src/core/load-fragment.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2012 Holger Hans Peter Freyther
   4 ***/
   5
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <linux/fs.h>
   9 #include <linux/oom.h>
  10 #include <sched.h>
  11 #include <sys/resource.h>
  12
  13 #include "sd-messages.h"
  14
  15 #include "af-list.h"
  16 #include "all-units.h"
  17 #include "alloc-util.h"
  18 #include "bpf-firewall.h"
  19 #include "bpf-lsm.h"
  20 #include "bpf-program.h"
  21 #include "bpf-socket-bind.h"
  22 #include "bus-error.h"
  23 #include "bus-internal.h"
  24 #include "bus-util.h"
  25 #include "cap-list.h"
  26 #include "capability-util.h"
  27 #include "cgroup-setup.h"
  28 #include "conf-parser.h"
  29 #include "core-varlink.h"
  30 #include "cpu-set-util.h"
  31 #include "creds-util.h"
  32 #include "env-util.h"
  33 #include "errno-list.h"
  34 #include "escape.h"
  35 #include "exec-credential.h"
  36 #include "execute.h"
  37 #include "fd-util.h"
  38 #include "fileio.h"
  39 #include "firewall-util.h"
  40 #include "fs-util.h"
  41 #include "hexdecoct.h"
  42 #include "iovec-util.h"
  43 #include "ioprio-util.h"
  44 #include "ip-protocol-list.h"
  45 #include "journal-file.h"
  46 #include "limits-util.h"
  47 #include "load-fragment.h"
  48 #include "log.h"
  49 #include "missing_ioprio.h"
  50 #include "mountpoint-util.h"
  51 #include "nulstr-util.h"
  52 #include "open-file.h"
  53 #include "parse-helpers.h"
  54 #include "parse-util.h"
  55 #include "path-util.h"
  56 #include "pcre2-util.h"
  57 #include "percent-util.h"
  58 #include "process-util.h"
  59 #include "seccomp-util.h"
  60 #include "securebits-util.h"
  61 #include "selinux-util.h"
  62 #include "signal-util.h"
  63 #include "socket-netlink.h"
  64 #include "specifier.h"
  65 #include "stat-util.h"
  66 #include "string-util.h"
  67 #include "strv.h"
  68 #include "syslog-util.h"
  69 #include "time-util.h"
  70 #include "unit-name.h"
  71 #include "unit-printf.h"
  72 #include "user-util.h"
  73 #include "utf8.h"
  74 #include "web-util.h"
  75
  76 static int parse_socket_protocol(const char *s) {
  77         int r;
  78
  79         r = parse_ip_protocol(s);
  80         if (r < 0)
  81                 return r;
  82         if (!IN_SET(r, IPPROTO_UDPLITE, IPPROTO_SCTP))
  83                 return -EPROTONOSUPPORT;
  84
  85         return r;
  86 }
  87
  88 int parse_crash_chvt(const char *value, int *data) {
  89         int b;
  90
  91         if (safe_atoi(value, data) >= 0)
  92                 return 0;
  93
  94         b = parse_boolean(value);
  95         if (b < 0)
  96                 return b;
  97
  98         if (b > 0)
  99                 *data = 0; /* switch to where kmsg goes */
 100         else
 101                 *data = -1; /* turn off switching */
 102
 103         return 0;
 104 }
 105
 106 int parse_confirm_spawn(const char *value, char **console) {
 107         char *s;
 108         int r;
 109
 110         r = value ? parse_boolean(value) : 1;
 111         if (r == 0) {
 112                 *console = NULL;
 113                 return 0;
 114         } else if (r > 0) /* on with default tty */
 115                 s = strdup("/dev/console");
 116         else if (is_path(value)) /* on with fully qualified path */
 117                 s = strdup(value);
 118         else /* on with only a tty file name, not a fully qualified path */
 119                 s = path_join("/dev/", value);
 120         if (!s)
 121                 return -ENOMEM;
 122
 123         *console = s;
 124         return 0;
 125 }
 126
 127 DEFINE_CONFIG_PARSE(config_parse_socket_protocol, parse_socket_protocol, "Failed to parse socket protocol");
 128 DEFINE_CONFIG_PARSE(config_parse_exec_secure_bits, secure_bits_from_string, "Failed to parse secure bits");
 129 DEFINE_CONFIG_PARSE_ENUM(config_parse_collect_mode, collect_mode, CollectMode, "Failed to parse garbage collection mode");
 130 DEFINE_CONFIG_PARSE_ENUM(config_parse_device_policy, cgroup_device_policy, CGroupDevicePolicy, "Failed to parse device policy");
 131 DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_keyring_mode, exec_keyring_mode, ExecKeyringMode, "Failed to parse keyring mode");
 132 DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_proc, protect_proc, ProtectProc, "Failed to parse /proc/ protection mode");
 133 DEFINE_CONFIG_PARSE_ENUM(config_parse_proc_subset, proc_subset, ProcSubset, "Failed to parse /proc/ subset mode");
 134 DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode, "Failed to parse utmp mode");
 135 DEFINE_CONFIG_PARSE_ENUM(config_parse_job_mode, job_mode, JobMode, "Failed to parse job mode");
 136 DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier");
 137 DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_home, protect_home, ProtectHome, "Failed to parse protect home value");
 138 DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_system, protect_system, ProtectSystem, "Failed to parse protect system value");
 139 DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_preserve_mode, exec_preserve_mode, ExecPreserveMode, "Failed to parse resource preserve mode");
 140 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type");
 141 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_exit_type, service_exit_type, ServiceExitType, "Failed to parse service exit type");
 142 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier");
 143 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart_mode, service_restart_mode, ServiceRestartMode, "Failed to parse service restart mode");
 144 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_timeout_failure_mode, service_timeout_failure_mode, ServiceTimeoutFailureMode, "Failed to parse timeout failure mode");
 145 DEFINE_CONFIG_PARSE_ENUM(config_parse_socket_bind, socket_address_bind_ipv6_only_or_bool, SocketAddressBindIPv6Only, "Failed to parse bind IPv6 only value");
 146 DEFINE_CONFIG_PARSE_ENUM(config_parse_oom_policy, oom_policy, OOMPolicy, "Failed to parse OOM policy");
 147 DEFINE_CONFIG_PARSE_ENUM(config_parse_managed_oom_preference, managed_oom_preference, ManagedOOMPreference, "Failed to parse ManagedOOMPreference=");
 148 DEFINE_CONFIG_PARSE_ENUM(config_parse_memory_pressure_watch, cgroup_pressure_watch, CGroupPressureWatch, "Failed to parse memory pressure watch setting");
 149 DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_ip_tos, ip_tos, int, -1, "Failed to parse IP TOS value");
 150 DEFINE_CONFIG_PARSE_PTR(config_parse_blockio_weight, cg_blkio_weight_parse, uint64_t, "Invalid block IO weight");
 151 DEFINE_CONFIG_PARSE_PTR(config_parse_cg_weight, cg_weight_parse, uint64_t, "Invalid weight");
 152 DEFINE_CONFIG_PARSE_PTR(config_parse_cg_cpu_weight, cg_cpu_weight_parse, uint64_t, "Invalid CPU weight");
 153 static DEFINE_CONFIG_PARSE_PTR(config_parse_cpu_shares_internal, cg_cpu_shares_parse, uint64_t, "Invalid CPU shares");
 154 DEFINE_CONFIG_PARSE_PTR(config_parse_exec_mount_propagation_flag, mount_propagation_flag_from_string, unsigned long, "Failed to parse mount propagation flag");
 155 DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_numa_policy, mpol, int, -1, "Invalid NUMA policy type");
 156 DEFINE_CONFIG_PARSE_ENUM(config_parse_status_unit_format, status_unit_format, StatusUnitFormat, "Failed to parse status unit format");
 157 DEFINE_CONFIG_PARSE_ENUM_FULL(config_parse_socket_timestamping, socket_timestamping_from_string_harder, SocketTimestamping, "Failed to parse timestamping precision");
 158
 159 int config_parse_cpu_shares(
 160                 const char *unit,
 161                 const char *filename,
 162                 unsigned line,
 163                 const char *section,
 164                 unsigned section_line,
 165                 const char *lvalue,
 166                 int ltype,
 167                 const char *rvalue,
 168                 void *data,
 169                 void *userdata) {
 170
 171         assert(filename);
 172         assert(lvalue);
 173         assert(rvalue);
 174
 175
 176         log_syntax(unit, LOG_WARNING, filename, line, 0,
 177                    "Unit uses %s=; please use CPUWeight= instead. Support for %s= will be removed soon.",
 178                    lvalue, lvalue);
 179
 180         return config_parse_cpu_shares_internal(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
 181 }
 182
 183 bool contains_instance_specifier_superset(const char *s) {
 184         const char *p, *q;
 185         bool percent = false;
 186
 187         assert(s);
 188
 189         p = strchr(s, '@');
 190         if (!p)
 191                 return false;
 192
 193         p++; /* Skip '@' */
 194
 195         q = strrchr(p, '.');
 196         if (!q)
 197                 q = p + strlen(p);
 198
 199         /* If the string is just the instance specifier, it's not a superset of the instance. */
 200         if (memcmp_nn(p, q - p, "%i", strlen("%i")) == 0)
 201                 return false;
 202
 203         /* %i, %n and %N all expand to the instance or a superset of it. */
 204         for (; p < q; p++)
 205                 if (*p == '%')
 206                         percent = !percent;
 207                 else if (percent) {
 208                         if (IN_SET(*p, 'n', 'N', 'i'))
 209                                 return true;
 210                         percent = false;
 211                 }
 212
 213         return false;
 214 }
 215
 216 /* `name` is the rendered version of `format` via `unit_printf` or similar functions. */
 217 int unit_is_likely_recursive_template_dependency(Unit *u, const char *name, const char *format) {
 218         const char *fragment_path;
 219         int r;
 220
 221         assert(u);
 222         assert(name);
 223
 224         /* If a template unit has a direct dependency on itself that includes the unit instance as part of
 225          * the template instance via a unit specifier (%i, %n or %N), this will almost certainly lead to
 226          * infinite recursion as systemd will keep instantiating new instances of the template unit.
 227          * https://github.com/systemd/systemd/issues/17602 shows a good example of how this can happen in
 228          * practice. To guard against this, we check for templates that depend on themselves and have the
 229          * instantiated unit instance included as part of the template instance of the dependency via a
 230          * specifier.
 231          *
 232          * For example, if systemd-notify@.service depends on systemd-notify@%n.service, this will result in
 233          * infinite recursion.
 234          */
 235
 236         if (!unit_name_is_valid(name, UNIT_NAME_INSTANCE))
 237                 return false;
 238
 239         if (!unit_name_prefix_equal(u->id, name))
 240                 return false;
 241
 242         if (u->type != unit_name_to_type(name))
 243                 return false;
 244
 245         r = unit_file_find_fragment(u->manager->unit_id_map, u->manager->unit_name_map, name, &fragment_path, NULL);
 246         if (r < 0)
 247                 return r;
 248
 249         /* Fragment paths should also be equal as a custom fragment for a specific template instance
 250          * wouldn't necessarily lead to infinite recursion. */
 251         if (!path_equal_ptr(u->fragment_path, fragment_path))
 252                 return false;
 253
 254         if (!contains_instance_specifier_superset(format))
 255                 return false;
 256
 257         return true;
 258 }
 259
 260 int config_parse_unit_deps(
 261                 const char *unit,
 262                 const char *filename,
 263                 unsigned line,
 264                 const char *section,
 265                 unsigned section_line,
 266                 const char *lvalue,
 267                 int ltype,
 268                 const char *rvalue,
 269                 void *data,
 270                 void *userdata) {
 271
 272         UnitDependency d = ltype;
 273         Unit *u = userdata;
 274
 275         assert(filename);
 276         assert(lvalue);
 277         assert(rvalue);
 278
 279         for (const char *p = rvalue;;) {
 280                 _cleanup_free_ char *word = NULL, *k = NULL;
 281                 int r;
 282
 283                 r = extract_first_word(&p, &word, NULL, EXTRACT_RETAIN_ESCAPE);
 284                 if (r == 0)
 285                         return 0;
 286                 if (r == -ENOMEM)
 287                         return log_oom();
 288                 if (r < 0) {
 289                         log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
 290                         return 0;
 291                 }
 292
 293                 r = unit_name_printf(u, word, &k);
 294                 if (r < 0) {
 295                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", word);
 296                         continue;
 297                 }
 298
 299                 r = unit_is_likely_recursive_template_dependency(u, k, word);
 300                 if (r < 0) {
 301                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to determine if '%s' is a recursive dependency, ignoring: %m", k);
 302                         continue;
 303                 }
 304                 if (r > 0) {
 305                         log_syntax(unit, LOG_DEBUG, filename, line, 0,
 306                                    "Dropping dependency %s=%s that likely leads to infinite recursion.",
 307                                    unit_dependency_to_string(d), word);
 308                         continue;
 309                 }
 310
 311                 r = unit_add_dependency_by_name(u, d, k, true, UNIT_DEPENDENCY_FILE);
 312                 if (r < 0)
 313                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);
 314         }
 315 }
 316
 317 int config_parse_obsolete_unit_deps(
 318                 const char *unit,
 319                 const char *filename,
 320                 unsigned line,
 321                 const char *section,
 322                 unsigned section_line,
 323                 const char *lvalue,
 324                 int ltype,
 325                 const char *rvalue,
 326                 void *data,
 327                 void *userdata) {
 328
 329         log_syntax(unit, LOG_WARNING, filename, line, 0,
 330                    "Unit dependency type %s= is obsolete, replacing by %s=, please update your unit file", lvalue, unit_dependency_to_string(ltype));
 331
 332         return config_parse_unit_deps(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
 333 }
 334
 335 int config_parse_unit_string_printf(
 336                 const char *unit,
 337                 const char *filename,
 338                 unsigned line,
 339                 const char *section,
 340                 unsigned section_line,
 341                 const char *lvalue,
 342                 int ltype,
 343                 const char *rvalue,
 344                 void *data,
 345                 void *userdata) {
 346
 347         _cleanup_free_ char *k = NULL;
 348         const Unit *u = ASSERT_PTR(userdata);
 349         int r;
 350
 351         assert(filename);
 352         assert(lvalue);
 353         assert(rvalue);
 354
 355         r = unit_full_printf(u, rvalue, &k);
 356         if (r < 0) {
 357                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
 358                 return 0;
 359         }
 360
 361         return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
 362 }
 363
 364 int config_parse_unit_strv_printf(
 365                 const char *unit,
 366                 const char *filename,
 367                 unsigned line,
 368                 const char *section,
 369                 unsigned section_line,
 370                 const char *lvalue,
 371                 int ltype,
 372                 const char *rvalue,
 373                 void *data,
 374                 void *userdata) {
 375
 376         const Unit *u = ASSERT_PTR(userdata);
 377         _cleanup_free_ char *k = NULL;
 378         int r;
 379
 380         assert(filename);
 381         assert(lvalue);
 382         assert(rvalue);
 383
 384         r = unit_full_printf(u, rvalue, &k);
 385         if (r < 0) {
 386                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
 387                 return 0;
 388         }
 389
 390         return config_parse_strv(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
 391 }
 392
 393 int config_parse_unit_path_printf(
 394                 const char *unit,
 395                 const char *filename,
 396                 unsigned line,
 397                 const char *section,
 398                 unsigned section_line,
 399                 const char *lvalue,
 400                 int ltype,
 401                 const char *rvalue,
 402                 void *data,
 403                 void *userdata) {
 404
 405         _cleanup_free_ char *k = NULL;
 406         const Unit *u = ASSERT_PTR(userdata);
 407         int r;
 408         bool fatal = ltype;
 409
 410         assert(filename);
 411         assert(lvalue);
 412         assert(rvalue);
 413
 414         r = unit_path_printf(u, rvalue, &k);
 415         if (r < 0) {
 416                 log_syntax(unit, fatal ? LOG_ERR : LOG_WARNING, filename, line, r,
 417                            "Failed to resolve unit specifiers in '%s'%s: %m",
 418                            rvalue, fatal ? "" : ", ignoring");
 419                 return fatal ? -ENOEXEC : 0;
 420         }
 421
 422         return config_parse_path(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
 423 }
 424
 425 int config_parse_colon_separated_paths(
 426                 const char *unit,
 427                 const char *filename,
 428                 unsigned line,
 429                 const char *section,
 430                 unsigned section_line,
 431                 const char *lvalue,
 432                 int ltype,
 433                 const char *rvalue,
 434                 void *data,
 435                 void *userdata) {
 436         char ***sv = ASSERT_PTR(data);
 437         const Unit *u = userdata;
 438         int r;
 439
 440         assert(filename);
 441         assert(lvalue);
 442         assert(rvalue);
 443
 444         if (isempty(rvalue)) {
 445                 /* Empty assignment resets the list */
 446                 *sv = strv_free(*sv);
 447                 return 0;
 448         }
 449
 450         for (const char *p = rvalue;;) {
 451                 _cleanup_free_ char *word = NULL, *k = NULL;
 452
 453                 r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
 454                 if (r == -ENOMEM)
 455                         return log_oom();
 456                 if (r < 0) {
 457                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract first word, ignoring: %s", rvalue);
 458                         return 0;
 459                 }
 460                 if (r == 0)
 461                         break;
 462
 463                 r = unit_path_printf(u, word, &k);
 464                 if (r < 0) {
 465                         log_syntax(unit, LOG_WARNING, filename, line, r,
 466                                    "Failed to resolve unit specifiers in '%s', ignoring: %m", word);
 467                         return 0;
 468                 }
 469
 470                 r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
 471                 if (r < 0)
 472                         return 0;
 473
 474                 r = strv_consume(sv, TAKE_PTR(k));
 475                 if (r < 0)
 476                         return log_oom();
 477         }
 478
 479         return 0;
 480 }
 481
 482 int config_parse_unit_path_strv_printf(
 483                 const char *unit,
 484                 const char *filename,
 485                 unsigned line,
 486                 const char *section,
 487                 unsigned section_line,
 488                 const char *lvalue,
 489                 int ltype,
 490                 const char *rvalue,
 491                 void *data,
 492                 void *userdata) {
 493
 494         char ***x = data;
 495         const Unit *u = ASSERT_PTR(userdata);
 496         int r;
 497
 498         assert(filename);
 499         assert(lvalue);
 500         assert(rvalue);
 501
 502         if (isempty(rvalue)) {
 503                 *x = strv_free(*x);
 504                 return 0;
 505         }
 506
 507         for (const char *p = rvalue;;) {
 508                 _cleanup_free_ char *word = NULL, *k = NULL;
 509
 510                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
 511                 if (r == 0)
 512                         return 0;
 513                 if (r == -ENOMEM)
 514                         return log_oom();
 515                 if (r < 0) {
 516                         log_syntax(unit, LOG_WARNING, filename, line, r,
 517                                    "Invalid syntax, ignoring: %s", rvalue);
 518                         return 0;
 519                 }
 520
 521                 r = unit_path_printf(u, word, &k);
 522                 if (r < 0) {
 523                         log_syntax(unit, LOG_WARNING, filename, line, r,
 524                                    "Failed to resolve unit specifiers in '%s', ignoring: %m", word);
 525                         return 0;
 526                 }
 527
 528                 r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
 529                 if (r < 0)
 530                         return 0;
 531
 532                 r = strv_consume(x, TAKE_PTR(k));
 533                 if (r < 0)
 534                         return log_oom();
 535         }
 536 }
 537
 538 static int patch_var_run(
 539                 const char *unit,
 540                 const char *filename,
 541                 unsigned line,
 542                 const char *lvalue,
 543                 char **path) {
 544
 545         const char *e;
 546         char *z;
 547
 548         e = path_startswith(*path, "/var/run/");
 549         if (!e)
 550                 return 0;
 551
 552         z = path_join("/run/", e);
 553         if (!z)
 554                 return log_oom();
 555
 556         log_syntax(unit, LOG_NOTICE, filename, line, 0,
 557                    "%s= references a path below legacy directory /var/run/, updating %s → %s; "
 558                    "please update the unit file accordingly.", lvalue, *path, z);
 559
 560         free_and_replace(*path, z);
 561
 562         return 1;
 563 }
 564
 565 int config_parse_socket_listen(
 566                 const char *unit,
 567                 const char *filename,
 568                 unsigned line,
 569                 const char *section,
 570                 unsigned section_line,
 571                 const char *lvalue,
 572                 int ltype,
 573                 const char *rvalue,
 574                 void *data,
 575                 void *userdata) {
 576
 577         _cleanup_free_ SocketPort *p = NULL;
 578         SocketPort *tail;
 579         Socket *s;
 580         int r;
 581
 582         assert(filename);
 583         assert(lvalue);
 584         assert(rvalue);
 585         assert(data);
 586
 587         s = SOCKET(data);
 588
 589         if (isempty(rvalue)) {
 590                 /* An empty assignment removes all ports */
 591                 socket_free_ports(s);
 592                 return 0;
 593         }
 594
 595         p = new0(SocketPort, 1);
 596         if (!p)
 597                 return log_oom();
 598
 599         if (ltype != SOCKET_SOCKET) {
 600                 _cleanup_free_ char *k = NULL;
 601
 602                 r = unit_path_printf(UNIT(s), rvalue, &k);
 603                 if (r < 0) {
 604                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
 605                         return 0;
 606                 }
 607
 608                 r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
 609                 if (r < 0)
 610                         return 0;
 611
 612                 if (ltype == SOCKET_FIFO) {
 613                         r = patch_var_run(unit, filename, line, lvalue, &k);
 614                         if (r < 0)
 615                                 return r;
 616                 }
 617
 618                 free_and_replace(p->path, k);
 619                 p->type = ltype;
 620
 621         } else if (streq(lvalue, "ListenNetlink")) {
 622                 _cleanup_free_ char  *k = NULL;
 623
 624                 r = unit_path_printf(UNIT(s), rvalue, &k);
 625                 if (r < 0) {
 626                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
 627                         return 0;
 628                 }
 629
 630                 r = socket_address_parse_netlink(&p->address, k);
 631                 if (r < 0) {
 632                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse address value in '%s', ignoring: %m", k);
 633                         return 0;
 634                 }
 635
 636                 p->type = SOCKET_SOCKET;
 637
 638         } else {
 639                 _cleanup_free_ char *k = NULL;
 640
 641                 r = unit_path_printf(UNIT(s), rvalue, &k);
 642                 if (r < 0) {
 643                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
 644                         return 0;
 645                 }
 646
 647                 if (k[0] == '/') { /* Only for AF_UNIX file system sockets… */
 648                         r = patch_var_run(unit, filename, line, lvalue, &k);
 649                         if (r < 0)
 650                                 return r;
 651                 }
 652
 653                 r = socket_address_parse_and_warn(&p->address, k);
 654                 if (r < 0) {
 655                         if (r != -EAFNOSUPPORT)
 656                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse address value in '%s', ignoring: %m", k);
 657                         return 0;
 658                 }
 659
 660                 if (streq(lvalue, "ListenStream"))
 661                         p->address.type = SOCK_STREAM;
 662                 else if (streq(lvalue, "ListenDatagram"))
 663                         p->address.type = SOCK_DGRAM;
 664                 else {
 665                         assert(streq(lvalue, "ListenSequentialPacket"));
 666                         p->address.type = SOCK_SEQPACKET;
 667                 }
 668
 669                 if (socket_address_family(&p->address) != AF_UNIX && p->address.type == SOCK_SEQPACKET) {
 670                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Address family not supported, ignoring: %s", rvalue);
 671                         return 0;
 672                 }
 673
 674                 p->type = SOCKET_SOCKET;
 675         }
 676
 677         p->fd = -EBADF;
 678         p->auxiliary_fds = NULL;
 679         p->n_auxiliary_fds = 0;
 680         p->socket = s;
 681
 682         tail = LIST_FIND_TAIL(port, s->ports);
 683         LIST_INSERT_AFTER(port, s->ports, tail, p);
 684
 685         p = NULL;
 686
 687         return 0;
 688 }
 689
 690 int config_parse_exec_nice(
 691                 const char *unit,
 692                 const char *filename,
 693                 unsigned line,
 694                 const char *section,
 695                 unsigned section_line,
 696                 const char *lvalue,
 697                 int ltype,
 698                 const char *rvalue,
 699                 void *data,
 700                 void *userdata) {
 701
 702         ExecContext *c = ASSERT_PTR(data);
 703         int priority, r;
 704
 705         assert(filename);
 706         assert(lvalue);
 707         assert(rvalue);
 708
 709         if (isempty(rvalue)) {
 710                 c->nice_set = false;
 711                 return 0;
 712         }
 713
 714         r = parse_nice(rvalue, &priority);
 715         if (r < 0) {
 716                 if (r == -ERANGE)
 717                         log_syntax(unit, LOG_WARNING, filename, line, r, "Nice priority out of range, ignoring: %s", rvalue);
 718                 else
 719                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse nice priority '%s', ignoring: %m", rvalue);
 720                 return 0;
 721         }
 722
 723         c->nice = priority;
 724         c->nice_set = true;
 725
 726         return 0;
 727 }
 728
 729 int config_parse_exec_oom_score_adjust(
 730                 const char* unit,
 731                 const char *filename,
 732                 unsigned line,
 733                 const char *section,
 734                 unsigned section_line,
 735                 const char *lvalue,
 736                 int ltype,
 737                 const char *rvalue,
 738                 void *data,
 739                 void *userdata) {
 740
 741         ExecContext *c = ASSERT_PTR(data);
 742         int oa, r;
 743
 744         assert(filename);
 745         assert(lvalue);
 746         assert(rvalue);
 747
 748         if (isempty(rvalue)) {
 749                 c->oom_score_adjust_set = false;
 750                 return 0;
 751         }
 752
 753         r = parse_oom_score_adjust(rvalue, &oa);
 754         if (r < 0) {
 755                 if (r == -ERANGE)
 756                         log_syntax(unit, LOG_WARNING, filename, line, r, "OOM score adjust value out of range, ignoring: %s", rvalue);
 757                 else
 758                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse the OOM score adjust value '%s', ignoring: %m", rvalue);
 759                 return 0;
 760         }
 761
 762         c->oom_score_adjust = oa;
 763         c->oom_score_adjust_set = true;
 764
 765         return 0;
 766 }
 767
 768 int config_parse_exec_coredump_filter(
 769                 const char* unit,
 770                 const char *filename,
 771                 unsigned line,
 772                 const char *section,
 773                 unsigned section_line,
 774                 const char *lvalue,
 775                 int ltype,
 776                 const char *rvalue,
 777                 void *data,
 778                 void *userdata) {
 779
 780         ExecContext *c = ASSERT_PTR(data);
 781         int r;
 782
 783         assert(filename);
 784         assert(lvalue);
 785         assert(rvalue);
 786
 787         if (isempty(rvalue)) {
 788                 c->coredump_filter = 0;
 789                 c->coredump_filter_set = false;
 790                 return 0;
 791         }
 792
 793         uint64_t f;
 794         r = coredump_filter_mask_from_string(rvalue, &f);
 795         if (r < 0) {
 796                 log_syntax(unit, LOG_WARNING, filename, line, r,
 797                            "Failed to parse the CoredumpFilter=%s, ignoring: %m", rvalue);
 798                 return 0;
 799         }
 800
 801         c->coredump_filter |= f;
 802         c->coredump_filter_set = true;
 803         return 0;
 804 }
 805
 806 int config_parse_kill_mode(
 807                 const char* unit,
 808                 const char *filename,
 809                 unsigned line,
 810                 const char *section,
 811                 unsigned section_line,
 812                 const char *lvalue,
 813                 int ltype,
 814                 const char *rvalue,
 815                 void *data,
 816                 void *userdata) {
 817
 818         KillMode *k = data, m;
 819
 820         assert(filename);
 821         assert(lvalue);
 822         assert(rvalue);
 823         assert(data);
 824
 825         if (isempty(rvalue)) {
 826                 *k = KILL_CONTROL_GROUP;
 827                 return 0;
 828         }
 829
 830         m = kill_mode_from_string(rvalue);
 831         if (m < 0) {
 832                 log_syntax(unit, LOG_WARNING, filename, line, m,
 833                            "Failed to parse kill mode specification, ignoring: %s", rvalue);
 834                 return 0;
 835         }
 836
 837         if (m == KILL_NONE)
 838                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 839                            "Unit uses KillMode=none. "
 840                            "This is unsafe, as it disables systemd's process lifecycle management for the service. "
 841                            "Please update the service to use a safer KillMode=, such as 'mixed' or 'control-group'. "
 842                            "Support for KillMode=none is deprecated and will eventually be removed.");
 843
 844         *k = m;
 845         return 0;
 846 }
 847
 848 int config_parse_exec(
 849                 const char *unit,
 850                 const char *filename,
 851                 unsigned line,
 852                 const char *section,
 853                 unsigned section_line,
 854                 const char *lvalue,
 855                 int ltype,
 856                 const char *rvalue,
 857                 void *data,
 858                 void *userdata) {
 859
 860         ExecCommand **e = ASSERT_PTR(data);
 861         const Unit *u = userdata;
 862         const char *p;
 863         bool semicolon;
 864         int r;
 865
 866         assert(filename);
 867         assert(lvalue);
 868         assert(rvalue);
 869
 870         e += ltype;
 871
 872         if (isempty(rvalue)) {
 873                 /* An empty assignment resets the list */
 874                 *e = exec_command_free_list(*e);
 875                 return 0;
 876         }
 877
 878         p = rvalue;
 879         do {
 880                 _cleanup_free_ char *path = NULL, *firstword = NULL;
 881                 ExecCommandFlags flags = 0;
 882                 bool ignore = false, separate_argv0 = false;
 883                 _cleanup_free_ ExecCommand *nce = NULL;
 884                 _cleanup_strv_free_ char **n = NULL;
 885                 size_t nlen = 0;
 886                 const char *f;
 887
 888                 semicolon = false;
 889
 890                 r = extract_first_word_and_warn(&p, &firstword, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);
 891                 if (r <= 0)
 892                         return 0;
 893
 894                 /* A lone ";" is a separator. Let's make sure we don't treat it as an executable name. */
 895                 if (streq(firstword, ";")) {
 896                         semicolon = true;
 897                         continue;
 898                 }
 899
 900                 f = firstword;
 901                 for (;;) {
 902                         /* We accept an absolute path as first argument.  If it's prefixed with - and the path doesn't
 903                          * exist, we ignore it instead of erroring out; if it's prefixed with @, we allow overriding of
 904                          * argv[0]; if it's prefixed with :, we will not do environment variable substitution;
 905                          * if it's prefixed with +, it will be run with full privileges and no sandboxing; if
 906                          * it's prefixed with '!' we apply sandboxing, but do not change user/group credentials; if
 907                          * it's prefixed with '!!', then we apply user/group credentials if the kernel supports ambient
 908                          * capabilities -- if it doesn't we don't apply the credentials themselves, but do apply most
 909                          * other sandboxing, with some special exceptions for changing UID.
 910                          *
 911                          * The idea is that '!!' may be used to write services that can take benefit of systemd's
 912                          * UID/GID dropping if the kernel supports ambient creds, but provide an automatic fallback to
 913                          * privilege dropping within the daemon if the kernel does not offer that. */
 914
 915                         if (*f == '-' && !(flags & EXEC_COMMAND_IGNORE_FAILURE)) {
 916                                 flags |= EXEC_COMMAND_IGNORE_FAILURE;
 917                                 ignore = true;
 918                         } else if (*f == '@' && !separate_argv0)
 919                                 separate_argv0 = true;
 920                         else if (*f == ':' && !(flags & EXEC_COMMAND_NO_ENV_EXPAND))
 921                                 flags |= EXEC_COMMAND_NO_ENV_EXPAND;
 922                         else if (*f == '+' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC)))
 923                                 flags |= EXEC_COMMAND_FULLY_PRIVILEGED;
 924                         else if (*f == '!' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC)))
 925                                 flags |= EXEC_COMMAND_NO_SETUID;
 926                         else if (*f == '!' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_AMBIENT_MAGIC))) {
 927                                 flags &= ~EXEC_COMMAND_NO_SETUID;
 928                                 flags |= EXEC_COMMAND_AMBIENT_MAGIC;
 929                         } else
 930                                 break;
 931                         f++;
 932                 }
 933
 934                 r = unit_path_printf(u, f, &path);
 935                 if (r < 0) {
 936                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,
 937                                    "Failed to resolve unit specifiers in '%s'%s: %m",
 938                                    f, ignore ? ", ignoring" : "");
 939                         return ignore ? 0 : -ENOEXEC;
 940                 }
 941
 942                 if (isempty(path)) {
 943                         /* First word is either "-" or "@" with no command. */
 944                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,
 945                                    "Empty path in command line%s: '%s'",
 946                                    ignore ? ", ignoring" : "", rvalue);
 947                         return ignore ? 0 : -ENOEXEC;
 948                 }
 949                 if (!string_is_safe(path)) {
 950                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,
 951                                    "Executable name contains special characters%s: %s",
 952                                    ignore ? ", ignoring" : "", path);
 953                         return ignore ? 0 : -ENOEXEC;
 954                 }
 955                 if (endswith(path, "/")) {
 956                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,
 957                                    "Executable path specifies a directory%s: %s",
 958                                    ignore ? ", ignoring" : "", path);
 959                         return ignore ? 0 : -ENOEXEC;
 960                 }
 961
 962                 if (!(path_is_absolute(path) ? path_is_valid(path) : filename_is_valid(path))) {
 963                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,
 964                                    "Neither a valid executable name nor an absolute path%s: %s",
 965                                    ignore ? ", ignoring" : "", path);
 966                         return ignore ? 0 : -ENOEXEC;
 967                 }
 968
 969                 if (!separate_argv0) {
 970                         char *w = NULL;
 971
 972                         if (!GREEDY_REALLOC0(n, nlen + 2))
 973                                 return log_oom();
 974
 975                         w = strdup(path);
 976                         if (!w)
 977                                 return log_oom();
 978                         n[nlen++] = w;
 979                         n[nlen] = NULL;
 980                 }
 981
 982                 path_simplify(path);
 983
 984                 while (!isempty(p)) {
 985                         _cleanup_free_ char *word = NULL, *resolved = NULL;
 986
 987                         /* Check explicitly for an unquoted semicolon as
 988                          * command separator token.  */
 989                         if (p[0] == ';' && (!p[1] || strchr(WHITESPACE, p[1]))) {
 990                                 p++;
 991                                 p += strspn(p, WHITESPACE);
 992                                 semicolon = true;
 993                                 break;
 994                         }
 995
 996                         /* Check for \; explicitly, to not confuse it with \\; or "\;" or "\\;" etc.
 997                          * extract_first_word() would return the same for all of those.  */
 998                         if (p[0] == '\\' && p[1] == ';' && (!p[2] || strchr(WHITESPACE, p[2]))) {
 999                                 char *w;
1000
1001                                 p += 2;
1002                                 p += strspn(p, WHITESPACE);
1003
1004                                 if (!GREEDY_REALLOC0(n, nlen + 2))
1005                                         return log_oom();
1006
1007                                 w = strdup(";");
1008                                 if (!w)
1009                                         return log_oom();
1010                                 n[nlen++] = w;
1011                                 n[nlen] = NULL;
1012                                 continue;
1013                         }
1014
1015                         r = extract_first_word_and_warn(&p, &word, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);
1016                         if (r == 0)
1017                                 break;
1018                         if (r < 0)
1019                                 return ignore ? 0 : -ENOEXEC;
1020
1021                         r = unit_full_printf(u, word, &resolved);
1022                         if (r < 0) {
1023                                 log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,
1024                                            "Failed to resolve unit specifiers in %s%s: %m",
1025                                            word, ignore ? ", ignoring" : "");
1026                                 return ignore ? 0 : -ENOEXEC;
1027                         }
1028
1029                         if (!GREEDY_REALLOC(n, nlen + 2))
1030                                 return log_oom();
1031
1032                         n[nlen++] = TAKE_PTR(resolved);
1033                         n[nlen] = NULL;
1034                 }
1035
1036                 if (!n || !n[0]) {
1037                         log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,
1038                                    "Empty executable name or zeroeth argument%s: %s",
1039                                    ignore ? ", ignoring" : "", rvalue);
1040                         return ignore ? 0 : -ENOEXEC;
1041                 }
1042
1043                 nce = new0(ExecCommand, 1);
1044                 if (!nce)
1045                         return log_oom();
1046
1047                 nce->argv = TAKE_PTR(n);
1048                 nce->path = TAKE_PTR(path);
1049                 nce->flags = flags;
1050
1051                 exec_command_append_list(e, nce);
1052
1053                 /* Do not _cleanup_free_ these. */
1054                 nce = NULL;
1055
1056                 rvalue = p;
1057         } while (semicolon);
1058
1059         return 0;
1060 }
1061
1062 int config_parse_socket_bindtodevice(
1063                 const char* unit,
1064                 const char *filename,
1065                 unsigned line,
1066                 const char *section,
1067                 unsigned section_line,
1068                 const char *lvalue,
1069                 int ltype,
1070                 const char *rvalue,
1071                 void *data,
1072                 void *userdata) {
1073
1074         Socket *s = ASSERT_PTR(data);
1075
1076         assert(filename);
1077         assert(lvalue);
1078         assert(rvalue);
1079
1080         if (isempty(rvalue) || streq(rvalue, "*")) {
1081                 s->bind_to_device = mfree(s->bind_to_device);
1082                 return 0;
1083         }
1084
1085         if (!ifname_valid(rvalue)) {
1086                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid interface name, ignoring: %s", rvalue);
1087                 return 0;
1088         }
1089
1090         return free_and_strdup_warn(&s->bind_to_device, rvalue);
1091 }
1092
1093 int config_parse_exec_input(
1094                 const char *unit,
1095                 const char *filename,
1096                 unsigned line,
1097                 const char *section,
1098                 unsigned section_line,
1099                 const char *lvalue,
1100                 int ltype,
1101                 const char *rvalue,
1102                 void *data,
1103                 void *userdata) {
1104
1105         ExecContext *c = ASSERT_PTR(data);
1106         const Unit *u = userdata;
1107         const char *n;
1108         ExecInput ei;
1109         int r;
1110
1111         assert(filename);
1112         assert(line);
1113         assert(rvalue);
1114
1115         n = startswith(rvalue, "fd:");
1116         if (n) {
1117                 _cleanup_free_ char *resolved = NULL;
1118
1119                 r = unit_fd_printf(u, n, &resolved);
1120                 if (r < 0) {
1121                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", n);
1122                         return 0;
1123                 }
1124
1125                 if (isempty(resolved))
1126                         resolved = mfree(resolved);
1127                 else if (!fdname_is_valid(resolved)) {
1128                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid file descriptor name, ignoring: %s", resolved);
1129                         return 0;
1130                 }
1131
1132                 free_and_replace(c->stdio_fdname[STDIN_FILENO], resolved);
1133
1134                 ei = EXEC_INPUT_NAMED_FD;
1135
1136         } else if ((n = startswith(rvalue, "file:"))) {
1137                 _cleanup_free_ char *resolved = NULL;
1138
1139                 r = unit_path_printf(u, n, &resolved);
1140                 if (r < 0) {
1141                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", n);
1142                         return 0;
1143                 }
1144
1145                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE | PATH_CHECK_FATAL, unit, filename, line, lvalue);
1146                 if (r < 0)
1147                         return 0;
1148
1149                 free_and_replace(c->stdio_file[STDIN_FILENO], resolved);
1150
1151                 ei = EXEC_INPUT_FILE;
1152
1153         } else {
1154                 ei = exec_input_from_string(rvalue);
1155                 if (ei < 0) {
1156                         log_syntax(unit, LOG_WARNING, filename, line, ei, "Failed to parse input specifier, ignoring: %s", rvalue);
1157                         return 0;
1158                 }
1159         }
1160
1161         c->std_input = ei;
1162         return 0;
1163 }
1164
1165 int config_parse_exec_input_text(
1166                 const char *unit,
1167                 const char *filename,
1168                 unsigned line,
1169                 const char *section,
1170                 unsigned section_line,
1171                 const char *lvalue,
1172                 int ltype,
1173                 const char *rvalue,
1174                 void *data,
1175                 void *userdata) {
1176
1177         _cleanup_free_ char *unescaped = NULL, *resolved = NULL;
1178         ExecContext *c = ASSERT_PTR(data);
1179         const Unit *u = userdata;
1180         int r;
1181
1182         assert(filename);
1183         assert(line);
1184         assert(rvalue);
1185
1186         if (isempty(rvalue)) {
1187                 /* Reset if the empty string is assigned */
1188                 c->stdin_data = mfree(c->stdin_data);
1189                 c->stdin_data_size = 0;
1190                 return 0;
1191         }
1192
1193         ssize_t l = cunescape(rvalue, 0, &unescaped);
1194         if (l < 0) {
1195                 log_syntax(unit, LOG_WARNING, filename, line, l,
1196                            "Failed to decode C escaped text '%s', ignoring: %m", rvalue);
1197                 return 0;
1198         }
1199
1200         r = unit_full_printf_full(u, unescaped, EXEC_STDIN_DATA_MAX, &resolved);
1201         if (r < 0) {
1202                 log_syntax(unit, LOG_WARNING, filename, line, r,
1203                            "Failed to resolve unit specifiers in '%s', ignoring: %m", unescaped);
1204                 return 0;
1205         }
1206
1207         size_t sz = strlen(resolved);
1208         if (c->stdin_data_size + sz + 1 < c->stdin_data_size || /* check for overflow */
1209             c->stdin_data_size + sz + 1 > EXEC_STDIN_DATA_MAX) {
1210                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1211                            "Standard input data too large (%zu), maximum of %zu permitted, ignoring.",
1212                            c->stdin_data_size + sz, (size_t) EXEC_STDIN_DATA_MAX);
1213                 return 0;
1214         }
1215
1216         void *p = realloc(c->stdin_data, c->stdin_data_size + sz + 1);
1217         if (!p)
1218                 return log_oom();
1219
1220         *((char*) mempcpy((char*) p + c->stdin_data_size, resolved, sz)) = '\n';
1221
1222         c->stdin_data = p;
1223         c->stdin_data_size += sz + 1;
1224
1225         return 0;
1226 }
1227
1228 int config_parse_exec_input_data(
1229                 const char *unit,
1230                 const char *filename,
1231                 unsigned line,
1232                 const char *section,
1233                 unsigned section_line,
1234                 const char *lvalue,
1235                 int ltype,
1236                 const char *rvalue,
1237                 void *data,
1238                 void *userdata) {
1239
1240         _cleanup_free_ void *p = NULL;
1241         ExecContext *c = ASSERT_PTR(data);
1242         size_t sz;
1243         void *q;
1244         int r;
1245
1246         assert(filename);
1247         assert(line);
1248         assert(rvalue);
1249
1250         if (isempty(rvalue)) {
1251                 /* Reset if the empty string is assigned */
1252                 c->stdin_data = mfree(c->stdin_data);
1253                 c->stdin_data_size = 0;
1254                 return 0;
1255         }
1256
1257         r = unbase64mem(rvalue, SIZE_MAX, &p, &sz);
1258         if (r < 0) {
1259                 log_syntax(unit, LOG_WARNING, filename, line, r,
1260                            "Failed to decode base64 data, ignoring: %s", rvalue);
1261                 return 0;
1262         }
1263
1264         assert(sz > 0);
1265
1266         if (c->stdin_data_size + sz < c->stdin_data_size || /* check for overflow */
1267             c->stdin_data_size + sz > EXEC_STDIN_DATA_MAX) {
1268                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1269                            "Standard input data too large (%zu), maximum of %zu permitted, ignoring.",
1270                            c->stdin_data_size + sz, (size_t) EXEC_STDIN_DATA_MAX);
1271                 return 0;
1272         }
1273
1274         q = realloc(c->stdin_data, c->stdin_data_size + sz);
1275         if (!q)
1276                 return log_oom();
1277
1278         memcpy((uint8_t*) q + c->stdin_data_size, p, sz);
1279
1280         c->stdin_data = q;
1281         c->stdin_data_size += sz;
1282
1283         return 0;
1284 }
1285
1286 int config_parse_exec_output(
1287                 const char *unit,
1288                 const char *filename,
1289                 unsigned line,
1290                 const char *section,
1291                 unsigned section_line,
1292                 const char *lvalue,
1293                 int ltype,
1294                 const char *rvalue,
1295                 void *data,
1296                 void *userdata) {
1297
1298         _cleanup_free_ char *resolved = NULL;
1299         const char *n;
1300         ExecContext *c = ASSERT_PTR(data);
1301         const Unit *u = userdata;
1302         bool obsolete = false;
1303         ExecOutput eo;
1304         int r;
1305
1306         assert(filename);
1307         assert(line);
1308         assert(lvalue);
1309         assert(rvalue);
1310
1311         n = startswith(rvalue, "fd:");
1312         if (n) {
1313                 r = unit_fd_printf(u, n, &resolved);
1314                 if (r < 0) {
1315                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s: %m", n);
1316                         return 0;
1317                 }
1318
1319                 if (isempty(resolved))
1320                         resolved = mfree(resolved);
1321                 else if (!fdname_is_valid(resolved)) {
1322                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid file descriptor name, ignoring: %s", resolved);
1323                         return 0;
1324                 }
1325
1326                 eo = EXEC_OUTPUT_NAMED_FD;
1327
1328         } else if (streq(rvalue, "syslog")) {
1329                 eo = EXEC_OUTPUT_JOURNAL;
1330                 obsolete = true;
1331
1332         } else if (streq(rvalue, "syslog+console")) {
1333                 eo = EXEC_OUTPUT_JOURNAL_AND_CONSOLE;
1334                 obsolete = true;
1335
1336         } else if ((n = startswith(rvalue, "file:"))) {
1337
1338                 r = unit_path_printf(u, n, &resolved);
1339                 if (r < 0) {
1340                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", n);
1341                         return 0;
1342                 }
1343
1344                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE | PATH_CHECK_FATAL, unit, filename, line, lvalue);
1345                 if (r < 0)
1346                         return 0;
1347
1348                 eo = EXEC_OUTPUT_FILE;
1349
1350         } else if ((n = startswith(rvalue, "append:"))) {
1351
1352                 r = unit_path_printf(u, n, &resolved);
1353                 if (r < 0) {
1354                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", n);
1355                         return 0;
1356                 }
1357
1358                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE | PATH_CHECK_FATAL, unit, filename, line, lvalue);
1359                 if (r < 0)
1360                         return 0;
1361
1362                 eo = EXEC_OUTPUT_FILE_APPEND;
1363
1364         } else if ((n = startswith(rvalue, "truncate:"))) {
1365
1366                 r = unit_path_printf(u, n, &resolved);
1367                 if (r < 0) {
1368                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", n);
1369                         return 0;
1370                 }
1371
1372                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE | PATH_CHECK_FATAL, unit, filename, line, lvalue);
1373                 if (r < 0)
1374                         return 0;
1375
1376                 eo = EXEC_OUTPUT_FILE_TRUNCATE;
1377         } else {
1378                 eo = exec_output_from_string(rvalue);
1379                 if (eo < 0) {
1380                         log_syntax(unit, LOG_WARNING, filename, line, eo, "Failed to parse output specifier, ignoring: %s", rvalue);
1381                         return 0;
1382                 }
1383         }
1384
1385         if (obsolete)
1386                 log_syntax(unit, LOG_NOTICE, filename, line, 0,
1387                            "Standard output type %s is obsolete, automatically updating to %s. Please update your unit file, and consider removing the setting altogether.",
1388                            rvalue, exec_output_to_string(eo));
1389
1390         if (streq(lvalue, "StandardOutput")) {
1391                 if (eo == EXEC_OUTPUT_NAMED_FD)
1392                         free_and_replace(c->stdio_fdname[STDOUT_FILENO], resolved);
1393                 else
1394                         free_and_replace(c->stdio_file[STDOUT_FILENO], resolved);
1395
1396                 c->std_output = eo;
1397
1398         } else {
1399                 assert(streq(lvalue, "StandardError"));
1400
1401                 if (eo == EXEC_OUTPUT_NAMED_FD)
1402                         free_and_replace(c->stdio_fdname[STDERR_FILENO], resolved);
1403                 else
1404                         free_and_replace(c->stdio_file[STDERR_FILENO], resolved);
1405
1406                 c->std_error = eo;
1407         }
1408
1409         return 0;
1410 }
1411
1412 int config_parse_exec_io_class(const char *unit,
1413                                const char *filename,
1414                                unsigned line,
1415                                const char *section,
1416                                unsigned section_line,
1417                                const char *lvalue,
1418                                int ltype,
1419                                const char *rvalue,
1420                                void *data,
1421                                void *userdata) {
1422
1423         ExecContext *c = ASSERT_PTR(data);
1424         int x;
1425
1426         assert(filename);
1427         assert(lvalue);
1428         assert(rvalue);
1429
1430         if (isempty(rvalue)) {
1431                 c->ioprio_set = false;
1432                 c->ioprio = IOPRIO_DEFAULT_CLASS_AND_PRIO;
1433                 return 0;
1434         }
1435
1436         x = ioprio_class_from_string(rvalue);
1437         if (x < 0) {
1438                 log_syntax(unit, LOG_WARNING, filename, line, x, "Failed to parse IO scheduling class, ignoring: %s", rvalue);
1439                 return 0;
1440         }
1441
1442         c->ioprio = ioprio_normalize(ioprio_prio_value(x, ioprio_prio_data(c->ioprio)));
1443         c->ioprio_set = true;
1444
1445         return 0;
1446 }
1447
1448 int config_parse_exec_io_priority(const char *unit,
1449                                   const char *filename,
1450                                   unsigned line,
1451                                   const char *section,
1452                                   unsigned section_line,
1453                                   const char *lvalue,
1454                                   int ltype,
1455                                   const char *rvalue,
1456                                   void *data,
1457                                   void *userdata) {
1458
1459         ExecContext *c = ASSERT_PTR(data);
1460         int i, r;
1461
1462         assert(filename);
1463         assert(lvalue);
1464         assert(rvalue);
1465
1466         if (isempty(rvalue)) {
1467                 c->ioprio_set = false;
1468                 c->ioprio = IOPRIO_DEFAULT_CLASS_AND_PRIO;
1469                 return 0;
1470         }
1471
1472         r = ioprio_parse_priority(rvalue, &i);
1473         if (r < 0) {
1474                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse IO priority, ignoring: %s", rvalue);
1475                 return 0;
1476         }
1477
1478         c->ioprio = ioprio_normalize(ioprio_prio_value(ioprio_prio_class(c->ioprio), i));
1479         c->ioprio_set = true;
1480
1481         return 0;
1482 }
1483
1484 int config_parse_exec_cpu_sched_policy(const char *unit,
1485                                        const char *filename,
1486                                        unsigned line,
1487                                        const char *section,
1488                                        unsigned section_line,
1489                                        const char *lvalue,
1490                                        int ltype,
1491                                        const char *rvalue,
1492                                        void *data,
1493                                        void *userdata) {
1494
1495         ExecContext *c = ASSERT_PTR(data);
1496         int x;
1497
1498         assert(filename);
1499         assert(lvalue);
1500         assert(rvalue);
1501
1502         if (isempty(rvalue)) {
1503                 c->cpu_sched_set = false;
1504                 c->cpu_sched_policy = SCHED_OTHER;
1505                 c->cpu_sched_priority = 0;
1506                 return 0;
1507         }
1508
1509         x = sched_policy_from_string(rvalue);
1510         if (x < 0) {
1511                 log_syntax(unit, LOG_WARNING, filename, line, x, "Failed to parse CPU scheduling policy, ignoring: %s", rvalue);
1512                 return 0;
1513         }
1514
1515         c->cpu_sched_policy = x;
1516         /* Moving to or from real-time policy? We need to adjust the priority */
1517         c->cpu_sched_priority = CLAMP(c->cpu_sched_priority, sched_get_priority_min(x), sched_get_priority_max(x));
1518         c->cpu_sched_set = true;
1519
1520         return 0;
1521 }
1522
1523 int config_parse_exec_mount_apivfs(const char *unit,
1524                                    const char *filename,
1525                                    unsigned line,
1526                                    const char *section,
1527                                    unsigned section_line,
1528                                    const char *lvalue,
1529                                    int ltype,
1530                                    const char *rvalue,
1531                                    void *data,
1532                                    void *userdata) {
1533
1534         ExecContext *c = ASSERT_PTR(data);
1535         int k;
1536
1537         assert(filename);
1538         assert(lvalue);
1539         assert(rvalue);
1540
1541         if (isempty(rvalue)) {
1542                 c->mount_apivfs_set = false;
1543                 c->mount_apivfs = false;
1544                 return 0;
1545         }
1546
1547         k = parse_boolean(rvalue);
1548         if (k < 0) {
1549                 log_syntax(unit, LOG_WARNING, filename, line, k,
1550                            "Failed to parse boolean value, ignoring: %s",
1551                            rvalue);
1552                 return 0;
1553         }
1554
1555         c->mount_apivfs_set = true;
1556         c->mount_apivfs = k;
1557         return 0;
1558 }
1559
1560 int config_parse_numa_mask(const char *unit,
1561                            const char *filename,
1562                            unsigned line,
1563                            const char *section,
1564                            unsigned section_line,
1565                            const char *lvalue,
1566                            int ltype,
1567                            const char *rvalue,
1568                            void *data,
1569                            void *userdata) {
1570         int r;
1571         NUMAPolicy *p = ASSERT_PTR(data);
1572
1573         assert(filename);
1574         assert(lvalue);
1575         assert(rvalue);
1576
1577         if (streq(rvalue, "all")) {
1578                 r = numa_mask_add_all(&p->nodes);
1579                 if (r < 0)
1580                         log_syntax(unit, LOG_WARNING, filename, line, r,
1581                                    "Failed to create NUMA mask representing \"all\" NUMA nodes, ignoring: %m");
1582         } else {
1583                 r = parse_cpu_set_extend(rvalue, &p->nodes, true, unit, filename, line, lvalue);
1584                 if (r < 0)
1585                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse NUMA node mask, ignoring: %s", rvalue);
1586         }
1587
1588         return 0;
1589 }
1590
1591 int config_parse_exec_cpu_sched_prio(const char *unit,
1592                                      const char *filename,
1593                                      unsigned line,
1594                                      const char *section,
1595                                      unsigned section_line,
1596                                      const char *lvalue,
1597                                      int ltype,
1598                                      const char *rvalue,
1599                                      void *data,
1600                                      void *userdata) {
1601
1602         ExecContext *c = ASSERT_PTR(data);
1603         int i, r;
1604
1605         assert(filename);
1606         assert(lvalue);
1607         assert(rvalue);
1608
1609         r = safe_atoi(rvalue, &i);
1610         if (r < 0) {
1611                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse CPU scheduling priority, ignoring: %s", rvalue);
1612                 return 0;
1613         }
1614
1615         /* On Linux RR/FIFO range from 1 to 99 and OTHER/BATCH may only be 0. Policy might be set later so
1616          * we do not check the precise range, but only the generic outer bounds. */
1617         if (i < 0 || i > 99) {
1618                 log_syntax(unit, LOG_WARNING, filename, line, 0, "CPU scheduling priority is out of range, ignoring: %s", rvalue);
1619                 return 0;
1620         }
1621
1622         c->cpu_sched_priority = i;
1623         c->cpu_sched_set = true;
1624
1625         return 0;
1626 }
1627
1628 int config_parse_root_image_options(
1629                 const char *unit,
1630                 const char *filename,
1631                 unsigned line,
1632                 const char *section,
1633                 unsigned section_line,
1634                 const char *lvalue,
1635                 int ltype,
1636                 const char *rvalue,
1637                 void *data,
1638                 void *userdata) {
1639
1640         _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
1641         _cleanup_strv_free_ char **l = NULL;
1642         ExecContext *c = ASSERT_PTR(data);
1643         const Unit *u = userdata;
1644         int r;
1645
1646         assert(filename);
1647         assert(lvalue);
1648         assert(rvalue);
1649
1650         if (isempty(rvalue)) {
1651                 c->root_image_options = mount_options_free_all(c->root_image_options);
1652                 return 0;
1653         }
1654
1655         r = strv_split_colon_pairs(&l, rvalue);
1656         if (r == -ENOMEM)
1657                 return log_oom();
1658         if (r < 0) {
1659                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s, ignoring: %s", lvalue, rvalue);
1660                 return 0;
1661         }
1662
1663         STRV_FOREACH_PAIR(first, second, l) {
1664                 MountOptions *o = NULL;
1665                 _cleanup_free_ char *mount_options_resolved = NULL;
1666                 const char *mount_options = NULL, *partition = "root";
1667                 PartitionDesignator partition_designator;
1668
1669                 /* Format is either 'root:foo' or 'foo' (root is implied) */
1670                 if (!isempty(*second)) {
1671                         partition = *first;
1672                         mount_options = *second;
1673                 } else
1674                         mount_options = *first;
1675
1676                 partition_designator = partition_designator_from_string(partition);
1677                 if (partition_designator < 0) {
1678                         log_syntax(unit, LOG_WARNING, filename, line, partition_designator,
1679                                    "Invalid partition name %s, ignoring", partition);
1680                         continue;
1681                 }
1682                 r = unit_full_printf(u, mount_options, &mount_options_resolved);
1683                 if (r < 0) {
1684                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", mount_options);
1685                         continue;
1686                 }
1687
1688                 o = new(MountOptions, 1);
1689                 if (!o)
1690                         return log_oom();
1691                 *o = (MountOptions) {
1692                         .partition_designator = partition_designator,
1693                         .options = TAKE_PTR(mount_options_resolved),
1694                 };
1695                 LIST_APPEND(mount_options, options, TAKE_PTR(o));
1696         }
1697
1698         if (options)
1699                 LIST_JOIN(mount_options, c->root_image_options, options);
1700         else
1701                 /* empty spaces/separators only */
1702                 c->root_image_options = mount_options_free_all(c->root_image_options);
1703
1704         return 0;
1705 }
1706
1707 int config_parse_exec_root_hash(
1708                 const char *unit,
1709                 const char *filename,
1710                 unsigned line,
1711                 const char *section,
1712                 unsigned section_line,
1713                 const char *lvalue,
1714                 int ltype,
1715                 const char *rvalue,
1716                 void *data,
1717                 void *userdata) {
1718
1719         _cleanup_free_ void *roothash_decoded = NULL;
1720         ExecContext *c = ASSERT_PTR(data);
1721         size_t roothash_decoded_size = 0;
1722         int r;
1723
1724         assert(filename);
1725         assert(line);
1726         assert(rvalue);
1727
1728         if (isempty(rvalue)) {
1729                 /* Reset if the empty string is assigned */
1730                 c->root_hash_path = mfree(c->root_hash_path);
1731                 c->root_hash = mfree(c->root_hash);
1732                 c->root_hash_size = 0;
1733                 return 0;
1734         }
1735
1736         if (path_is_absolute(rvalue)) {
1737                 /* We have the path to a roothash to load and decode, eg: RootHash=/foo/bar.roothash */
1738                 _cleanup_free_ char *p = NULL;
1739
1740                 p = strdup(rvalue);
1741                 if (!p)
1742                         return -ENOMEM;
1743
1744                 free_and_replace(c->root_hash_path, p);
1745                 c->root_hash = mfree(c->root_hash);
1746                 c->root_hash_size = 0;
1747                 return 0;
1748         }
1749
1750         /* We have a roothash to decode, eg: RootHash=012345789abcdef */
1751         r = unhexmem(rvalue, strlen(rvalue), &roothash_decoded, &roothash_decoded_size);
1752         if (r < 0) {
1753                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to decode RootHash=, ignoring: %s", rvalue);
1754                 return 0;
1755         }
1756         if (roothash_decoded_size < sizeof(sd_id128_t)) {
1757                 log_syntax(unit, LOG_WARNING, filename, line, 0, "RootHash= is too short, ignoring: %s", rvalue);
1758                 return 0;
1759         }
1760
1761         free_and_replace(c->root_hash, roothash_decoded);
1762         c->root_hash_size = roothash_decoded_size;
1763         c->root_hash_path = mfree(c->root_hash_path);
1764
1765         return 0;
1766 }
1767
1768 int config_parse_exec_root_hash_sig(
1769                 const char *unit,
1770                 const char *filename,
1771                 unsigned line,
1772                 const char *section,
1773                 unsigned section_line,
1774                 const char *lvalue,
1775                 int ltype,
1776                 const char *rvalue,
1777                 void *data,
1778                 void *userdata) {
1779
1780         _cleanup_free_ void *roothash_sig_decoded = NULL;
1781         char *value;
1782         ExecContext *c = ASSERT_PTR(data);
1783         size_t roothash_sig_decoded_size = 0;
1784         int r;
1785
1786         assert(filename);
1787         assert(line);
1788         assert(rvalue);
1789
1790         if (isempty(rvalue)) {
1791                 /* Reset if the empty string is assigned */
1792                 c->root_hash_sig_path = mfree(c->root_hash_sig_path);
1793                 c->root_hash_sig = mfree(c->root_hash_sig);
1794                 c->root_hash_sig_size = 0;
1795                 return 0;
1796         }
1797
1798         if (path_is_absolute(rvalue)) {
1799                 /* We have the path to a roothash signature to load and decode, eg: RootHashSignature=/foo/bar.roothash.p7s */
1800                 _cleanup_free_ char *p = NULL;
1801
1802                 p = strdup(rvalue);
1803                 if (!p)
1804                         return log_oom();
1805
1806                 free_and_replace(c->root_hash_sig_path, p);
1807                 c->root_hash_sig = mfree(c->root_hash_sig);
1808                 c->root_hash_sig_size = 0;
1809                 return 0;
1810         }
1811
1812         if (!(value = startswith(rvalue, "base64:"))) {
1813                 log_syntax(unit, LOG_WARNING, filename, line, 0,
1814                            "Failed to decode RootHashSignature=, not a path but doesn't start with 'base64:', ignoring: %s", rvalue);
1815                 return 0;
1816         }
1817
1818         /* We have a roothash signature to decode, eg: RootHashSignature=base64:012345789abcdef */
1819         r = unbase64mem(value, strlen(value), &roothash_sig_decoded, &roothash_sig_decoded_size);
1820         if (r < 0) {
1821                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to decode RootHashSignature=, ignoring: %s", rvalue);
1822                 return 0;
1823         }
1824
1825         free_and_replace(c->root_hash_sig, roothash_sig_decoded);
1826         c->root_hash_sig_size = roothash_sig_decoded_size;
1827         c->root_hash_sig_path = mfree(c->root_hash_sig_path);
1828
1829         return 0;
1830 }
1831
1832 int config_parse_exec_cpu_affinity(
1833                 const char *unit,
1834                 const char *filename,
1835                 unsigned line,
1836                 const char *section,
1837                 unsigned section_line,
1838                 const char *lvalue,
1839                 int ltype,
1840                 const char *rvalue,
1841                 void *data,
1842                 void *userdata) {
1843
1844         ExecContext *c = ASSERT_PTR(data);
1845         const Unit *u = userdata;
1846         _cleanup_free_ char *k = NULL;
1847         int r;
1848
1849         assert(filename);
1850         assert(lvalue);
1851         assert(rvalue);
1852
1853         if (streq(rvalue, "numa")) {
1854                 c->cpu_affinity_from_numa = true;
1855                 cpu_set_reset(&c->cpu_set);
1856
1857                 return 0;
1858         }
1859
1860         r = unit_full_printf(u, rvalue, &k);
1861         if (r < 0) {
1862                 log_syntax(unit, LOG_WARNING, filename, line, r,
1863                            "Failed to resolve unit specifiers in '%s', ignoring: %m",
1864                            rvalue);
1865                 return 0;
1866         }
1867
1868         r = parse_cpu_set_extend(k, &c->cpu_set, true, unit, filename, line, lvalue);
1869         if (r >= 0)
1870                 c->cpu_affinity_from_numa = false;
1871
1872         return 0;
1873 }
1874
1875 int config_parse_capability_set(
1876                 const char *unit,
1877                 const char *filename,
1878                 unsigned line,
1879                 const char *section,
1880                 unsigned section_line,
1881                 const char *lvalue,
1882                 int ltype,
1883                 const char *rvalue,
1884                 void *data,
1885                 void *userdata) {
1886
1887         uint64_t *capability_set = ASSERT_PTR(data);
1888         uint64_t sum = 0, initial, def;
1889         bool invert = false;
1890         int r;
1891
1892         assert(filename);
1893         assert(lvalue);
1894         assert(rvalue);
1895
1896         if (rvalue[0] == '~') {
1897                 invert = true;
1898                 rvalue++;
1899         }
1900
1901         if (streq(lvalue, "CapabilityBoundingSet")) {
1902                 initial = CAP_MASK_ALL; /* initialized to all bits on */
1903                 def = CAP_MASK_UNSET;   /* not set */
1904         } else
1905                 def = initial = 0; /* All bits off */
1906
1907         r = capability_set_from_string(rvalue, &sum);
1908         if (r < 0) {
1909                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s= specifier '%s', ignoring: %m", lvalue, rvalue);
1910                 return 0;
1911         }
1912
1913         if (sum == 0 || *capability_set == def)
1914                 /* "", "~" or uninitialized data -> replace */
1915                 *capability_set = invert ? ~sum : sum;
1916         else {
1917                 /* previous data -> merge */
1918                 if (invert)
1919                         *capability_set &= ~sum;
1920                 else
1921                         *capability_set |= sum;
1922         }
1923
1924         return 0;
1925 }
1926
1927 int config_parse_exec_selinux_context(
1928                 const char *unit,
1929                 const char *filename,
1930                 unsigned line,
1931                 const char *section,
1932                 unsigned section_line,
1933                 const char *lvalue,
1934                 int ltype,
1935                 const char *rvalue,
1936                 void *data,
1937                 void *userdata) {
1938
1939         ExecContext *c = ASSERT_PTR(data);
1940         const Unit *u = userdata;
1941         bool ignore;
1942         char *k;
1943         int r;
1944
1945         assert(filename);
1946         assert(lvalue);
1947         assert(rvalue);
1948
1949         if (isempty(rvalue)) {
1950                 c->selinux_context = mfree(c->selinux_context);
1951                 c->selinux_context_ignore = false;
1952                 return 0;
1953         }
1954
1955         if (rvalue[0] == '-') {
1956                 ignore = true;
1957                 rvalue++;
1958         } else
1959                 ignore = false;
1960
1961         r = unit_full_printf(u, rvalue, &k);
1962         if (r < 0) {
1963                 log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,
1964                            "Failed to resolve unit specifiers in '%s'%s: %m",
1965                            rvalue, ignore ? ", ignoring" : "");
1966                 return ignore ? 0 : -ENOEXEC;
1967         }
1968
1969         free_and_replace(c->selinux_context, k);
1970         c->selinux_context_ignore = ignore;
1971
1972         return 0;
1973 }
1974
1975 int config_parse_exec_apparmor_profile(
1976                 const char *unit,
1977                 const char *filename,
1978                 unsigned line,
1979                 const char *section,
1980                 unsigned section_line,
1981                 const char *lvalue,
1982                 int ltype,
1983                 const char *rvalue,
1984                 void *data,
1985                 void *userdata) {
1986
1987         ExecContext *c = ASSERT_PTR(data);
1988         const Unit *u = userdata;
1989         bool ignore;
1990         char *k;
1991         int r;
1992
1993         assert(filename);
1994         assert(lvalue);
1995         assert(rvalue);
1996
1997         if (isempty(rvalue)) {
1998                 c->apparmor_profile = mfree(c->apparmor_profile);
1999                 c->apparmor_profile_ignore = false;
2000                 return 0;
2001         }
2002
2003         if (rvalue[0] == '-') {
2004                 ignore = true;
2005                 rvalue++;
2006         } else
2007                 ignore = false;
2008
2009         r = unit_full_printf(u, rvalue, &k);
2010         if (r < 0) {
2011                 log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,
2012                            "Failed to resolve unit specifiers in '%s'%s: %m",
2013                            rvalue, ignore ? ", ignoring" : "");
2014                 return ignore ? 0 : -ENOEXEC;
2015         }
2016
2017         free_and_replace(c->apparmor_profile, k);
2018         c->apparmor_profile_ignore = ignore;
2019
2020         return 0;
2021 }
2022
2023 int config_parse_exec_smack_process_label(
2024                 const char *unit,
2025                 const char *filename,
2026                 unsigned line,
2027                 const char *section,
2028                 unsigned section_line,
2029                 const char *lvalue,
2030                 int ltype,
2031                 const char *rvalue,
2032                 void *data,
2033                 void *userdata) {
2034
2035         ExecContext *c = ASSERT_PTR(data);
2036         const Unit *u = userdata;
2037         bool ignore;
2038         char *k;
2039         int r;
2040
2041         assert(filename);
2042         assert(lvalue);
2043         assert(rvalue);
2044
2045         if (isempty(rvalue)) {
2046                 c->smack_process_label = mfree(c->smack_process_label);
2047                 c->smack_process_label_ignore = false;
2048                 return 0;
2049         }
2050
2051         if (rvalue[0] == '-') {
2052                 ignore = true;
2053                 rvalue++;
2054         } else
2055                 ignore = false;
2056
2057         r = unit_full_printf(u, rvalue, &k);
2058         if (r < 0) {
2059                 log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,
2060                            "Failed to resolve unit specifiers in '%s'%s: %m",
2061                            rvalue, ignore ? ", ignoring" : "");
2062                 return ignore ? 0 : -ENOEXEC;
2063         }
2064
2065         free_and_replace(c->smack_process_label, k);
2066         c->smack_process_label_ignore = ignore;
2067
2068         return 0;
2069 }
2070
2071 int config_parse_timer(
2072                 const char *unit,
2073                 const char *filename,
2074                 unsigned line,
2075                 const char *section,
2076                 unsigned section_line,
2077                 const char *lvalue,
2078                 int ltype,
2079                 const char *rvalue,
2080                 void *data,
2081                 void *userdata) {
2082
2083         _cleanup_(calendar_spec_freep) CalendarSpec *c = NULL;
2084         _cleanup_free_ char *k = NULL;
2085         const Unit *u = userdata;
2086         Timer *t = ASSERT_PTR(data);
2087         usec_t usec = 0;
2088         TimerValue *v;
2089         int r;
2090
2091         assert(filename);
2092         assert(lvalue);
2093         assert(rvalue);
2094
2095         if (isempty(rvalue)) {
2096                 /* Empty assignment resets list */
2097                 timer_free_values(t);
2098                 return 0;
2099         }
2100
2101         r = unit_full_printf(u, rvalue, &k);
2102         if (r < 0) {
2103                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
2104                 return 0;
2105         }
2106
2107         if (ltype == TIMER_CALENDAR) {
2108                 r = calendar_spec_from_string(k, &c);
2109                 if (r < 0) {
2110                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse calendar specification, ignoring: %s", k);
2111                         return 0;
2112                 }
2113         } else {
2114                 r = parse_sec(k, &usec);
2115                 if (r < 0) {
2116                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse timer value, ignoring: %s", k);
2117                         return 0;
2118                 }
2119         }
2120
2121         v = new(TimerValue, 1);
2122         if (!v)
2123                 return log_oom();
2124
2125         *v = (TimerValue) {
2126                 .base = ltype,
2127                 .value = usec,
2128                 .calendar_spec = TAKE_PTR(c),
2129         };
2130
2131         LIST_PREPEND(value, t->values, v);
2132
2133         return 0;
2134 }
2135
2136 int config_parse_trigger_unit(
2137                 const char *unit,
2138                 const char *filename,
2139                 unsigned line,
2140                 const char *section,
2141                 unsigned section_line,
2142                 const char *lvalue,
2143                 int ltype,
2144                 const char *rvalue,
2145                 void *data,
2146                 void *userdata) {
2147
2148         _cleanup_free_ char *p = NULL;
2149         Unit *u = ASSERT_PTR(data);
2150         UnitType type;
2151         int r;
2152
2153         assert(filename);
2154         assert(lvalue);
2155         assert(rvalue);
2156
2157         if (UNIT_TRIGGER(u)) {
2158                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Multiple units to trigger specified, ignoring: %s", rvalue);
2159                 return 0;
2160         }
2161
2162         r = unit_name_printf(u, rvalue, &p);
2163         if (r < 0) {
2164                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
2165                 return 0;
2166         }
2167
2168         type = unit_name_to_type(p);
2169         if (type < 0) {
2170                 log_syntax(unit, LOG_WARNING, filename, line, type, "Unit type not valid, ignoring: %s", rvalue);
2171                 return 0;
2172         }
2173         if (unit_has_name(u, p)) {
2174                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Units cannot trigger themselves, ignoring: %s", rvalue);
2175                 return 0;
2176         }
2177
2178         r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_TRIGGERS, p, true, UNIT_DEPENDENCY_FILE);
2179         if (r < 0) {
2180                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add trigger on %s, ignoring: %m", p);
2181                 return 0;
2182         }
2183
2184         return 0;
2185 }
2186
2187 int config_parse_path_spec(const char *unit,
2188                            const char *filename,
2189                            unsigned line,
2190                            const char *section,
2191                            unsigned section_line,
2192                            const char *lvalue,
2193                            int ltype,
2194                            const char *rvalue,
2195                            void *data,
2196                            void *userdata) {
2197
2198         Path *p = ASSERT_PTR(data);
2199         PathSpec *s;
2200         PathType b;
2201         _cleanup_free_ char *k = NULL;
2202         int r;
2203
2204         assert(filename);
2205         assert(lvalue);
2206         assert(rvalue);
2207
2208         if (isempty(rvalue)) {
2209                 /* Empty assignment clears list */
2210                 path_free_specs(p);
2211                 return 0;
2212         }
2213
2214         b = path_type_from_string(lvalue);
2215         if (b < 0) {
2216                 log_syntax(unit, LOG_WARNING, filename, line, b, "Failed to parse path type, ignoring: %s", lvalue);
2217                 return 0;
2218         }
2219
2220         r = unit_path_printf(UNIT(p), rvalue, &k);
2221         if (r < 0) {
2222                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
2223                 return 0;
2224         }
2225
2226         r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
2227         if (r < 0)
2228                 return 0;
2229
2230         s = new0(PathSpec, 1);
2231         if (!s)
2232                 return log_oom();
2233
2234         s->unit = UNIT(p);
2235         s->path = TAKE_PTR(k);
2236         s->type = b;
2237         s->inotify_fd = -EBADF;
2238
2239         LIST_PREPEND(spec, p->specs, s);
2240
2241         return 0;
2242 }
2243
2244 int config_parse_socket_service(
2245                 const char *unit,
2246                 const char *filename,
2247                 unsigned line,
2248                 const char *section,
2249                 unsigned section_line,
2250                 const char *lvalue,
2251                 int ltype,
2252                 const char *rvalue,
2253                 void *data,
2254                 void *userdata) {
2255
2256         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2257         _cleanup_free_ char *p = NULL;
2258         Socket *s = ASSERT_PTR(data);
2259         Unit *x;
2260         int r;
2261
2262         assert(filename);
2263         assert(lvalue);
2264         assert(rvalue);
2265
2266         r = unit_name_printf(UNIT(s), rvalue, &p);
2267         if (r < 0) {
2268                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
2269                 return 0;
2270         }
2271
2272         if (!endswith(p, ".service")) {
2273                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Unit must be of type service, ignoring: %s", rvalue);
2274                 return 0;
2275         }
2276
2277         r = manager_load_unit(UNIT(s)->manager, p, NULL, &error, &x);
2278         if (r < 0) {
2279                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to load unit %s, ignoring: %s", rvalue, bus_error_message(&error, r));
2280                 return 0;
2281         }
2282
2283         unit_ref_set(&s->service, UNIT(s), x);
2284
2285         return 0;
2286 }
2287
2288 int config_parse_fdname(
2289                 const char *unit,
2290                 const char *filename,
2291                 unsigned line,
2292                 const char *section,
2293                 unsigned section_line,
2294                 const char *lvalue,
2295                 int ltype,
2296                 const char *rvalue,
2297                 void *data,
2298                 void *userdata) {
2299
2300         _cleanup_free_ char *p = NULL;
2301         Socket *s = ASSERT_PTR(data);
2302         int r;
2303
2304         assert(filename);
2305         assert(lvalue);
2306         assert(rvalue);
2307
2308         if (isempty(rvalue)) {
2309                 s->fdname = mfree(s->fdname);
2310                 return 0;
2311         }
2312
2313         r = unit_fd_printf(UNIT(s), rvalue, &p);
2314         if (r < 0) {
2315                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
2316                 return 0;
2317         }
2318
2319         if (!fdname_is_valid(p)) {
2320                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid file descriptor name, ignoring: %s", p);
2321                 return 0;
2322         }
2323
2324         return free_and_replace(s->fdname, p);
2325 }
2326
2327 int config_parse_service_sockets(
2328                 const char *unit,
2329                 const char *filename,
2330                 unsigned line,
2331                 const char *section,
2332                 unsigned section_line,
2333                 const char *lvalue,
2334                 int ltype,
2335                 const char *rvalue,
2336                 void *data,
2337                 void *userdata) {
2338
2339         Service *s = ASSERT_PTR(data);
2340         int r;
2341
2342         assert(filename);
2343         assert(lvalue);
2344         assert(rvalue);
2345
2346         for (const char *p = rvalue;;) {
2347                 _cleanup_free_ char *word = NULL, *k = NULL;
2348
2349                 r = extract_first_word(&p, &word, NULL, 0);
2350                 if (r == -ENOMEM)
2351                         return log_oom();
2352                 if (r < 0) {
2353                         log_syntax(unit, LOG_WARNING, filename, line, r, "Trailing garbage in sockets, ignoring: %s", rvalue);
2354                         return 0;
2355                 }
2356                 if (r == 0)
2357                         return 0;
2358
2359                 r = unit_name_printf(UNIT(s), word, &k);
2360                 if (r < 0) {
2361                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", word);
2362                         continue;
2363                 }
2364
2365                 if (!endswith(k, ".socket")) {
2366                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Unit must be of type socket, ignoring: %s", k);
2367                         continue;
2368                 }
2369
2370                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_WANTS, UNIT_AFTER, k, true, UNIT_DEPENDENCY_FILE);
2371                 if (r < 0)
2372                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);
2373
2374                 r = unit_add_dependency_by_name(UNIT(s), UNIT_TRIGGERED_BY, k, true, UNIT_DEPENDENCY_FILE);
2375                 if (r < 0)
2376                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);
2377         }
2378 }
2379
2380 int config_parse_bus_name(
2381                 const char *unit,
2382                 const char *filename,
2383                 unsigned line,
2384                 const char *section,
2385                 unsigned section_line,
2386                 const char *lvalue,
2387                 int ltype,
2388                 const char *rvalue,
2389                 void *data,
2390                 void *userdata) {
2391
2392         _cleanup_free_ char *k = NULL;
2393         const Unit *u = ASSERT_PTR(userdata);
2394         int r;
2395
2396         assert(filename);
2397         assert(lvalue);
2398         assert(rvalue);
2399
2400         r = unit_full_printf_full(u, rvalue, SD_BUS_MAXIMUM_NAME_LENGTH, &k);
2401         if (r < 0) {
2402                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
2403                 return 0;
2404         }
2405
2406         if (!sd_bus_service_name_is_valid(k)) {
2407                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid bus name, ignoring: %s", k);
2408                 return 0;
2409         }
2410
2411         return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
2412 }
2413
2414 int config_parse_service_timeout(
2415                 const char *unit,
2416                 const char *filename,
2417                 unsigned line,
2418                 const char *section,
2419                 unsigned section_line,
2420                 const char *lvalue,
2421                 int ltype,
2422                 const char *rvalue,
2423                 void *data,
2424                 void *userdata) {
2425
2426         Service *s = ASSERT_PTR(userdata);
2427         usec_t usec;
2428         int r;
2429
2430         assert(filename);
2431         assert(lvalue);
2432         assert(rvalue);
2433
2434         /* This is called for two cases: TimeoutSec= and TimeoutStartSec=. */
2435
2436         /* Traditionally, these options accepted 0 to disable the timeouts. However, a timeout of 0 suggests it happens
2437          * immediately, hence fix this to become USEC_INFINITY instead. This is in-line with how we internally handle
2438          * all other timeouts. */
2439         r = parse_sec_fix_0(rvalue, &usec);
2440         if (r < 0) {
2441                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s= parameter, ignoring: %s", lvalue, rvalue);
2442                 return 0;
2443         }
2444
2445         s->start_timeout_defined = true;
2446         s->timeout_start_usec = usec;
2447
2448         if (streq(lvalue, "TimeoutSec"))
2449                 s->timeout_stop_usec = usec;
2450
2451         return 0;
2452 }
2453
2454 int config_parse_timeout_abort(
2455                 const char *unit,
2456                 const char *filename,
2457                 unsigned line,
2458                 const char *section,
2459                 unsigned section_line,
2460                 const char *lvalue,
2461                 int ltype,
2462                 const char *rvalue,
2463                 void *data,
2464                 void *userdata) {
2465
2466         usec_t *ret = ASSERT_PTR(data);
2467         int r;
2468
2469         assert(filename);
2470         assert(lvalue);
2471         assert(rvalue);
2472
2473         /* Note: apart from setting the arg, this returns an extra bit of information in the return value. */
2474
2475         if (isempty(rvalue)) {
2476                 *ret = 0;
2477                 return 0; /* "not set" */
2478         }
2479
2480         r = parse_sec(rvalue, ret);
2481         if (r < 0)
2482                 return log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s= setting, ignoring: %s", lvalue, rvalue);
2483
2484         return 1; /* "set" */
2485 }
2486
2487 int config_parse_service_timeout_abort(
2488                 const char *unit,
2489                 const char *filename,
2490                 unsigned line,
2491                 const char *section,
2492                 unsigned section_line,
2493                 const char *lvalue,
2494                 int ltype,
2495                 const char *rvalue,
2496                 void *data,
2497                 void *userdata) {
2498
2499         Service *s = ASSERT_PTR(userdata);
2500         int r;
2501
2502         r = config_parse_timeout_abort(unit, filename, line, section, section_line, lvalue, ltype, rvalue,
2503                                        &s->timeout_abort_usec, s);
2504         if (r >= 0)
2505                 s->timeout_abort_set = r;
2506         return 0;
2507 }
2508
2509 int config_parse_user_group_compat(
2510                 const char *unit,
2511                 const char *filename,
2512                 unsigned line,
2513                 const char *section,
2514                 unsigned section_line,
2515                 const char *lvalue,
2516                 int ltype,
2517                 const char *rvalue,
2518                 void *data,
2519                 void *userdata) {
2520
2521         _cleanup_free_ char *k = NULL;
2522         char **user = data;
2523         const Unit *u = ASSERT_PTR(userdata);
2524         int r;
2525
2526         assert(filename);
2527         assert(lvalue);
2528         assert(rvalue);
2529
2530         if (isempty(rvalue)) {
2531                 *user = mfree(*user);
2532                 return 0;
2533         }
2534
2535         r = unit_full_printf(u, rvalue, &k);
2536         if (r < 0) {
2537                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve unit specifiers in %s: %m", rvalue);
2538                 return -ENOEXEC;
2539         }
2540
2541         if (!valid_user_group_name(k, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX|VALID_USER_WARN)) {
2542                 log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid user/group name or numeric ID: %s", k);
2543                 return -ENOEXEC;
2544         }
2545
2546         if (strstr(lvalue, "User") && streq(k, NOBODY_USER_NAME))
2547                 log_struct(LOG_NOTICE,
2548                            "MESSAGE=%s:%u: Special user %s configured, this is not safe!", filename, line, k,
2549                            "UNIT=%s", unit,
2550                            "MESSAGE_ID=" SD_MESSAGE_NOBODY_USER_UNSUITABLE_STR,
2551                            "OFFENDING_USER=%s", k,
2552                            "CONFIG_FILE=%s", filename,
2553                            "CONFIG_LINE=%u", line);
2554
2555         return free_and_replace(*user, k);
2556 }
2557
2558 int config_parse_user_group_strv_compat(
2559                 const char *unit,
2560                 const char *filename,
2561                 unsigned line,
2562                 const char *section,
2563                 unsigned section_line,
2564                 const char *lvalue,
2565                 int ltype,
2566                 const char *rvalue,
2567                 void *data,
2568                 void *userdata) {
2569
2570         char ***users = data;
2571         const Unit *u = ASSERT_PTR(userdata);
2572         int r;
2573
2574         assert(filename);
2575         assert(lvalue);
2576         assert(rvalue);
2577
2578         if (isempty(rvalue)) {
2579                 *users = strv_free(*users);
2580                 return 0;
2581         }
2582
2583         for (const char *p = rvalue;;) {
2584                 _cleanup_free_ char *word = NULL, *k = NULL;
2585
2586                 r = extract_first_word(&p, &word, NULL, 0);
2587                 if (r == -ENOMEM)
2588                         return log_oom();
2589                 if (r < 0) {
2590                         log_syntax(unit, LOG_ERR, filename, line, r, "Invalid syntax: %s", rvalue);
2591                         return -ENOEXEC;
2592                 }
2593                 if (r == 0)
2594                         return 0;
2595
2596                 r = unit_full_printf(u, word, &k);
2597                 if (r < 0) {
2598                         log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve unit specifiers in %s: %m", word);
2599                         return -ENOEXEC;
2600                 }
2601
2602                 if (!valid_user_group_name(k, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX|VALID_USER_WARN)) {
2603                         log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid user/group name or numeric ID: %s", k);
2604                         return -ENOEXEC;
2605                 }
2606
2607                 r = strv_push(users, k);
2608                 if (r < 0)
2609                         return log_oom();
2610
2611                 k = NULL;
2612         }
2613 }
2614
2615 int config_parse_working_directory(
2616                 const char *unit,
2617                 const char *filename,
2618                 unsigned line,
2619                 const char *section,
2620                 unsigned section_line,
2621                 const char *lvalue,
2622                 int ltype,
2623                 const char *rvalue,
2624                 void *data,
2625                 void *userdata) {
2626
2627         ExecContext *c = ASSERT_PTR(data);
2628         const Unit *u = ASSERT_PTR(userdata);
2629         bool missing_ok;
2630         int r;
2631
2632         assert(filename);
2633         assert(lvalue);
2634         assert(rvalue);
2635
2636         if (isempty(rvalue)) {
2637                 c->working_directory_home = false;
2638                 c->working_directory = mfree(c->working_directory);
2639                 return 0;
2640         }
2641
2642         if (rvalue[0] == '-') {
2643                 missing_ok = true;
2644                 rvalue++;
2645         } else
2646                 missing_ok = false;
2647
2648         if (streq(rvalue, "~")) {
2649                 c->working_directory_home = true;
2650                 c->working_directory = mfree(c->working_directory);
2651         } else {
2652                 _cleanup_free_ char *k = NULL;
2653
2654                 r = unit_path_printf(u, rvalue, &k);
2655                 if (r < 0) {
2656                         log_syntax(unit, missing_ok ? LOG_WARNING : LOG_ERR, filename, line, r,
2657                                    "Failed to resolve unit specifiers in working directory path '%s'%s: %m",
2658                                    rvalue, missing_ok ? ", ignoring" : "");
2659                         return missing_ok ? 0 : -ENOEXEC;
2660                 }
2661
2662                 r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE | (missing_ok ? 0 : PATH_CHECK_FATAL), unit, filename, line, lvalue);
2663                 if (r < 0)
2664                         return missing_ok ? 0 : -ENOEXEC;
2665
2666                 c->working_directory_home = false;
2667                 free_and_replace(c->working_directory, k);
2668         }
2669
2670         c->working_directory_missing_ok = missing_ok;
2671         return 0;
2672 }
2673
2674 int config_parse_unit_env_file(const char *unit,
2675                                const char *filename,
2676                                unsigned line,
2677                                const char *section,
2678                                unsigned section_line,
2679                                const char *lvalue,
2680                                int ltype,
2681                                const char *rvalue,
2682                                void *data,
2683                                void *userdata) {
2684
2685         char ***env = ASSERT_PTR(data);
2686         const Unit *u = userdata;
2687         _cleanup_free_ char *n = NULL;
2688         int r;
2689
2690         assert(filename);
2691         assert(lvalue);
2692         assert(rvalue);
2693
2694         if (isempty(rvalue)) {
2695                 /* Empty assignment frees the list */
2696                 *env = strv_free(*env);
2697                 return 0;
2698         }
2699
2700         r = unit_full_printf_full(u, rvalue, PATH_MAX, &n);
2701         if (r < 0) {
2702                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
2703                 return 0;
2704         }
2705
2706         r = path_simplify_and_warn(n[0] == '-' ? n + 1 : n, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
2707         if (r < 0)
2708                 return 0;
2709
2710         r = strv_push(env, n);
2711         if (r < 0)
2712                 return log_oom();
2713
2714         n = NULL;
2715
2716         return 0;
2717 }
2718
2719 int config_parse_environ(
2720                 const char *unit,
2721                 const char *filename,
2722                 unsigned line,
2723                 const char *section,
2724                 unsigned section_line,
2725                 const char *lvalue,
2726                 int ltype,
2727                 const char *rvalue,
2728                 void *data,
2729                 void *userdata) {
2730
2731         const Unit *u = userdata;
2732         char ***env = ASSERT_PTR(data);
2733         int r;
2734
2735         assert(filename);
2736         assert(lvalue);
2737         assert(rvalue);
2738
2739         if (isempty(rvalue)) {
2740                 /* Empty assignment resets the list */
2741                 *env = strv_free(*env);
2742                 return 0;
2743         }
2744
2745         /* If 'u' is set, we operate on the regular unit specifier table. Otherwise we use a manager-specific
2746          * specifier table (in which case ltype must contain the runtime scope). */
2747         const Specifier *table = u ? NULL : (const Specifier[]) {
2748                 COMMON_SYSTEM_SPECIFIERS,
2749                 COMMON_TMP_SPECIFIERS,
2750                 COMMON_CREDS_SPECIFIERS(ltype),
2751                 { 'h', specifier_user_home,  NULL },
2752                 { 's', specifier_user_shell, NULL },
2753         };
2754
2755         for (const char *p = rvalue;; ) {
2756                 _cleanup_free_ char *word = NULL, *resolved = NULL;
2757
2758                 r = extract_first_word(&p, &word, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
2759                 if (r == -ENOMEM)
2760                         return log_oom();
2761                 if (r < 0) {
2762                         log_syntax(unit, LOG_WARNING, filename, line, r,
2763                                    "Invalid syntax, ignoring: %s", rvalue);
2764                         return 0;
2765                 }
2766                 if (r == 0)
2767                         return 0;
2768
2769                 if (table)
2770                         r = specifier_printf(word, sc_arg_max(), table, NULL, NULL, &resolved);
2771                 else
2772                         r = unit_env_printf(u, word, &resolved);
2773                 if (r < 0) {
2774                         log_syntax(unit, LOG_WARNING, filename, line, r,
2775                                    "Failed to resolve specifiers in %s, ignoring: %m", word);
2776                         continue;
2777                 }
2778
2779                 if (!env_assignment_is_valid(resolved)) {
2780                         log_syntax(unit, LOG_WARNING, filename, line, 0,
2781                                    "Invalid environment assignment, ignoring: %s", resolved);
2782                         continue;
2783                 }
2784
2785                 r = strv_env_replace_consume(env, TAKE_PTR(resolved));
2786                 if (r < 0)
2787                         return log_error_errno(r, "Failed to update environment: %m");
2788         }
2789 }
2790
2791 int config_parse_pass_environ(
2792                 const char *unit,
2793                 const char *filename,
2794                 unsigned line,
2795                 const char *section,
2796                 unsigned section_line,
2797                 const char *lvalue,
2798                 int ltype,
2799                 const char *rvalue,
2800                 void *data,
2801                 void *userdata) {
2802
2803         _cleanup_strv_free_ char **n = NULL;
2804         const Unit *u = userdata;
2805         char*** passenv = ASSERT_PTR(data);
2806         size_t nlen = 0;
2807         int r;
2808
2809         assert(filename);
2810         assert(lvalue);
2811         assert(rvalue);
2812
2813         if (isempty(rvalue)) {
2814                 /* Empty assignment resets the list */
2815                 *passenv = strv_free(*passenv);
2816                 return 0;
2817         }
2818
2819         for (const char *p = rvalue;;) {
2820                 _cleanup_free_ char *word = NULL, *k = NULL;
2821
2822                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
2823                 if (r == -ENOMEM)
2824                         return log_oom();
2825                 if (r < 0) {
2826                         log_syntax(unit, LOG_WARNING, filename, line, r,
2827                                    "Trailing garbage in %s, ignoring: %s", lvalue, rvalue);
2828                         break;
2829                 }
2830                 if (r == 0)
2831                         break;
2832
2833                 if (u) {
2834                         r = unit_env_printf(u, word, &k);
2835                         if (r < 0) {
2836                                 log_syntax(unit, LOG_WARNING, filename, line, r,
2837                                            "Failed to resolve specifiers in %s, ignoring: %m", word);
2838                                 continue;
2839                         }
2840                 } else
2841                         k = TAKE_PTR(word);
2842
2843                 if (!env_name_is_valid(k)) {
2844                         log_syntax(unit, LOG_WARNING, filename, line, 0,
2845                                    "Invalid environment name for %s, ignoring: %s", lvalue, k);
2846                         continue;
2847                 }
2848
2849                 if (!GREEDY_REALLOC(n, nlen + 2))
2850                         return log_oom();
2851
2852                 n[nlen++] = TAKE_PTR(k);
2853                 n[nlen] = NULL;
2854         }
2855
2856         if (n) {
2857                 r = strv_extend_strv(passenv, n, true);
2858                 if (r < 0)
2859                         return log_oom();
2860         }
2861
2862         return 0;
2863 }
2864
2865 int config_parse_unset_environ(
2866                 const char *unit,
2867                 const char *filename,
2868                 unsigned line,
2869                 const char *section,
2870                 unsigned section_line,
2871                 const char *lvalue,
2872                 int ltype,
2873                 const char *rvalue,
2874                 void *data,
2875                 void *userdata) {
2876
2877         _cleanup_strv_free_ char **n = NULL;
2878         char*** unsetenv = ASSERT_PTR(data);
2879         const Unit *u = userdata;
2880         size_t nlen = 0;
2881         int r;
2882
2883         assert(filename);
2884         assert(lvalue);
2885         assert(rvalue);
2886
2887         if (isempty(rvalue)) {
2888                 /* Empty assignment resets the list */
2889                 *unsetenv = strv_free(*unsetenv);
2890                 return 0;
2891         }
2892
2893         for (const char *p = rvalue;;) {
2894                 _cleanup_free_ char *word = NULL, *k = NULL;
2895
2896                 r = extract_first_word(&p, &word, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
2897                 if (r == -ENOMEM)
2898                         return log_oom();
2899                 if (r < 0) {
2900                         log_syntax(unit, LOG_WARNING, filename, line, r,
2901                                    "Trailing garbage in %s, ignoring: %s", lvalue, rvalue);
2902                         break;
2903                 }
2904                 if (r == 0)
2905                         break;
2906
2907                 if (u) {
2908                         r = unit_env_printf(u, word, &k);
2909                         if (r < 0) {
2910                                 log_syntax(unit, LOG_WARNING, filename, line, r,
2911                                            "Failed to resolve unit specifiers in %s, ignoring: %m", word);
2912                                 continue;
2913                         }
2914                 } else
2915                         k = TAKE_PTR(word);
2916
2917                 if (!env_assignment_is_valid(k) && !env_name_is_valid(k)) {
2918                         log_syntax(unit, LOG_WARNING, filename, line, 0,
2919                                    "Invalid environment name or assignment %s, ignoring: %s", lvalue, k);
2920                         continue;
2921                 }
2922
2923                 if (!GREEDY_REALLOC(n, nlen + 2))
2924                         return log_oom();
2925
2926                 n[nlen++] = TAKE_PTR(k);
2927                 n[nlen] = NULL;
2928         }
2929
2930         if (n) {
2931                 r = strv_extend_strv(unsetenv, n, true);
2932                 if (r < 0)
2933                         return log_oom();
2934         }
2935
2936         return 0;
2937 }
2938
2939 int config_parse_log_extra_fields(
2940                 const char *unit,
2941                 const char *filename,
2942                 unsigned line,
2943                 const char *section,
2944                 unsigned section_line,
2945                 const char *lvalue,
2946                 int ltype,
2947                 const char *rvalue,
2948                 void *data,
2949                 void *userdata) {
2950
2951         ExecContext *c = ASSERT_PTR(data);
2952         const Unit *u = userdata;
2953         int r;
2954
2955         assert(filename);
2956         assert(lvalue);
2957         assert(rvalue);
2958
2959         if (isempty(rvalue)) {
2960                 exec_context_free_log_extra_fields(c);
2961                 return 0;
2962         }
2963
2964         for (const char *p = rvalue;;) {
2965                 _cleanup_free_ char *word = NULL, *k = NULL;
2966                 struct iovec *t;
2967                 const char *eq;
2968
2969                 r = extract_first_word(&p, &word, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
2970                 if (r == -ENOMEM)
2971                         return log_oom();
2972                 if (r < 0) {
2973                         log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
2974                         return 0;
2975                 }
2976                 if (r == 0)
2977                         return 0;
2978
2979                 r = unit_full_printf(u, word, &k);
2980                 if (r < 0) {
2981                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", word);
2982                         continue;
2983                 }
2984
2985                 eq = strchr(k, '=');
2986                 if (!eq) {
2987                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Log field lacks '=' character, ignoring: %s", k);
2988                         continue;
2989                 }
2990
2991                 if (!journal_field_valid(k, eq-k, false)) {
2992                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Log field name is invalid, ignoring: %s", k);
2993                         continue;
2994                 }
2995
2996                 t = reallocarray(c->log_extra_fields, c->n_log_extra_fields+1, sizeof(struct iovec));
2997                 if (!t)
2998                         return log_oom();
2999
3000                 c->log_extra_fields = t;
3001                 c->log_extra_fields[c->n_log_extra_fields++] = IOVEC_MAKE_STRING(k);
3002
3003                 k = NULL;
3004         }
3005 }
3006
3007 int config_parse_log_namespace(
3008                 const char *unit,
3009                 const char *filename,
3010                 unsigned line,
3011                 const char *section,
3012                 unsigned section_line,
3013                 const char *lvalue,
3014                 int ltype,
3015                 const char *rvalue,
3016                 void *data,
3017                 void *userdata) {
3018
3019         _cleanup_free_ char *k = NULL;
3020         ExecContext *c = ASSERT_PTR(data);
3021         const Unit *u = userdata;
3022         int r;
3023
3024         assert(filename);
3025         assert(lvalue);
3026         assert(rvalue);
3027
3028         if (isempty(rvalue)) {
3029                 c->log_namespace = mfree(c->log_namespace);
3030                 return 0;
3031         }
3032
3033         r = unit_full_printf_full(u, rvalue, NAME_MAX, &k);
3034         if (r < 0) {
3035                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
3036                 return 0;
3037         }
3038
3039         if (!log_namespace_name_valid(k)) {
3040                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Specified log namespace name is not valid, ignoring: %s", k);
3041                 return 0;
3042         }
3043
3044         free_and_replace(c->log_namespace, k);
3045         return 0;
3046 }
3047
3048 int config_parse_unit_condition_path(
3049                 const char *unit,
3050                 const char *filename,
3051                 unsigned line,
3052                 const char *section,
3053                 unsigned section_line,
3054                 const char *lvalue,
3055                 int ltype,
3056                 const char *rvalue,
3057                 void *data,
3058                 void *userdata) {
3059
3060         _cleanup_free_ char *p = NULL;
3061         Condition **list = ASSERT_PTR(data), *c;
3062         ConditionType t = ltype;
3063         bool trigger, negate;
3064         const Unit *u = userdata;
3065         int r;
3066
3067         assert(filename);
3068         assert(lvalue);
3069         assert(rvalue);
3070
3071         if (isempty(rvalue)) {
3072                 /* Empty assignment resets the list */
3073                 *list = condition_free_list(*list);
3074                 return 0;
3075         }
3076
3077         trigger = rvalue[0] == '|';
3078         if (trigger)
3079                 rvalue++;
3080
3081         negate = rvalue[0] == '!';
3082         if (negate)
3083                 rvalue++;
3084
3085         r = unit_path_printf(u, rvalue, &p);
3086         if (r < 0) {
3087                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
3088                 return 0;
3089         }
3090
3091         r = path_simplify_and_warn(p, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
3092         if (r < 0)
3093                 return 0;
3094
3095         c = condition_new(t, p, trigger, negate);
3096         if (!c)
3097                 return log_oom();
3098
3099         LIST_PREPEND(conditions, *list, c);
3100         return 0;
3101 }
3102
3103 int config_parse_unit_condition_string(
3104                 const char *unit,
3105                 const char *filename,
3106                 unsigned line,
3107                 const char *section,
3108                 unsigned section_line,
3109                 const char *lvalue,
3110                 int ltype,
3111                 const char *rvalue,
3112                 void *data,
3113                 void *userdata) {
3114
3115         _cleanup_free_ char *s = NULL;
3116         Condition **list = ASSERT_PTR(data), *c;
3117         ConditionType t = ltype;
3118         bool trigger, negate;
3119         const Unit *u = userdata;
3120         int r;
3121
3122         assert(filename);
3123         assert(lvalue);
3124         assert(rvalue);
3125
3126         if (isempty(rvalue)) {
3127                 /* Empty assignment resets the list */
3128                 *list = condition_free_list(*list);
3129                 return 0;
3130         }
3131
3132         trigger = *rvalue == '|';
3133         if (trigger)
3134                 rvalue += 1 + strspn(rvalue + 1, WHITESPACE);
3135
3136         negate = *rvalue == '!';
3137         if (negate)
3138                 rvalue += 1 + strspn(rvalue + 1, WHITESPACE);
3139
3140         r = unit_full_printf(u, rvalue, &s);
3141         if (r < 0) {
3142                 log_syntax(unit, LOG_WARNING, filename, line, r,
3143                            "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
3144                 return 0;
3145         }
3146
3147         c = condition_new(t, s, trigger, negate);
3148         if (!c)
3149                 return log_oom();
3150
3151         LIST_PREPEND(conditions, *list, c);
3152         return 0;
3153 }
3154
3155 int config_parse_unit_requires_mounts_for(
3156                 const char *unit,
3157                 const char *filename,
3158                 unsigned line,
3159                 const char *section,
3160                 unsigned section_line,
3161                 const char *lvalue,
3162                 int ltype,
3163                 const char *rvalue,
3164                 void *data,
3165                 void *userdata) {
3166
3167         Unit *u = userdata;
3168         int r;
3169
3170         assert(filename);
3171         assert(lvalue);
3172         assert(rvalue);
3173         assert(data);
3174
3175         for (const char *p = rvalue;;) {
3176                 _cleanup_free_ char *word = NULL, *resolved = NULL;
3177
3178                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
3179                 if (r == -ENOMEM)
3180                         return log_oom();
3181                 if (r < 0) {
3182                         log_syntax(unit, LOG_WARNING, filename, line, r,
3183                                    "Invalid syntax, ignoring: %s", rvalue);
3184                         return 0;
3185                 }
3186                 if (r == 0)
3187                         return 0;
3188
3189                 r = unit_path_printf(u, word, &resolved);
3190                 if (r < 0) {
3191                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", word);
3192                         continue;
3193                 }
3194
3195                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
3196                 if (r < 0)
3197                         continue;
3198
3199                 r = unit_require_mounts_for(u, resolved, UNIT_DEPENDENCY_FILE);
3200                 if (r < 0) {
3201                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add required mount '%s', ignoring: %m", resolved);
3202                         continue;
3203                 }
3204         }
3205 }
3206
3207 int config_parse_documentation(
3208                 const char *unit,
3209                 const char *filename,
3210                 unsigned line,
3211                 const char *section,
3212                 unsigned section_line,
3213                 const char *lvalue,
3214                 int ltype,
3215                 const char *rvalue,
3216                 void *data,
3217                 void *userdata) {
3218
3219         Unit *u = ASSERT_PTR(userdata);
3220         int r;
3221         char **a, **b;
3222
3223         assert(filename);
3224         assert(lvalue);
3225         assert(rvalue);
3226
3227         if (isempty(rvalue)) {
3228                 /* Empty assignment resets the list */
3229                 u->documentation = strv_free(u->documentation);
3230                 return 0;
3231         }
3232
3233         r = config_parse_unit_strv_printf(unit, filename, line, section, section_line, lvalue, ltype,
3234                                           rvalue, data, userdata);
3235         if (r < 0)
3236                 return r;
3237
3238         for (a = b = u->documentation; a && *a; a++) {
3239
3240                 if (documentation_url_is_valid(*a))
3241                         *(b++) = *a;
3242                 else {
3243                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid URL, ignoring: %s", *a);
3244                         free(*a);
3245                 }
3246         }
3247         if (b)
3248                 *b = NULL;
3249
3250         return 0;
3251 }
3252
3253 #if HAVE_SECCOMP
3254 int config_parse_syscall_filter(
3255                 const char *unit,
3256                 const char *filename,
3257                 unsigned line,
3258                 const char *section,
3259                 unsigned section_line,
3260                 const char *lvalue,
3261                 int ltype,
3262                 const char *rvalue,
3263                 void *data,
3264                 void *userdata) {
3265
3266         ExecContext *c = data;
3267         _unused_ const Unit *u = ASSERT_PTR(userdata);
3268         bool invert = false;
3269         int r;
3270
3271         assert(filename);
3272         assert(lvalue);
3273         assert(rvalue);
3274
3275         if (isempty(rvalue)) {
3276                 /* Empty assignment resets the list */
3277                 c->syscall_filter = hashmap_free(c->syscall_filter);
3278                 c->syscall_allow_list = false;
3279                 return 0;
3280         }
3281
3282         if (rvalue[0] == '~') {
3283                 invert = true;
3284                 rvalue++;
3285         }
3286
3287         if (!c->syscall_filter) {
3288                 c->syscall_filter = hashmap_new(NULL);
3289                 if (!c->syscall_filter)
3290                         return log_oom();
3291
3292                 if (invert)
3293                         /* Allow everything but the ones listed */
3294                         c->syscall_allow_list = false;
3295                 else {
3296                         /* Allow nothing but the ones listed */
3297                         c->syscall_allow_list = true;
3298
3299                         /* Accept default syscalls if we are on an allow_list */
3300                         r = seccomp_parse_syscall_filter(
3301                                         "@default", -1, c->syscall_filter,
3302                                         SECCOMP_PARSE_PERMISSIVE|SECCOMP_PARSE_ALLOW_LIST,
3303                                         unit,
3304                                         NULL, 0);
3305                         if (r < 0)
3306                                 return r;
3307                 }
3308         }
3309
3310         for (const char *p = rvalue;;) {
3311                 _cleanup_free_ char *word = NULL, *name = NULL;
3312                 int num;
3313
3314                 r = extract_first_word(&p, &word, NULL, 0);
3315                 if (r == -ENOMEM)
3316                         return log_oom();
3317                 if (r < 0) {
3318                         log_syntax(unit, LOG_WARNING, filename, line, r,
3319                                    "Invalid syntax, ignoring: %s", rvalue);
3320                         return 0;
3321                 }
3322                 if (r == 0)
3323                         return 0;
3324
3325                 r = parse_syscall_and_errno(word, &name, &num);
3326                 if (r < 0) {
3327                         log_syntax(unit, LOG_WARNING, filename, line, r,
3328                                    "Failed to parse syscall:errno, ignoring: %s", word);
3329                         continue;
3330                 }
3331                 if (!invert && num >= 0) {
3332                         log_syntax(unit, LOG_WARNING, filename, line, 0,
3333                                    "Allow-listed system calls cannot take error number, ignoring: %s", word);
3334                         continue;
3335                 }
3336
3337                 r = seccomp_parse_syscall_filter(
3338                                 name, num, c->syscall_filter,
3339                                 SECCOMP_PARSE_LOG|SECCOMP_PARSE_PERMISSIVE|
3340                                 (invert ? SECCOMP_PARSE_INVERT : 0)|
3341                                 (c->syscall_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
3342                                 unit, filename, line);
3343                 if (r < 0)
3344                         return r;
3345         }
3346 }
3347
3348 int config_parse_syscall_log(
3349                 const char *unit,
3350                 const char *filename,
3351                 unsigned line,
3352                 const char *section,
3353                 unsigned section_line,
3354                 const char *lvalue,
3355                 int ltype,
3356                 const char *rvalue,
3357                 void *data,
3358                 void *userdata) {
3359
3360         ExecContext *c = data;
3361         _unused_ const Unit *u = ASSERT_PTR(userdata);
3362         bool invert = false;
3363         const char *p;
3364         int r;
3365
3366         assert(filename);
3367         assert(lvalue);
3368         assert(rvalue);
3369
3370         if (isempty(rvalue)) {
3371                 /* Empty assignment resets the list */
3372                 c->syscall_log = hashmap_free(c->syscall_log);
3373                 c->syscall_log_allow_list = false;
3374                 return 0;
3375         }
3376
3377         if (rvalue[0] == '~') {
3378                 invert = true;
3379                 rvalue++;
3380         }
3381
3382         if (!c->syscall_log) {
3383                 c->syscall_log = hashmap_new(NULL);
3384                 if (!c->syscall_log)
3385                         return log_oom();
3386
3387                 if (invert)
3388                         /* Log everything but the ones listed */
3389                         c->syscall_log_allow_list = false;
3390                 else
3391                         /* Log nothing but the ones listed */
3392                         c->syscall_log_allow_list = true;
3393         }
3394
3395         p = rvalue;
3396         for (;;) {
3397                 _cleanup_free_ char *word = NULL;
3398
3399                 r = extract_first_word(&p, &word, NULL, 0);
3400                 if (r == -ENOMEM)
3401                         return log_oom();
3402                 if (r < 0) {
3403                         log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
3404                         return 0;
3405                 }
3406                 if (r == 0)
3407                         return 0;
3408
3409                 r = seccomp_parse_syscall_filter(
3410                                 word, -1, c->syscall_log,
3411                                 SECCOMP_PARSE_LOG|SECCOMP_PARSE_PERMISSIVE|
3412                                 (invert ? SECCOMP_PARSE_INVERT : 0)|
3413                                 (c->syscall_log_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
3414                                 unit, filename, line);
3415                 if (r < 0)
3416                         return r;
3417         }
3418 }
3419
3420 int config_parse_syscall_archs(
3421                 const char *unit,
3422                 const char *filename,
3423                 unsigned line,
3424                 const char *section,
3425                 unsigned section_line,
3426                 const char *lvalue,
3427                 int ltype,
3428                 const char *rvalue,
3429                 void *data,
3430                 void *userdata) {
3431
3432         Set **archs = data;
3433         int r;
3434
3435         if (isempty(rvalue)) {
3436                 *archs = set_free(*archs);
3437                 return 0;
3438         }
3439
3440         for (const char *p = rvalue;;) {
3441                 _cleanup_free_ char *word = NULL;
3442                 uint32_t a;
3443
3444                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
3445                 if (r == -ENOMEM)
3446                         return log_oom();
3447                 if (r < 0) {
3448                         log_syntax(unit, LOG_WARNING, filename, line, r,
3449                                    "Invalid syntax, ignoring: %s", rvalue);
3450                         return 0;
3451                 }
3452                 if (r == 0)
3453                         return 0;
3454
3455                 r = seccomp_arch_from_string(word, &a);
3456                 if (r < 0) {
3457                         log_syntax(unit, LOG_WARNING, filename, line, r,
3458                                    "Failed to parse system call architecture \"%s\", ignoring: %m", word);
3459                         continue;
3460                 }
3461
3462                 r = set_ensure_put(archs, NULL, UINT32_TO_PTR(a + 1));
3463                 if (r < 0)
3464                         return log_oom();
3465         }
3466 }
3467
3468 int config_parse_syscall_errno(
3469                 const char *unit,
3470                 const char *filename,
3471                 unsigned line,
3472                 const char *section,
3473                 unsigned section_line,
3474                 const char *lvalue,
3475                 int ltype,
3476                 const char *rvalue,
3477                 void *data,
3478                 void *userdata) {
3479
3480         ExecContext *c = data;
3481         int e;
3482
3483         assert(filename);
3484         assert(lvalue);
3485         assert(rvalue);
3486
3487         if (isempty(rvalue) || streq(rvalue, "kill")) {
3488                 /* Empty assignment resets to KILL */
3489                 c->syscall_errno = SECCOMP_ERROR_NUMBER_KILL;
3490                 return 0;
3491         }
3492
3493         e = parse_errno(rvalue);
3494         if (e < 0) {
3495                 log_syntax(unit, LOG_WARNING, filename, line, e, "Failed to parse error number, ignoring: %s", rvalue);
3496                 return 0;
3497         }
3498         if (e == 0) {
3499                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid error number, ignoring: %s", rvalue);
3500                 return 0;
3501         }
3502
3503         c->syscall_errno = e;
3504         return 0;
3505 }
3506
3507 int config_parse_address_families(
3508                 const char *unit,
3509                 const char *filename,
3510                 unsigned line,
3511                 const char *section,
3512                 unsigned section_line,
3513                 const char *lvalue,
3514                 int ltype,
3515                 const char *rvalue,
3516                 void *data,
3517                 void *userdata) {
3518
3519         ExecContext *c = data;
3520         bool invert = false;
3521         int r;
3522
3523         assert(filename);
3524         assert(lvalue);
3525         assert(rvalue);
3526
3527         if (isempty(rvalue)) {
3528                 /* Empty assignment resets the list */
3529                 c->address_families = set_free(c->address_families);
3530                 c->address_families_allow_list = false;
3531                 return 0;
3532         }
3533
3534         if (streq(rvalue, "none")) {
3535                 /* Forbid all address families. */
3536                 c->address_families = set_free(c->address_families);
3537                 c->address_families_allow_list = true;
3538                 return 0;
3539         }
3540
3541         if (rvalue[0] == '~') {
3542                 invert = true;
3543                 rvalue++;
3544         }
3545
3546         if (!c->address_families) {
3547                 c->address_families = set_new(NULL);
3548                 if (!c->address_families)
3549                         return log_oom();
3550
3551                 c->address_families_allow_list = !invert;
3552         }
3553
3554         for (const char *p = rvalue;;) {
3555                 _cleanup_free_ char *word = NULL;
3556                 int af;
3557
3558                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
3559                 if (r == -ENOMEM)
3560                         return log_oom();
3561                 if (r < 0) {
3562                         log_syntax(unit, LOG_WARNING, filename, line, r,
3563                                    "Invalid syntax, ignoring: %s", rvalue);
3564                         return 0;
3565                 }
3566                 if (r == 0)
3567                         return 0;
3568
3569                 af = af_from_name(word);
3570                 if (af < 0) {
3571                         log_syntax(unit, LOG_WARNING, filename, line, af,
3572                                    "Failed to parse address family, ignoring: %s", word);
3573                         continue;
3574                 }
3575
3576                 /* If we previously wanted to forbid an address family and now
3577                  * we want to allow it, then just remove it from the list.
3578                  */
3579                 if (!invert == c->address_families_allow_list)  {
3580                         r = set_put(c->address_families, INT_TO_PTR(af));
3581                         if (r < 0)
3582                                 return log_oom();
3583                 } else
3584                         set_remove(c->address_families, INT_TO_PTR(af));
3585         }
3586 }
3587
3588 int config_parse_restrict_namespaces(
3589                 const char *unit,
3590                 const char *filename,
3591                 unsigned line,
3592                 const char *section,
3593                 unsigned section_line,
3594                 const char *lvalue,
3595                 int ltype,
3596                 const char *rvalue,
3597                 void *data,
3598                 void *userdata) {
3599
3600         ExecContext *c = data;
3601         unsigned long flags;
3602         bool invert = false;
3603         int r;
3604
3605         if (isempty(rvalue)) {
3606                 /* Reset to the default. */
3607                 c->restrict_namespaces = NAMESPACE_FLAGS_INITIAL;
3608                 return 0;
3609         }
3610
3611         /* Boolean parameter ignores the previous settings */
3612         r = parse_boolean(rvalue);
3613         if (r > 0) {
3614                 c->restrict_namespaces = 0;
3615                 return 0;
3616         } else if (r == 0) {
3617                 c->restrict_namespaces = NAMESPACE_FLAGS_ALL;
3618                 return 0;
3619         }
3620
3621         if (rvalue[0] == '~') {
3622                 invert = true;
3623                 rvalue++;
3624         }
3625
3626         /* Not a boolean argument, in this case it's a list of namespace types. */
3627         r = namespace_flags_from_string(rvalue, &flags);
3628         if (r < 0) {
3629                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse namespace type string, ignoring: %s", rvalue);
3630                 return 0;
3631         }
3632
3633         if (c->restrict_namespaces == NAMESPACE_FLAGS_INITIAL)
3634                 /* Initial assignment. Just set the value. */
3635                 c->restrict_namespaces = invert ? (~flags) & NAMESPACE_FLAGS_ALL : flags;
3636         else
3637                 /* Merge the value with the previous one. */
3638                 SET_FLAG(c->restrict_namespaces, flags, !invert);
3639
3640         return 0;
3641 }
3642 #endif
3643
3644 int config_parse_restrict_filesystems(
3645                 const char *unit,
3646                 const char *filename,
3647                 unsigned line,
3648                 const char *section,
3649                 unsigned section_line,
3650                 const char *lvalue,
3651                 int ltype,
3652                 const char *rvalue,
3653                 void *data,
3654                 void *userdata) {
3655         ExecContext *c = ASSERT_PTR(data);
3656         bool invert = false;
3657         int r;
3658
3659         assert(filename);
3660         assert(lvalue);
3661         assert(rvalue);
3662
3663         if (isempty(rvalue)) {
3664                 /* Empty assignment resets the list */
3665                 c->restrict_filesystems = set_free_free(c->restrict_filesystems);
3666                 c->restrict_filesystems_allow_list = false;
3667                 return 0;
3668         }
3669
3670         if (rvalue[0] == '~') {
3671                 invert = true;
3672                 rvalue++;
3673         }
3674
3675         if (!c->restrict_filesystems) {
3676                 if (invert)
3677                         /* Allow everything but the ones listed */
3678                         c->restrict_filesystems_allow_list = false;
3679                 else
3680                         /* Allow nothing but the ones listed */
3681                         c->restrict_filesystems_allow_list = true;
3682         }
3683
3684         for (const char *p = rvalue;;) {
3685                 _cleanup_free_ char *word = NULL;
3686
3687                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
3688                 if (r == 0)
3689                         break;
3690                 if (r == -ENOMEM)
3691                         return log_oom();
3692                 if (r < 0) {
3693                         log_syntax(unit, LOG_WARNING, filename, line, r,
3694                                    "Trailing garbage in %s, ignoring: %s", lvalue, rvalue);
3695                         break;
3696                 }
3697
3698                 r = lsm_bpf_parse_filesystem(
3699                               word,
3700                               &c->restrict_filesystems,
3701                               FILESYSTEM_PARSE_LOG|
3702                               (invert ? FILESYSTEM_PARSE_INVERT : 0)|
3703                               (c->restrict_filesystems_allow_list ? FILESYSTEM_PARSE_ALLOW_LIST : 0),
3704                               unit, filename, line);
3705
3706                 if (r < 0)
3707                         return r;
3708         }
3709
3710         return 0;
3711 }
3712
3713 int config_parse_unit_slice(
3714                 const char *unit,
3715                 const char *filename,
3716                 unsigned line,
3717                 const char *section,
3718                 unsigned section_line,
3719                 const char *lvalue,
3720                 int ltype,
3721                 const char *rvalue,
3722                 void *data,
3723                 void *userdata) {
3724
3725         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3726         _cleanup_free_ char *k = NULL;
3727         Unit *u = userdata, *slice;
3728         int r;
3729
3730         assert(filename);
3731         assert(lvalue);
3732         assert(rvalue);
3733         assert(u);
3734
3735         r = unit_name_printf(u, rvalue, &k);
3736         if (r < 0) {
3737                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", rvalue);
3738                 return 0;
3739         }
3740
3741         r = manager_load_unit(u->manager, k, NULL, &error, &slice);
3742         if (r < 0) {
3743                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to load slice unit %s, ignoring: %s", k, bus_error_message(&error, r));
3744                 return 0;
3745         }
3746
3747         r = unit_set_slice(u, slice);
3748         if (r < 0) {
3749                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to assign slice %s to unit %s, ignoring: %m", slice->id, u->id);
3750                 return 0;
3751         }
3752
3753         return 0;
3754 }
3755
3756 int config_parse_cpu_quota(
3757                 const char *unit,
3758                 const char *filename,
3759                 unsigned line,
3760                 const char *section,
3761                 unsigned section_line,
3762                 const char *lvalue,
3763                 int ltype,
3764                 const char *rvalue,
3765                 void *data,
3766                 void *userdata) {
3767
3768         CGroupContext *c = data;
3769         int r;
3770
3771         assert(filename);
3772         assert(lvalue);
3773         assert(rvalue);
3774
3775         if (isempty(rvalue)) {
3776                 c->cpu_quota_per_sec_usec = USEC_INFINITY;
3777                 return 0;
3778         }
3779
3780         r = parse_permyriad_unbounded(rvalue);
3781         if (r <= 0) {
3782                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid CPU quota '%s', ignoring.", rvalue);
3783                 return 0;
3784         }
3785
3786         c->cpu_quota_per_sec_usec = ((usec_t) r * USEC_PER_SEC) / 10000U;
3787         return 0;
3788 }
3789
3790 int config_parse_allowed_cpuset(
3791                 const char *unit,
3792                 const char *filename,
3793                 unsigned line,
3794                 const char *section,
3795                 unsigned section_line,
3796                 const char *lvalue,
3797                 int ltype,
3798                 const char *rvalue,
3799                 void *data,
3800                 void *userdata) {
3801
3802         CPUSet *c = data;
3803
3804         (void) parse_cpu_set_extend(rvalue, c, true, unit, filename, line, lvalue);
3805         return 0;
3806 }
3807
3808 int config_parse_memory_limit(
3809                 const char *unit,
3810                 const char *filename,
3811                 unsigned line,
3812                 const char *section,
3813                 unsigned section_line,
3814                 const char *lvalue,
3815                 int ltype,
3816                 const char *rvalue,
3817                 void *data,
3818                 void *userdata) {
3819
3820         CGroupContext *c = data;
3821         uint64_t bytes = CGROUP_LIMIT_MAX;
3822         int r;
3823
3824         if (isempty(rvalue) && STR_IN_SET(lvalue, "DefaultMemoryLow",
3825                                                   "DefaultMemoryMin",
3826                                                   "MemoryLow",
3827                                                   "StartupMemoryLow",
3828                                                   "MemoryMin"))
3829                 bytes = CGROUP_LIMIT_MIN;
3830         else if (!isempty(rvalue) && !streq(rvalue, "infinity")) {
3831
3832                 r = parse_permyriad(rvalue);
3833                 if (r < 0) {
3834                         r = parse_size(rvalue, 1024, &bytes);
3835                         if (r < 0) {
3836                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid memory limit '%s', ignoring: %m", rvalue);
3837                                 return 0;
3838                         }
3839                 } else
3840                         bytes = physical_memory_scale(r, 10000U);
3841
3842                 if (bytes >= UINT64_MAX ||
3843                     (bytes <= 0 && !STR_IN_SET(lvalue,
3844                                                "MemorySwapMax",
3845                                                "StartupMemorySwapMax",
3846                                                "MemoryZSwapMax",
3847                                                "StartupMemoryZSwapMax",
3848                                                "MemoryLow",
3849                                                "StartupMemoryLow",
3850                                                "MemoryMin",
3851                                                "DefaultMemoryLow",
3852                                                "DefaultstartupMemoryLow",
3853                                                "DefaultMemoryMin"))) {
3854                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Memory limit '%s' out of range, ignoring.", rvalue);
3855                         return 0;
3856                 }
3857         }
3858
3859         if (streq(lvalue, "DefaultMemoryLow")) {
3860                 c->default_memory_low = bytes;
3861                 c->default_memory_low_set = true;
3862         } else if (streq(lvalue, "DefaultStartupMemoryLow")) {
3863                 c->default_startup_memory_low = bytes;
3864                 c->default_startup_memory_low_set = true;
3865         } else if (streq(lvalue, "DefaultMemoryMin")) {
3866                 c->default_memory_min = bytes;
3867                 c->default_memory_min_set = true;
3868         } else if (streq(lvalue, "MemoryMin")) {
3869                 c->memory_min = bytes;
3870                 c->memory_min_set = true;
3871         } else if (streq(lvalue, "MemoryLow")) {
3872                 c->memory_low = bytes;
3873                 c->memory_low_set = true;
3874         } else if (streq(lvalue, "StartupMemoryLow")) {
3875                 c->startup_memory_low = bytes;
3876                 c->startup_memory_low_set = true;
3877         } else if (streq(lvalue, "MemoryHigh"))
3878                 c->memory_high = bytes;
3879         else if (streq(lvalue, "StartupMemoryHigh")) {
3880                 c->startup_memory_high = bytes;
3881                 c->startup_memory_high_set = true;
3882         } else if (streq(lvalue, "MemoryMax"))
3883                 c->memory_max = bytes;
3884         else if (streq(lvalue, "StartupMemoryMax")) {
3885                 c->startup_memory_max = bytes;
3886                 c->startup_memory_max_set = true;
3887         } else if (streq(lvalue, "MemorySwapMax"))
3888                 c->memory_swap_max = bytes;
3889         else if (streq(lvalue, "StartupMemorySwapMax")) {
3890                 c->startup_memory_swap_max = bytes;
3891                 c->startup_memory_swap_max_set = true;
3892         } else if (streq(lvalue, "MemoryZSwapMax"))
3893                 c->memory_zswap_max = bytes;
3894         else if (streq(lvalue, "StartupMemoryZSwapMax")) {
3895                 c->startup_memory_zswap_max = bytes;
3896                 c->startup_memory_zswap_max_set = true;
3897         } else if (streq(lvalue, "MemoryLimit")) {
3898                 log_syntax(unit, LOG_WARNING, filename, line, 0,
3899                            "Unit uses MemoryLimit=; please use MemoryMax= instead. Support for MemoryLimit= will be removed soon.");
3900                 c->memory_limit = bytes;
3901         } else
3902                 return -EINVAL;
3903
3904         return 0;
3905 }
3906
3907 int config_parse_tasks_max(
3908                 const char *unit,
3909                 const char *filename,
3910                 unsigned line,
3911                 const char *section,
3912                 unsigned section_line,
3913                 const char *lvalue,
3914                 int ltype,
3915                 const char *rvalue,
3916                 void *data,
3917                 void *userdata) {
3918
3919         const Unit *u = userdata;
3920         CGroupTasksMax *tasks_max = data;
3921         uint64_t v;
3922         int r;
3923
3924         if (isempty(rvalue)) {
3925                 *tasks_max = u ? u->manager->defaults.tasks_max : CGROUP_TASKS_MAX_UNSET;
3926                 return 0;
3927         }
3928
3929         if (streq(rvalue, "infinity")) {
3930                 *tasks_max = CGROUP_TASKS_MAX_UNSET;
3931                 return 0;
3932         }
3933
3934         r = parse_permyriad(rvalue);
3935         if (r >= 0)
3936                 *tasks_max = (CGroupTasksMax) { r, 10000U }; /* r‱ */
3937         else {
3938                 r = safe_atou64(rvalue, &v);
3939                 if (r < 0) {
3940                         log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid maximum tasks value '%s', ignoring: %m", rvalue);
3941                         return 0;
3942                 }
3943
3944                 if (v <= 0 || v >= UINT64_MAX) {
3945                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Maximum tasks value '%s' out of range, ignoring.", rvalue);
3946                         return 0;
3947                 }
3948
3949                 *tasks_max = (CGroupTasksMax) { v };
3950         }
3951
3952         return 0;
3953 }
3954
3955 int config_parse_delegate(
3956                 const char *unit,
3957                 const char *filename,
3958                 unsigned line,
3959                 const char *section,
3960                 unsigned section_line,
3961                 const char *lvalue,
3962                 int ltype,
3963                 const char *rvalue,
3964                 void *data,
3965                 void *userdata) {
3966
3967         CGroupContext *c = data;
3968         UnitType t;
3969         int r;
3970
3971         t = unit_name_to_type(unit);
3972         assert(t != _UNIT_TYPE_INVALID);
3973
3974         if (!unit_vtable[t]->can_delegate) {
3975                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Delegate= setting not supported for this unit type, ignoring.");
3976                 return 0;
3977         }
3978
3979         /* We either accept a boolean value, which may be used to turn on delegation for all controllers, or
3980          * turn it off for all. Or it takes a list of controller names, in which case we add the specified
3981          * controllers to the mask to delegate. Delegate= enables delegation without any controllers. */
3982
3983         if (isempty(rvalue)) {
3984                 /* An empty string resets controllers and sets Delegate=yes. */
3985                 c->delegate = true;
3986                 c->delegate_controllers = 0;
3987                 return 0;
3988         }
3989
3990         r = parse_boolean(rvalue);
3991         if (r < 0) {
3992                 CGroupMask mask = 0;
3993
3994                 for (const char *p = rvalue;;) {
3995                         _cleanup_free_ char *word = NULL;
3996                         CGroupController cc;
3997
3998                         r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
3999                         if (r == -ENOMEM)
4000                                 return log_oom();
4001                         if (r < 0) {
4002                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
4003                                 return 0;
4004                         }
4005                         if (r == 0)
4006                                 break;
4007
4008                         cc = cgroup_controller_from_string(word);
4009                         if (cc < 0) {
4010                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid controller name '%s', ignoring", word);
4011                                 continue;
4012                         }
4013
4014                         mask |= CGROUP_CONTROLLER_TO_MASK(cc);
4015                 }
4016
4017                 c->delegate = true;
4018                 c->delegate_controllers |= mask;
4019
4020         } else if (r > 0) {
4021                 c->delegate = true;
4022                 c->delegate_controllers = _CGROUP_MASK_ALL;
4023         } else {
4024                 c->delegate = false;
4025                 c->delegate_controllers = 0;
4026         }
4027
4028         return 0;
4029 }
4030
4031 int config_parse_delegate_subgroup(
4032                 const char *unit,
4033                 const char *filename,
4034                 unsigned line,
4035                 const char *section,
4036                 unsigned section_line,
4037                 const char *lvalue,
4038                 int ltype,
4039                 const char *rvalue,
4040                 void *data,
4041                 void *userdata) {
4042
4043         CGroupContext *c = ASSERT_PTR(data);
4044         UnitType t;
4045
4046         t = unit_name_to_type(unit);
4047         assert(t >= 0);
4048
4049         if (!unit_vtable[t]->can_delegate) {
4050                 log_syntax(unit, LOG_WARNING, filename, line, 0, "DelegateSubgroup= setting not supported for this unit type, ignoring.");
4051                 return 0;
4052         }
4053
4054         if (isempty(rvalue)) {
4055                 c->delegate_subgroup = mfree(c->delegate_subgroup);
4056                 return 0;
4057         }
4058
4059         if (cg_needs_escape(rvalue)) { /* Insist that specified names don't need escaping */
4060                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid control group name, ignoring: %s", rvalue);
4061                 return 0;
4062         }
4063
4064         return free_and_strdup_warn(&c->delegate_subgroup, rvalue);
4065 }
4066
4067 int config_parse_managed_oom_mode(
4068                 const char *unit,
4069                 const char *filename,
4070                 unsigned line,
4071                 const char *section,
4072                 unsigned section_line,
4073                 const char *lvalue,
4074                 int ltype,
4075                 const char *rvalue,
4076                 void *data,
4077                 void *userdata) {
4078
4079         ManagedOOMMode *mode = data, m;
4080         UnitType t;
4081
4082         t = unit_name_to_type(unit);
4083         assert(t != _UNIT_TYPE_INVALID);
4084
4085         if (!unit_vtable[t]->can_set_managed_oom)
4086                 return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
4087
4088         if (isempty(rvalue)) {
4089                 *mode = MANAGED_OOM_AUTO;
4090                 return 0;
4091         }
4092
4093         m = managed_oom_mode_from_string(rvalue);
4094         if (m < 0) {
4095                 log_syntax(unit, LOG_WARNING, filename, line, m, "Invalid syntax, ignoring: %s", rvalue);
4096                 return 0;
4097         }
4098
4099         *mode = m;
4100         return 0;
4101 }
4102
4103 int config_parse_managed_oom_mem_pressure_limit(
4104                 const char *unit,
4105                 const char *filename,
4106                 unsigned line,
4107                 const char *section,
4108                 unsigned section_line,
4109                 const char *lvalue,
4110                 int ltype,
4111                 const char *rvalue,
4112                 void *data,
4113                 void *userdata) {
4114
4115         uint32_t *limit = data;
4116         UnitType t;
4117         int r;
4118
4119         t = unit_name_to_type(unit);
4120         assert(t != _UNIT_TYPE_INVALID);
4121
4122         if (!unit_vtable[t]->can_set_managed_oom)
4123                 return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
4124
4125         if (isempty(rvalue)) {
4126                 *limit = 0;
4127                 return 0;
4128         }
4129
4130         r = parse_permyriad(rvalue);
4131         if (r < 0) {
4132                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse memory pressure limit value, ignoring: %s", rvalue);
4133                 return 0;
4134         }
4135
4136         /* Normalize to 2^32-1 == 100% */
4137         *limit = UINT32_SCALE_FROM_PERMYRIAD(r);
4138         return 0;
4139 }
4140
4141 int config_parse_device_allow(
4142                 const char *unit,
4143                 const char *filename,
4144                 unsigned line,
4145                 const char *section,
4146                 unsigned section_line,
4147                 const char *lvalue,
4148                 int ltype,
4149                 const char *rvalue,
4150                 void *data,
4151                 void *userdata) {
4152
4153         _cleanup_free_ char *path = NULL, *resolved = NULL;
4154         CGroupDevicePermissions permissions;
4155         CGroupContext *c = data;
4156         const char *p = rvalue;
4157         int r;
4158
4159         if (isempty(rvalue)) {
4160                 while (c->device_allow)
4161                         cgroup_context_free_device_allow(c, c->device_allow);
4162
4163                 return 0;
4164         }
4165
4166         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4167         if (r == -ENOMEM)
4168                 return log_oom();
4169         if (r <= 0) {
4170                 log_syntax(unit, LOG_WARNING, filename, line, r,
4171                            "Failed to extract device path and rights from '%s', ignoring.", rvalue);
4172                 return 0;
4173         }
4174
4175         r = unit_path_printf(userdata, path, &resolved);
4176         if (r < 0) {
4177                 log_syntax(unit, LOG_WARNING, filename, line, r,
4178                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4179                 return 0;
4180         }
4181
4182         if (!STARTSWITH_SET(resolved, "block-", "char-")) {
4183
4184                 r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4185                 if (r < 0)
4186                         return 0;
4187
4188                 if (!valid_device_node_path(resolved)) {
4189                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid device node path '%s', ignoring.", resolved);
4190                         return 0;
4191                 }
4192         }
4193
4194         permissions = isempty(p) ? 0 : cgroup_device_permissions_from_string(p);
4195         if (permissions < 0) {
4196                 log_syntax(unit, LOG_WARNING, filename, line, permissions, "Invalid device rights '%s', ignoring.", p);
4197                 return 0;
4198         }
4199
4200         return cgroup_context_add_device_allow(c, resolved, permissions);
4201 }
4202
4203 int config_parse_io_device_weight(
4204                 const char *unit,
4205                 const char *filename,
4206                 unsigned line,
4207                 const char *section,
4208                 unsigned section_line,
4209                 const char *lvalue,
4210                 int ltype,
4211                 const char *rvalue,
4212                 void *data,
4213                 void *userdata) {
4214
4215         _cleanup_free_ char *path = NULL, *resolved = NULL;
4216         CGroupIODeviceWeight *w;
4217         CGroupContext *c = data;
4218         const char *p = ASSERT_PTR(rvalue);
4219         uint64_t u;
4220         int r;
4221
4222         assert(filename);
4223         assert(lvalue);
4224
4225         if (isempty(rvalue)) {
4226                 while (c->io_device_weights)
4227                         cgroup_context_free_io_device_weight(c, c->io_device_weights);
4228
4229                 return 0;
4230         }
4231
4232         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4233         if (r == -ENOMEM)
4234                 return log_oom();
4235         if (r < 0) {
4236                 log_syntax(unit, LOG_WARNING, filename, line, r,
4237                            "Failed to extract device path and weight from '%s', ignoring.", rvalue);
4238                 return 0;
4239         }
4240         if (r == 0 || isempty(p)) {
4241                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4242                            "Invalid device path or weight specified in '%s', ignoring.", rvalue);
4243                 return 0;
4244         }
4245
4246         r = unit_path_printf(userdata, path, &resolved);
4247         if (r < 0) {
4248                 log_syntax(unit, LOG_WARNING, filename, line, r,
4249                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4250                 return 0;
4251         }
4252
4253         r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4254         if (r < 0)
4255                 return 0;
4256
4257         r = cg_weight_parse(p, &u);
4258         if (r < 0) {
4259                 log_syntax(unit, LOG_WARNING, filename, line, r, "IO weight '%s' invalid, ignoring: %m", p);
4260                 return 0;
4261         }
4262
4263         assert(u != CGROUP_WEIGHT_INVALID);
4264
4265         w = new0(CGroupIODeviceWeight, 1);
4266         if (!w)
4267                 return log_oom();
4268
4269         w->path = TAKE_PTR(resolved);
4270         w->weight = u;
4271
4272         LIST_PREPEND(device_weights, c->io_device_weights, w);
4273         return 0;
4274 }
4275
4276 int config_parse_io_device_latency(
4277                 const char *unit,
4278                 const char *filename,
4279                 unsigned line,
4280                 const char *section,
4281                 unsigned section_line,
4282                 const char *lvalue,
4283                 int ltype,
4284                 const char *rvalue,
4285                 void *data,
4286                 void *userdata) {
4287
4288         _cleanup_free_ char *path = NULL, *resolved = NULL;
4289         CGroupIODeviceLatency *l;
4290         CGroupContext *c = data;
4291         const char *p = ASSERT_PTR(rvalue);
4292         usec_t usec;
4293         int r;
4294
4295         assert(filename);
4296         assert(lvalue);
4297
4298         if (isempty(rvalue)) {
4299                 while (c->io_device_latencies)
4300                         cgroup_context_free_io_device_latency(c, c->io_device_latencies);
4301
4302                 return 0;
4303         }
4304
4305         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4306         if (r == -ENOMEM)
4307                 return log_oom();
4308         if (r < 0) {
4309                 log_syntax(unit, LOG_WARNING, filename, line, r,
4310                            "Failed to extract device path and latency from '%s', ignoring.", rvalue);
4311                 return 0;
4312         }
4313         if (r == 0 || isempty(p)) {
4314                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4315                            "Invalid device path or latency specified in '%s', ignoring.", rvalue);
4316                 return 0;
4317         }
4318
4319         r = unit_path_printf(userdata, path, &resolved);
4320         if (r < 0) {
4321                 log_syntax(unit, LOG_WARNING, filename, line, r,
4322                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4323                 return 0;
4324         }
4325
4326         r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4327         if (r < 0)
4328                 return 0;
4329
4330         r = parse_sec(p, &usec);
4331         if (r < 0) {
4332                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse timer value, ignoring: %s", p);
4333                 return 0;
4334         }
4335
4336         l = new0(CGroupIODeviceLatency, 1);
4337         if (!l)
4338                 return log_oom();
4339
4340         l->path = TAKE_PTR(resolved);
4341         l->target_usec = usec;
4342
4343         LIST_PREPEND(device_latencies, c->io_device_latencies, l);
4344         return 0;
4345 }
4346
4347 int config_parse_io_limit(
4348                 const char *unit,
4349                 const char *filename,
4350                 unsigned line,
4351                 const char *section,
4352                 unsigned section_line,
4353                 const char *lvalue,
4354                 int ltype,
4355                 const char *rvalue,
4356                 void *data,
4357                 void *userdata) {
4358
4359         _cleanup_free_ char *path = NULL, *resolved = NULL;
4360         CGroupIODeviceLimit *l = NULL;
4361         CGroupContext *c = data;
4362         CGroupIOLimitType type;
4363         const char *p = ASSERT_PTR(rvalue);
4364         uint64_t num;
4365         int r;
4366
4367         assert(filename);
4368         assert(lvalue);
4369
4370         type = cgroup_io_limit_type_from_string(lvalue);
4371         assert(type >= 0);
4372
4373         if (isempty(rvalue)) {
4374                 LIST_FOREACH(device_limits, t, c->io_device_limits)
4375                         t->limits[type] = cgroup_io_limit_defaults[type];
4376                 return 0;
4377         }
4378
4379         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4380         if (r == -ENOMEM)
4381                 return log_oom();
4382         if (r < 0) {
4383                 log_syntax(unit, LOG_WARNING, filename, line, r,
4384                            "Failed to extract device node and bandwidth from '%s', ignoring.", rvalue);
4385                 return 0;
4386         }
4387         if (r == 0 || isempty(p)) {
4388                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4389                            "Invalid device node or bandwidth specified in '%s', ignoring.", rvalue);
4390                 return 0;
4391         }
4392
4393         r = unit_path_printf(userdata, path, &resolved);
4394         if (r < 0) {
4395                 log_syntax(unit, LOG_WARNING, filename, line, r,
4396                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4397                 return 0;
4398         }
4399
4400         r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4401         if (r < 0)
4402                 return 0;
4403
4404         if (streq("infinity", p))
4405                 num = CGROUP_LIMIT_MAX;
4406         else {
4407                 r = parse_size(p, 1000, &num);
4408                 if (r < 0 || num <= 0) {
4409                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid IO limit '%s', ignoring.", p);
4410                         return 0;
4411                 }
4412         }
4413
4414         LIST_FOREACH(device_limits, t, c->io_device_limits)
4415                 if (path_equal(resolved, t->path)) {
4416                         l = t;
4417                         break;
4418                 }
4419
4420         if (!l) {
4421                 l = new0(CGroupIODeviceLimit, 1);
4422                 if (!l)
4423                         return log_oom();
4424
4425                 l->path = TAKE_PTR(resolved);
4426                 for (CGroupIOLimitType i = 0; i < _CGROUP_IO_LIMIT_TYPE_MAX; i++)
4427                         l->limits[i] = cgroup_io_limit_defaults[i];
4428
4429                 LIST_PREPEND(device_limits, c->io_device_limits, l);
4430         }
4431
4432         l->limits[type] = num;
4433
4434         return 0;
4435 }
4436
4437 int config_parse_blockio_device_weight(
4438                 const char *unit,
4439                 const char *filename,
4440                 unsigned line,
4441                 const char *section,
4442                 unsigned section_line,
4443                 const char *lvalue,
4444                 int ltype,
4445                 const char *rvalue,
4446                 void *data,
4447                 void *userdata) {
4448
4449         _cleanup_free_ char *path = NULL, *resolved = NULL;
4450         CGroupBlockIODeviceWeight *w;
4451         CGroupContext *c = data;
4452         const char *p = ASSERT_PTR(rvalue);
4453         uint64_t u;
4454         int r;
4455
4456         assert(filename);
4457         assert(lvalue);
4458
4459         log_syntax(unit, LOG_WARNING, filename, line, 0,
4460                    "Unit uses %s=; please use IO*= settings instead. Support for %s= will be removed soon.",
4461                    lvalue, lvalue);
4462
4463         if (isempty(rvalue)) {
4464                 while (c->blockio_device_weights)
4465                         cgroup_context_free_blockio_device_weight(c, c->blockio_device_weights);
4466
4467                 return 0;
4468         }
4469
4470         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4471         if (r == -ENOMEM)
4472                 return log_oom();
4473         if (r < 0) {
4474                 log_syntax(unit, LOG_WARNING, filename, line, r,
4475                            "Failed to extract device node and weight from '%s', ignoring.", rvalue);
4476                 return 0;
4477         }
4478         if (r == 0 || isempty(p)) {
4479                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4480                            "Invalid device node or weight specified in '%s', ignoring.", rvalue);
4481                 return 0;
4482         }
4483
4484         r = unit_path_printf(userdata, path, &resolved);
4485         if (r < 0) {
4486                 log_syntax(unit, LOG_WARNING, filename, line, r,
4487                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4488                 return 0;
4489         }
4490
4491         r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4492         if (r < 0)
4493                 return 0;
4494
4495         r = cg_blkio_weight_parse(p, &u);
4496         if (r < 0) {
4497                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid block IO weight '%s', ignoring: %m", p);
4498                 return 0;
4499         }
4500
4501         assert(u != CGROUP_BLKIO_WEIGHT_INVALID);
4502
4503         w = new0(CGroupBlockIODeviceWeight, 1);
4504         if (!w)
4505                 return log_oom();
4506
4507         w->path = TAKE_PTR(resolved);
4508         w->weight = u;
4509
4510         LIST_PREPEND(device_weights, c->blockio_device_weights, w);
4511         return 0;
4512 }
4513
4514 int config_parse_blockio_bandwidth(
4515                 const char *unit,
4516                 const char *filename,
4517                 unsigned line,
4518                 const char *section,
4519                 unsigned section_line,
4520                 const char *lvalue,
4521                 int ltype,
4522                 const char *rvalue,
4523                 void *data,
4524                 void *userdata) {
4525
4526         _cleanup_free_ char *path = NULL, *resolved = NULL;
4527         CGroupBlockIODeviceBandwidth *b = NULL;
4528         CGroupContext *c = data;
4529         const char *p = ASSERT_PTR(rvalue);
4530         uint64_t bytes;
4531         bool read;
4532         int r;
4533
4534         assert(filename);
4535         assert(lvalue);
4536
4537         log_syntax(unit, LOG_WARNING, filename, line, 0,
4538                    "Unit uses %s=; please use IO*= settings instead. Support for %s= will be removed soon.",
4539                    lvalue, lvalue);
4540
4541         read = streq("BlockIOReadBandwidth", lvalue);
4542
4543         if (isempty(rvalue)) {
4544                 LIST_FOREACH(device_bandwidths, t, c->blockio_device_bandwidths) {
4545                         t->rbps = CGROUP_LIMIT_MAX;
4546                         t->wbps = CGROUP_LIMIT_MAX;
4547                 }
4548                 return 0;
4549         }
4550
4551         r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
4552         if (r == -ENOMEM)
4553                 return log_oom();
4554         if (r < 0) {
4555                 log_syntax(unit, LOG_WARNING, filename, line, r,
4556                            "Failed to extract device node and bandwidth from '%s', ignoring.", rvalue);
4557                 return 0;
4558         }
4559         if (r == 0 || isempty(p)) {
4560                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4561                            "Invalid device node or bandwidth specified in '%s', ignoring.", rvalue);
4562                 return 0;
4563         }
4564
4565         r = unit_path_printf(userdata, path, &resolved);
4566         if (r < 0) {
4567                 log_syntax(unit, LOG_WARNING, filename, line, r,
4568                            "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
4569                 return 0;
4570         }
4571
4572         r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
4573         if (r < 0)
4574                 return 0;
4575
4576         r = parse_size(p, 1000, &bytes);
4577         if (r < 0 || bytes <= 0) {
4578                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid Block IO Bandwidth '%s', ignoring.", p);
4579                 return 0;
4580         }
4581
4582         LIST_FOREACH(device_bandwidths, t, c->blockio_device_bandwidths)
4583                 if (path_equal(resolved, t->path)) {
4584                         b = t;
4585                         break;
4586                 }
4587
4588         if (!b) {
4589                 b = new0(CGroupBlockIODeviceBandwidth, 1);
4590                 if (!b)
4591                         return log_oom();
4592
4593                 b->path = TAKE_PTR(resolved);
4594                 b->rbps = CGROUP_LIMIT_MAX;
4595                 b->wbps = CGROUP_LIMIT_MAX;
4596
4597                 LIST_PREPEND(device_bandwidths, c->blockio_device_bandwidths, b);
4598         }
4599
4600         if (read)
4601                 b->rbps = bytes;
4602         else
4603                 b->wbps = bytes;
4604
4605         return 0;
4606 }
4607
4608 int config_parse_job_mode_isolate(
4609                 const char *unit,
4610                 const char *filename,
4611                 unsigned line,
4612                 const char *section,
4613                 unsigned section_line,
4614                 const char *lvalue,
4615                 int ltype,
4616                 const char *rvalue,
4617                 void *data,
4618                 void *userdata) {
4619
4620         JobMode *m = data;
4621         int r;
4622
4623         assert(filename);
4624         assert(lvalue);
4625         assert(rvalue);
4626
4627         r = parse_boolean(rvalue);
4628         if (r < 0) {
4629                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse boolean, ignoring: %s", rvalue);
4630                 return 0;
4631         }
4632
4633         log_notice("%s is deprecated. Please use OnFailureJobMode= instead", lvalue);
4634
4635         *m = r ? JOB_ISOLATE : JOB_REPLACE;
4636         return 0;
4637 }
4638
4639 int config_parse_exec_directories(
4640                 const char *unit,
4641                 const char *filename,
4642                 unsigned line,
4643                 const char *section,
4644                 unsigned section_line,
4645                 const char *lvalue,
4646                 int ltype,
4647                 const char *rvalue,
4648                 void *data,
4649                 void *userdata) {
4650
4651         ExecDirectory *ed = ASSERT_PTR(data);
4652         const Unit *u = userdata;
4653         int r;
4654
4655         assert(filename);
4656         assert(lvalue);
4657         assert(rvalue);
4658
4659         if (isempty(rvalue)) {
4660                 /* Empty assignment resets the list */
4661                 exec_directory_done(ed);
4662                 return 0;
4663         }
4664
4665         for (const char *p = rvalue;;) {
4666                 _cleanup_free_ char *tuple = NULL;
4667
4668                 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
4669                 if (r == -ENOMEM)
4670                         return log_oom();
4671                 if (r < 0) {
4672                         log_syntax(unit, LOG_WARNING, filename, line, r,
4673                                    "Invalid syntax %s=%s, ignoring: %m", lvalue, rvalue);
4674                         return 0;
4675                 }
4676                 if (r == 0)
4677                         return 0;
4678
4679                 _cleanup_free_ char *src = NULL, *dest = NULL;
4680                 const char *q = tuple;
4681                 r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &src, &dest, NULL);
4682                 if (r == -ENOMEM)
4683                         return log_oom();
4684                 if (r <= 0) {
4685                         log_syntax(unit, LOG_WARNING, filename, line, r,
4686                                    "Invalid syntax in %s=, ignoring: %s", lvalue, tuple);
4687                         return 0;
4688                 }
4689
4690                 _cleanup_free_ char *sresolved = NULL;
4691                 r = unit_path_printf(u, src, &sresolved);
4692                 if (r < 0) {
4693                         log_syntax(unit, LOG_WARNING, filename, line, r,
4694                                    "Failed to resolve unit specifiers in \"%s\", ignoring: %m", src);
4695                         continue;
4696                 }
4697
4698                 r = path_simplify_and_warn(sresolved, PATH_CHECK_RELATIVE, unit, filename, line, lvalue);
4699                 if (r < 0)
4700                         continue;
4701
4702                 if (path_startswith(sresolved, "private")) {
4703                         log_syntax(unit, LOG_WARNING, filename, line, 0,
4704                                    "%s= path can't be 'private', ignoring assignment: %s", lvalue, tuple);
4705                         continue;
4706                 }
4707
4708                 /* For State and Runtime directories we support an optional destination parameter, which
4709                  * will be used to create a symlink to the source. */
4710                 _cleanup_free_ char *dresolved = NULL;
4711                 if (!isempty(dest)) {
4712                         if (streq(lvalue, "ConfigurationDirectory")) {
4713                                 log_syntax(unit, LOG_WARNING, filename, line, 0,
4714                                            "Destination parameter is not supported for ConfigurationDirectory, ignoring: %s", tuple);
4715                                 continue;
4716                         }
4717
4718                         r = unit_path_printf(u, dest, &dresolved);
4719                         if (r < 0) {
4720                                 log_syntax(unit, LOG_WARNING, filename, line, r,
4721                                         "Failed to resolve unit specifiers in \"%s\", ignoring: %m", dest);
4722                                 continue;
4723                         }
4724
4725                         r = path_simplify_and_warn(dresolved, PATH_CHECK_RELATIVE, unit, filename, line, lvalue);
4726                         if (r < 0)
4727                                 continue;
4728                 }
4729
4730                 r = exec_directory_add(ed, sresolved, dresolved);
4731                 if (r < 0)
4732                         return log_oom();
4733         }
4734 }
4735
4736 int config_parse_set_credential(
4737                 const char *unit,
4738                 const char *filename,
4739                 unsigned line,
4740                 const char *section,
4741                 unsigned section_line,
4742                 const char *lvalue,
4743                 int ltype,
4744                 const char *rvalue,
4745                 void *data,
4746                 void *userdata) {
4747
4748         _cleanup_free_ char *word = NULL, *k = NULL;
4749         _cleanup_free_ void *d = NULL;
4750         ExecContext *context = ASSERT_PTR(data);
4751         ExecSetCredential *old;
4752         Unit *u = userdata;
4753         bool encrypted = ltype;
4754         const char *p = ASSERT_PTR(rvalue);
4755         size_t size;
4756         int r;
4757
4758         assert(filename);
4759         assert(lvalue);
4760
4761         if (isempty(rvalue)) {
4762                 /* Empty assignment resets the list */
4763                 context->set_credentials = hashmap_free(context->set_credentials);
4764                 return 0;
4765         }
4766
4767         r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
4768         if (r == -ENOMEM)
4769                 return log_oom();
4770         if (r < 0) {
4771                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract credential name, ignoring: %s", rvalue);
4772                 return 0;
4773         }
4774         if (r == 0 || isempty(p)) {
4775                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid syntax, ignoring: %s", rvalue);
4776                 return 0;
4777         }
4778
4779         r = unit_cred_printf(u, word, &k);
4780         if (r < 0) {
4781                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", word);
4782                 return 0;
4783         }
4784         if (!credential_name_valid(k)) {
4785                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name \"%s\" not valid, ignoring.", k);
4786                 return 0;
4787         }
4788
4789         if (encrypted) {
4790                 r = unbase64mem_full(p, SIZE_MAX, true, &d, &size);
4791                 if (r < 0) {
4792                         log_syntax(unit, LOG_WARNING, filename, line, r, "Encrypted credential data not valid Base64 data, ignoring.");
4793                         return 0;
4794                 }
4795         } else {
4796                 char *unescaped;
4797                 ssize_t l;
4798
4799                 /* We support escape codes here, so that users can insert trailing \n if they like */
4800                 l = cunescape(p, UNESCAPE_ACCEPT_NUL, &unescaped);
4801                 if (l < 0) {
4802                         log_syntax(unit, LOG_WARNING, filename, line, l, "Can't unescape \"%s\", ignoring: %m", p);
4803                         return 0;
4804                 }
4805
4806                 d = unescaped;
4807                 size = l;
4808         }
4809
4810         old = hashmap_get(context->set_credentials, k);
4811         if (old) {
4812                 free_and_replace(old->data, d);
4813                 old->size = size;
4814                 old->encrypted = encrypted;
4815         } else {
4816                 _cleanup_(exec_set_credential_freep) ExecSetCredential *sc = NULL;
4817
4818                 sc = new(ExecSetCredential, 1);
4819                 if (!sc)
4820                         return log_oom();
4821
4822                 *sc = (ExecSetCredential) {
4823                         .id = TAKE_PTR(k),
4824                         .data = TAKE_PTR(d),
4825                         .size = size,
4826                         .encrypted = encrypted,
4827                 };
4828
4829                 r = hashmap_ensure_put(&context->set_credentials, &exec_set_credential_hash_ops, sc->id, sc);
4830                 if (r == -ENOMEM)
4831                         return log_oom();
4832                 if (r < 0) {
4833                         log_syntax(unit, LOG_WARNING, filename, line, r,
4834                                    "Duplicated credential value '%s', ignoring assignment: %s", sc->id, rvalue);
4835                         return 0;
4836                 }
4837
4838                 TAKE_PTR(sc);
4839         }
4840
4841         return 0;
4842 }
4843
4844 int hashmap_put_credential(Hashmap **h, const char *id, const char *path, bool encrypted) {
4845         ExecLoadCredential *old;
4846         int r;
4847
4848         assert(h);
4849         assert(id);
4850         assert(path);
4851
4852         old = hashmap_get(*h, id);
4853         if (old) {
4854                 r = free_and_strdup(&old->path, path);
4855                 if (r < 0)
4856                         return r;
4857
4858                 old->encrypted = encrypted;
4859         } else {
4860                 _cleanup_(exec_load_credential_freep) ExecLoadCredential *lc = NULL;
4861
4862                 lc = new(ExecLoadCredential, 1);
4863                 if (!lc)
4864                         return log_oom();
4865
4866                 *lc = (ExecLoadCredential) {
4867                         .id = strdup(id),
4868                         .path = strdup(path),
4869                         .encrypted = encrypted,
4870                 };
4871                 if (!lc->id || !lc->path)
4872                         return -ENOMEM;
4873
4874                 r = hashmap_ensure_put(h, &exec_load_credential_hash_ops, lc->id, lc);
4875                 if (r < 0)
4876                         return r;
4877
4878                 TAKE_PTR(lc);
4879         }
4880
4881         return 0;
4882 }
4883
4884 int config_parse_load_credential(
4885                 const char *unit,
4886                 const char *filename,
4887                 unsigned line,
4888                 const char *section,
4889                 unsigned section_line,
4890                 const char *lvalue,
4891                 int ltype,
4892                 const char *rvalue,
4893                 void *data,
4894                 void *userdata) {
4895
4896         _cleanup_free_ char *word = NULL, *k = NULL, *q = NULL;
4897         ExecContext *context = ASSERT_PTR(data);
4898         bool encrypted = ltype;
4899         Unit *u = userdata;
4900         const char *p;
4901         int r;
4902
4903         assert(filename);
4904         assert(lvalue);
4905         assert(rvalue);
4906
4907         if (isempty(rvalue)) {
4908                 /* Empty assignment resets the list */
4909                 context->load_credentials = hashmap_free(context->load_credentials);
4910                 return 0;
4911         }
4912
4913         p = rvalue;
4914         r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
4915         if (r == -ENOMEM)
4916                 return log_oom();
4917         if (r <= 0) {
4918                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
4919                 return 0;
4920         }
4921
4922         r = unit_cred_printf(u, word, &k);
4923         if (r < 0) {
4924                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", word);
4925                 return 0;
4926         }
4927         if (!credential_name_valid(k)) {
4928                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name \"%s\" not valid, ignoring.", k);
4929                 return 0;
4930         }
4931
4932         if (isempty(p)) {
4933                 /* If only one field is specified take it as shortcut for inheriting a credential named
4934                  * the same way from our parent */
4935                 q = strdup(k);
4936                 if (!q)
4937                         return log_oom();
4938         } else {
4939                 r = unit_path_printf(u, p, &q);
4940                 if (r < 0) {
4941                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", p);
4942                         return 0;
4943                 }
4944                 if (path_is_absolute(q) ? !path_is_normalized(q) : !credential_name_valid(q)) {
4945                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential source \"%s\" not valid, ignoring.", q);
4946                         return 0;
4947                 }
4948         }
4949
4950         r = hashmap_put_credential(&context->load_credentials, k, q, encrypted);
4951         if (r < 0)
4952                 return log_error_errno(r, "Failed to store load credential '%s': %m", rvalue);
4953
4954         return 0;
4955 }
4956
4957 int config_parse_import_credential(
4958                 const char *unit,
4959                 const char *filename,
4960                 unsigned line,
4961                 const char *section,
4962                 unsigned section_line,
4963                 const char *lvalue,
4964                 int ltype,
4965                 const char *rvalue,
4966                 void *data,
4967                 void *userdata) {
4968
4969         _cleanup_free_ char *s = NULL;
4970         Set** import_credentials = ASSERT_PTR(data);
4971         Unit *u = userdata;
4972         int r;
4973
4974         assert(filename);
4975         assert(lvalue);
4976         assert(rvalue);
4977
4978         if (isempty(rvalue)) {
4979                 /* Empty assignment resets the list */
4980                 *import_credentials = set_free_free(*import_credentials);
4981                 return 0;
4982         }
4983
4984         r = unit_cred_printf(u, rvalue, &s);
4985         if (r < 0) {
4986                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", s);
4987                 return 0;
4988         }
4989         if (!credential_glob_valid(s)) {
4990                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name or glob \"%s\" not valid, ignoring.", s);
4991                 return 0;
4992         }
4993
4994         r = set_put_strdup(import_credentials, s);
4995         if (r < 0)
4996                 return log_error_errno(r, "Failed to store credential name '%s': %m", rvalue);
4997
4998         return 0;
4999 }
5000
5001 int config_parse_set_status(
5002                 const char *unit,
5003                 const char *filename,
5004                 unsigned line,
5005                 const char *section,
5006                 unsigned section_line,
5007                 const char *lvalue,
5008                 int ltype,
5009                 const char *rvalue,
5010                 void *data,
5011                 void *userdata) {
5012
5013         ExitStatusSet *status_set = ASSERT_PTR(data);
5014         int r;
5015
5016         assert(filename);
5017         assert(lvalue);
5018         assert(rvalue);
5019
5020         /* Empty assignment resets the list */
5021         if (isempty(rvalue)) {
5022                 exit_status_set_free(status_set);
5023                 return 0;
5024         }
5025
5026         for (const char *p = rvalue;;) {
5027                 _cleanup_free_ char *word = NULL;
5028                 Bitmap *bitmap;
5029
5030                 r = extract_first_word(&p, &word, NULL, 0);
5031                 if (r == -ENOMEM)
5032                         return log_oom();
5033                 if (r < 0) {
5034                         log_syntax(unit, LOG_WARNING, filename, line, r,
5035                                    "Failed to parse %s=%s, ignoring: %m", lvalue, rvalue);
5036                         return 0;
5037                 }
5038                 if (r == 0)
5039                         return 0;
5040
5041                 /* We need to call exit_status_from_string() first, because we want
5042                  * to parse numbers as exit statuses, not signals. */
5043
5044                 r = exit_status_from_string(word);
5045                 if (r >= 0) {
5046                         assert(r >= 0 && r < 256);
5047                         bitmap = &status_set->status;
5048                 } else {
5049                         r = signal_from_string(word);
5050                         if (r < 0) {
5051                                 log_syntax(unit, LOG_WARNING, filename, line, r,
5052                                            "Failed to parse value, ignoring: %s", word);
5053                                 continue;
5054                         }
5055                         bitmap = &status_set->signal;
5056                 }
5057
5058                 r = bitmap_set(bitmap, r);
5059                 if (r < 0)
5060                         log_syntax(unit, LOG_WARNING, filename, line, r,
5061                                    "Failed to set signal or status %s, ignoring: %m", word);
5062         }
5063 }
5064
5065 int config_parse_namespace_path_strv(
5066                 const char *unit,
5067                 const char *filename,
5068                 unsigned line,
5069                 const char *section,
5070                 unsigned section_line,
5071                 const char *lvalue,
5072                 int ltype,
5073                 const char *rvalue,
5074                 void *data,
5075                 void *userdata) {
5076
5077         const Unit *u = userdata;
5078         char*** sv = ASSERT_PTR(data);
5079         int r;
5080
5081         assert(filename);
5082         assert(lvalue);
5083         assert(rvalue);
5084
5085         if (isempty(rvalue)) {
5086                 /* Empty assignment resets the list */
5087                 *sv = strv_free(*sv);
5088                 return 0;
5089         }
5090
5091         for (const char *p = rvalue;;) {
5092                 _cleanup_free_ char *word = NULL, *resolved = NULL, *joined = NULL;
5093                 const char *w;
5094                 bool ignore_enoent = false, shall_prefix = false;
5095
5096                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
5097                 if (r == -ENOMEM)
5098                         return log_oom();
5099                 if (r < 0) {
5100                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract first word, ignoring: %s", rvalue);
5101                         return 0;
5102                 }
5103                 if (r == 0)
5104                         break;
5105
5106                 w = word;
5107                 if (startswith(w, "-")) {
5108                         ignore_enoent = true;
5109                         w++;
5110                 }
5111                 if (startswith(w, "+")) {
5112                         shall_prefix = true;
5113                         w++;
5114                 }
5115
5116                 r = unit_path_printf(u, w, &resolved);
5117                 if (r < 0) {
5118                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s: %m", w);
5119                         continue;
5120                 }
5121
5122                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5123                 if (r < 0)
5124                         continue;
5125
5126                 joined = strjoin(ignore_enoent ? "-" : "",
5127                                  shall_prefix ? "+" : "",
5128                                  resolved);
5129
5130                 r = strv_push(sv, joined);
5131                 if (r < 0)
5132                         return log_oom();
5133
5134                 joined = NULL;
5135         }
5136
5137         return 0;
5138 }
5139
5140 int config_parse_temporary_filesystems(
5141                 const char *unit,
5142                 const char *filename,
5143                 unsigned line,
5144                 const char *section,
5145                 unsigned section_line,
5146                 const char *lvalue,
5147                 int ltype,
5148                 const char *rvalue,
5149                 void *data,
5150                 void *userdata) {
5151
5152         const Unit *u = userdata;
5153         ExecContext *c = ASSERT_PTR(data);
5154         int r;
5155
5156         assert(filename);
5157         assert(lvalue);
5158         assert(rvalue);
5159
5160         if (isempty(rvalue)) {
5161                 /* Empty assignment resets the list */
5162                 temporary_filesystem_free_many(c->temporary_filesystems, c->n_temporary_filesystems);
5163                 c->temporary_filesystems = NULL;
5164                 c->n_temporary_filesystems = 0;
5165                 return 0;
5166         }
5167
5168         for (const char *p = rvalue;;) {
5169                 _cleanup_free_ char *word = NULL, *path = NULL, *resolved = NULL;
5170                 const char *w;
5171
5172                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
5173                 if (r == -ENOMEM)
5174                         return log_oom();
5175                 if (r < 0) {
5176                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract first word, ignoring: %s", rvalue);
5177                         return 0;
5178                 }
5179                 if (r == 0)
5180                         return 0;
5181
5182                 w = word;
5183                 r = extract_first_word(&w, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
5184                 if (r == -ENOMEM)
5185                         return log_oom();
5186                 if (r < 0) {
5187                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract first word, ignoring: %s", word);
5188                         continue;
5189                 }
5190                 if (r == 0) {
5191                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid syntax, ignoring: %s", word);
5192                         continue;
5193                 }
5194
5195                 r = unit_path_printf(u, path, &resolved);
5196                 if (r < 0) {
5197                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", path);
5198                         continue;
5199                 }
5200
5201                 r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5202                 if (r < 0)
5203                         continue;
5204
5205                 r = temporary_filesystem_add(&c->temporary_filesystems, &c->n_temporary_filesystems, resolved, w);
5206                 if (r < 0)
5207                         return log_oom();
5208         }
5209 }
5210
5211 int config_parse_bind_paths(
5212                 const char *unit,
5213                 const char *filename,
5214                 unsigned line,
5215                 const char *section,
5216                 unsigned section_line,
5217                 const char *lvalue,
5218                 int ltype,
5219                 const char *rvalue,
5220                 void *data,
5221                 void *userdata) {
5222
5223         ExecContext *c = ASSERT_PTR(data);
5224         const Unit *u = userdata;
5225         int r;
5226
5227         assert(filename);
5228         assert(lvalue);
5229         assert(rvalue);
5230
5231         if (isempty(rvalue)) {
5232                 /* Empty assignment resets the list */
5233                 bind_mount_free_many(c->bind_mounts, c->n_bind_mounts);
5234                 c->bind_mounts = NULL;
5235                 c->n_bind_mounts = 0;
5236                 return 0;
5237         }
5238
5239         for (const char *p = rvalue;;) {
5240                 _cleanup_free_ char *source = NULL, *destination = NULL;
5241                 _cleanup_free_ char *sresolved = NULL, *dresolved = NULL;
5242                 char *s = NULL, *d = NULL;
5243                 bool rbind = true, ignore_enoent = false;
5244
5245                 r = extract_first_word(&p, &source, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
5246                 if (r == -ENOMEM)
5247                         return log_oom();
5248                 if (r < 0) {
5249                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s, ignoring: %s", lvalue, rvalue);
5250                         return 0;
5251                 }
5252                 if (r == 0)
5253                         break;
5254
5255                 r = unit_full_printf_full(u, source, PATH_MAX, &sresolved);
5256                 if (r < 0) {
5257                         log_syntax(unit, LOG_WARNING, filename, line, r,
5258                                    "Failed to resolve unit specifiers in \"%s\", ignoring: %m", source);
5259                         continue;
5260                 }
5261
5262                 s = sresolved;
5263                 if (s[0] == '-') {
5264                         ignore_enoent = true;
5265                         s++;
5266                 }
5267
5268                 r = path_simplify_and_warn(s, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5269                 if (r < 0)
5270                         continue;
5271
5272                 /* Optionally, the destination is specified. */
5273                 if (p && p[-1] == ':') {
5274                         r = extract_first_word(&p, &destination, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
5275                         if (r == -ENOMEM)
5276                                 return log_oom();
5277                         if (r < 0) {
5278                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s, ignoring: %s", lvalue, rvalue);
5279                                 return 0;
5280                         }
5281                         if (r == 0) {
5282                                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Missing argument after ':', ignoring: %s", s);
5283                                 continue;
5284                         }
5285
5286                         r = unit_path_printf(u, destination, &dresolved);
5287                         if (r < 0) {
5288                                 log_syntax(unit, LOG_WARNING, filename, line, r,
5289                                            "Failed to resolve specifiers in \"%s\", ignoring: %m", destination);
5290                                 continue;
5291                         }
5292
5293                         r = path_simplify_and_warn(dresolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5294                         if (r < 0)
5295                                 continue;
5296
5297                         d = dresolved;
5298
5299                         /* Optionally, there's also a short option string specified */
5300                         if (p && p[-1] == ':') {
5301                                 _cleanup_free_ char *options = NULL;
5302
5303                                 r = extract_first_word(&p, &options, NULL, EXTRACT_UNQUOTE);
5304                                 if (r == -ENOMEM)
5305                                         return log_oom();
5306                                 if (r < 0) {
5307                                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s=, ignoring: %s", lvalue, rvalue);
5308                                         return 0;
5309                                 }
5310
5311                                 if (isempty(options) || streq(options, "rbind"))
5312                                         rbind = true;
5313                                 else if (streq(options, "norbind"))
5314                                         rbind = false;
5315                                 else {
5316                                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid option string, ignoring setting: %s", options);
5317                                         continue;
5318                                 }
5319                         }
5320                 } else
5321                         d = s;
5322
5323                 r = bind_mount_add(&c->bind_mounts, &c->n_bind_mounts,
5324                                    &(BindMount) {
5325                                            .source = s,
5326                                            .destination = d,
5327                                            .read_only = !!strstr(lvalue, "ReadOnly"),
5328                                            .recursive = rbind,
5329                                            .ignore_enoent = ignore_enoent,
5330                                    });
5331                 if (r < 0)
5332                         return log_oom();
5333         }
5334
5335         return 0;
5336 }
5337
5338 int config_parse_mount_images(
5339                 const char *unit,
5340                 const char *filename,
5341                 unsigned line,
5342                 const char *section,
5343                 unsigned section_line,
5344                 const char *lvalue,
5345                 int ltype,
5346                 const char *rvalue,
5347                 void *data,
5348                 void *userdata) {
5349
5350         ExecContext *c = ASSERT_PTR(data);
5351         const Unit *u = userdata;
5352         int r;
5353
5354         assert(filename);
5355         assert(lvalue);
5356         assert(rvalue);
5357
5358         if (isempty(rvalue)) {
5359                 /* Empty assignment resets the list */
5360                 c->mount_images = mount_image_free_many(c->mount_images, &c->n_mount_images);
5361                 return 0;
5362         }
5363
5364         for (const char *p = rvalue;;) {
5365                 _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
5366                 _cleanup_free_ char *first = NULL, *second = NULL, *tuple = NULL;
5367                 _cleanup_free_ char *sresolved = NULL, *dresolved = NULL;
5368                 const char *q = NULL;
5369                 char *s = NULL;
5370                 bool permissive = false;
5371
5372                 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
5373                 if (r == -ENOMEM)
5374                         return log_oom();
5375                 if (r < 0) {
5376                         log_syntax(unit, LOG_WARNING, filename, line, r,
5377                                    "Invalid syntax %s=%s, ignoring: %m", lvalue, rvalue);
5378                         return 0;
5379                 }
5380                 if (r == 0)
5381                         return 0;
5382
5383                 q = tuple;
5384                 r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &first, &second, NULL);
5385                 if (r == -ENOMEM)
5386                         return log_oom();
5387                 if (r < 0) {
5388                         log_syntax(unit, LOG_WARNING, filename, line, r,
5389                                    "Invalid syntax in %s=, ignoring: %s", lvalue, tuple);
5390                         return 0;
5391                 }
5392                 if (r == 0)
5393                         continue;
5394
5395                 s = first;
5396                 if (s[0] == '-') {
5397                         permissive = true;
5398                         s++;
5399                 }
5400
5401                 r = unit_path_printf(u, s, &sresolved);
5402                 if (r < 0) {
5403                         log_syntax(unit, LOG_WARNING, filename, line, r,
5404                                    "Failed to resolve unit specifiers in \"%s\", ignoring: %m", s);
5405                         continue;
5406                 }
5407
5408                 r = path_simplify_and_warn(sresolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5409                 if (r < 0)
5410                         continue;
5411
5412                 if (isempty(second)) {
5413                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Missing destination in %s, ignoring: %s", lvalue, rvalue);
5414                         continue;
5415                 }
5416
5417                 r = unit_path_printf(u, second, &dresolved);
5418                 if (r < 0) {
5419                         log_syntax(unit, LOG_WARNING, filename, line, r,
5420                                         "Failed to resolve specifiers in \"%s\", ignoring: %m", second);
5421                         continue;
5422                 }
5423
5424                 r = path_simplify_and_warn(dresolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5425                 if (r < 0)
5426                         continue;
5427
5428                 for (;;) {
5429                         _cleanup_free_ char *partition = NULL, *mount_options = NULL, *mount_options_resolved = NULL;
5430                         MountOptions *o = NULL;
5431                         PartitionDesignator partition_designator;
5432
5433                         r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options, NULL);
5434                         if (r == -ENOMEM)
5435                                 return log_oom();
5436                         if (r < 0) {
5437                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", q);
5438                                 return 0;
5439                         }
5440                         if (r == 0)
5441                                 break;
5442                         /* Single set of options, applying to the root partition/single filesystem */
5443                         if (r == 1) {
5444                                 r = unit_full_printf(u, partition, &mount_options_resolved);
5445                                 if (r < 0) {
5446                                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", first);
5447                                         continue;
5448                                 }
5449
5450                                 o = new(MountOptions, 1);
5451                                 if (!o)
5452                                         return log_oom();
5453                                 *o = (MountOptions) {
5454                                         .partition_designator = PARTITION_ROOT,
5455                                         .options = TAKE_PTR(mount_options_resolved),
5456                                 };
5457                                 LIST_APPEND(mount_options, options, o);
5458
5459                                 break;
5460                         }
5461
5462                         partition_designator = partition_designator_from_string(partition);
5463                         if (partition_designator < 0) {
5464                                 log_syntax(unit, LOG_WARNING, filename, line, partition_designator,
5465                                            "Invalid partition name %s, ignoring", partition);
5466                                 continue;
5467                         }
5468                         r = unit_full_printf(u, mount_options, &mount_options_resolved);
5469                         if (r < 0) {
5470                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", mount_options);
5471                                 continue;
5472                         }
5473
5474                         o = new(MountOptions, 1);
5475                         if (!o)
5476                                 return log_oom();
5477                         *o = (MountOptions) {
5478                                 .partition_designator = partition_designator,
5479                                 .options = TAKE_PTR(mount_options_resolved),
5480                         };
5481                         LIST_APPEND(mount_options, options, o);
5482                 }
5483
5484                 r = mount_image_add(&c->mount_images, &c->n_mount_images,
5485                                     &(MountImage) {
5486                                             .source = sresolved,
5487                                             .destination = dresolved,
5488                                             .mount_options = options,
5489                                             .ignore_enoent = permissive,
5490                                             .type = MOUNT_IMAGE_DISCRETE,
5491                                     });
5492                 if (r < 0)
5493                         return log_oom();
5494         }
5495 }
5496
5497 int config_parse_extension_images(
5498                 const char *unit,
5499                 const char *filename,
5500                 unsigned line,
5501                 const char *section,
5502                 unsigned section_line,
5503                 const char *lvalue,
5504                 int ltype,
5505                 const char *rvalue,
5506                 void *data,
5507                 void *userdata) {
5508
5509         ExecContext *c = ASSERT_PTR(data);
5510         const Unit *u = userdata;
5511         int r;
5512
5513         assert(filename);
5514         assert(lvalue);
5515         assert(rvalue);
5516
5517         if (isempty(rvalue)) {
5518                 /* Empty assignment resets the list */
5519                 c->extension_images = mount_image_free_many(c->extension_images, &c->n_extension_images);
5520                 return 0;
5521         }
5522
5523         for (const char *p = rvalue;;) {
5524                 _cleanup_free_ char *source = NULL, *tuple = NULL, *sresolved = NULL;
5525                 _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
5526                 bool permissive = false;
5527                 const char *q = NULL;
5528                 char *s = NULL;
5529
5530                 r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
5531                 if (r == -ENOMEM)
5532                         return log_oom();
5533                 if (r < 0) {
5534                         log_syntax(unit, LOG_WARNING, filename, line, r,
5535                                    "Invalid syntax %s=%s, ignoring: %m", lvalue, rvalue);
5536                         return 0;
5537                 }
5538                 if (r == 0)
5539                         return 0;
5540
5541                 q = tuple;
5542                 r = extract_first_word(&q, &source, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS);
5543                 if (r == -ENOMEM)
5544                         return log_oom();
5545                 if (r < 0) {
5546                         log_syntax(unit, LOG_WARNING, filename, line, r,
5547                                    "Invalid syntax in %s=, ignoring: %s", lvalue, tuple);
5548                         return 0;
5549                 }
5550                 if (r == 0)
5551                         continue;
5552
5553                 s = source;
5554                 if (s[0] == '-') {
5555                         permissive = true;
5556                         s++;
5557                 }
5558
5559                 r = unit_path_printf(u, s, &sresolved);
5560                 if (r < 0) {
5561                         log_syntax(unit, LOG_WARNING, filename, line, r,
5562                                    "Failed to resolve unit specifiers in \"%s\", ignoring: %m", s);
5563                         continue;
5564                 }
5565
5566                 r = path_simplify_and_warn(sresolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5567                 if (r < 0)
5568                         continue;
5569
5570                 for (;;) {
5571                         _cleanup_free_ char *partition = NULL, *mount_options = NULL, *mount_options_resolved = NULL;
5572                         MountOptions *o = NULL;
5573                         PartitionDesignator partition_designator;
5574
5575                         r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS, &partition, &mount_options, NULL);
5576                         if (r == -ENOMEM)
5577                                 return log_oom();
5578                         if (r < 0) {
5579                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", q);
5580                                 return 0;
5581                         }
5582                         if (r == 0)
5583                                 break;
5584                         /* Single set of options, applying to the root partition/single filesystem */
5585                         if (r == 1) {
5586                                 r = unit_full_printf(u, partition, &mount_options_resolved);
5587                                 if (r < 0) {
5588                                         log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", partition);
5589                                         continue;
5590                                 }
5591
5592                                 o = new(MountOptions, 1);
5593                                 if (!o)
5594                                         return log_oom();
5595                                 *o = (MountOptions) {
5596                                         .partition_designator = PARTITION_ROOT,
5597                                         .options = TAKE_PTR(mount_options_resolved),
5598                                 };
5599                                 LIST_APPEND(mount_options, options, o);
5600
5601                                 break;
5602                         }
5603
5604                         partition_designator = partition_designator_from_string(partition);
5605                         if (partition_designator < 0) {
5606                                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid partition name %s, ignoring", partition);
5607                                 continue;
5608                         }
5609                         r = unit_full_printf(u, mount_options, &mount_options_resolved);
5610                         if (r < 0) {
5611                                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in %s, ignoring: %m", mount_options);
5612                                 continue;
5613                         }
5614
5615                         o = new(MountOptions, 1);
5616                         if (!o)
5617                                 return log_oom();
5618                         *o = (MountOptions) {
5619                                 .partition_designator = partition_designator,
5620                                 .options = TAKE_PTR(mount_options_resolved),
5621                         };
5622                         LIST_APPEND(mount_options, options, o);
5623                 }
5624
5625                 r = mount_image_add(&c->extension_images, &c->n_extension_images,
5626                                     &(MountImage) {
5627                                             .source = sresolved,
5628                                             .mount_options = options,
5629                                             .ignore_enoent = permissive,
5630                                             .type = MOUNT_IMAGE_EXTENSION,
5631                                     });
5632                 if (r < 0)
5633                         return log_oom();
5634         }
5635 }
5636
5637 int config_parse_job_timeout_sec(
5638                 const char* unit,
5639                 const char *filename,
5640                 unsigned line,
5641                 const char *section,
5642                 unsigned section_line,
5643                 const char *lvalue,
5644                 int ltype,
5645                 const char *rvalue,
5646                 void *data,
5647                 void *userdata) {
5648
5649         Unit *u = ASSERT_PTR(data);
5650         usec_t usec;
5651         int r;
5652
5653         assert(filename);
5654         assert(lvalue);
5655         assert(rvalue);
5656
5657         r = parse_sec_fix_0(rvalue, &usec);
5658         if (r < 0) {
5659                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse JobTimeoutSec= parameter, ignoring: %s", rvalue);
5660                 return 0;
5661         }
5662
5663         /* If the user explicitly changed JobTimeoutSec= also change JobRunningTimeoutSec=, for compatibility with old
5664          * versions. If JobRunningTimeoutSec= was explicitly set, avoid this however as whatever the user picked should
5665          * count. */
5666
5667         if (!u->job_running_timeout_set)
5668                 u->job_running_timeout = usec;
5669
5670         u->job_timeout = usec;
5671
5672         return 0;
5673 }
5674
5675 int config_parse_job_running_timeout_sec(
5676                 const char* unit,
5677                 const char *filename,
5678                 unsigned line,
5679                 const char *section,
5680                 unsigned section_line,
5681                 const char *lvalue,
5682                 int ltype,
5683                 const char *rvalue,
5684                 void *data,
5685                 void *userdata) {
5686
5687         Unit *u = ASSERT_PTR(data);
5688         usec_t usec;
5689         int r;
5690
5691         assert(filename);
5692         assert(lvalue);
5693         assert(rvalue);
5694
5695         r = parse_sec_fix_0(rvalue, &usec);
5696         if (r < 0) {
5697                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse JobRunningTimeoutSec= parameter, ignoring: %s", rvalue);
5698                 return 0;
5699         }
5700
5701         u->job_running_timeout = usec;
5702         u->job_running_timeout_set = true;
5703
5704         return 0;
5705 }
5706
5707 int config_parse_emergency_action(
5708                 const char* unit,
5709                 const char *filename,
5710                 unsigned line,
5711                 const char *section,
5712                 unsigned section_line,
5713                 const char *lvalue,
5714                 int ltype,
5715                 const char *rvalue,
5716                 void *data,
5717                 void *userdata) {
5718
5719         EmergencyAction *x = ASSERT_PTR(data);
5720         RuntimeScope runtime_scope;
5721         int r;
5722
5723         assert(filename);
5724         assert(lvalue);
5725         assert(rvalue);
5726
5727         /* If we have a unit determine the scope based on it */
5728         if (unit)
5729                 runtime_scope = ((Unit*) ASSERT_PTR(userdata))->manager->runtime_scope;
5730         else
5731                 runtime_scope = ltype; /* otherwise, assume the scope is passed in via ltype */
5732
5733         r = parse_emergency_action(rvalue, runtime_scope, x);
5734         if (r < 0) {
5735                 if (r == -EOPNOTSUPP)
5736                         log_syntax(unit, LOG_WARNING, filename, line, r,
5737                                    "%s= specified as %s mode action, ignoring: %s",
5738                                    lvalue, runtime_scope_to_string(runtime_scope), rvalue);
5739                 else
5740                         log_syntax(unit, LOG_WARNING, filename, line, r,
5741                                    "Failed to parse %s=, ignoring: %s", lvalue, rvalue);
5742                 return 0;
5743         }
5744
5745         return 0;
5746 }
5747
5748 int config_parse_pid_file(
5749                 const char *unit,
5750                 const char *filename,
5751                 unsigned line,
5752                 const char *section,
5753                 unsigned section_line,
5754                 const char *lvalue,
5755                 int ltype,
5756                 const char *rvalue,
5757                 void *data,
5758                 void *userdata) {
5759
5760         _cleanup_free_ char *k = NULL, *n = NULL;
5761         const Unit *u = ASSERT_PTR(userdata);
5762         char **s = data;
5763         int r;
5764
5765         assert(filename);
5766         assert(lvalue);
5767         assert(rvalue);
5768
5769         if (isempty(rvalue)) {
5770                 /* An empty assignment removes already set value. */
5771                 *s = mfree(*s);
5772                 return 0;
5773         }
5774
5775         r = unit_path_printf(u, rvalue, &k);
5776         if (r < 0) {
5777                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
5778                 return 0;
5779         }
5780
5781         /* If this is a relative path make it absolute by prefixing the /run */
5782         n = path_make_absolute(k, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
5783         if (!n)
5784                 return log_oom();
5785
5786         /* Check that the result is a sensible path */
5787         r = path_simplify_and_warn(n, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5788         if (r < 0)
5789                 return r;
5790
5791         r = patch_var_run(unit, filename, line, lvalue, &n);
5792         if (r < 0)
5793                 return r;
5794
5795         free_and_replace(*s, n);
5796         return 0;
5797 }
5798
5799 int config_parse_exit_status(
5800                 const char *unit,
5801                 const char *filename,
5802                 unsigned line,
5803                 const char *section,
5804                 unsigned section_line,
5805                 const char *lvalue,
5806                 int ltype,
5807                 const char *rvalue,
5808                 void *data,
5809                 void *userdata) {
5810
5811         int *exit_status = data, r;
5812         uint8_t u;
5813
5814         assert(filename);
5815         assert(lvalue);
5816         assert(rvalue);
5817         assert(exit_status);
5818
5819         if (isempty(rvalue)) {
5820                 *exit_status = -1;
5821                 return 0;
5822         }
5823
5824         r = safe_atou8(rvalue, &u);
5825         if (r < 0) {
5826                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse exit status '%s', ignoring: %m", rvalue);
5827                 return 0;
5828         }
5829
5830         *exit_status = u;
5831         return 0;
5832 }
5833
5834 int config_parse_disable_controllers(
5835                 const char *unit,
5836                 const char *filename,
5837                 unsigned line,
5838                 const char *section,
5839                 unsigned section_line,
5840                 const char *lvalue,
5841                 int ltype,
5842                 const char *rvalue,
5843                 void *data,
5844                 void *userdata) {
5845
5846         int r;
5847         CGroupContext *c = data;
5848         CGroupMask disabled_mask;
5849
5850         /* 1. If empty, make all controllers eligible for use again.
5851          * 2. If non-empty, merge all listed controllers, space separated. */
5852
5853         if (isempty(rvalue)) {
5854                 c->disable_controllers = 0;
5855                 return 0;
5856         }
5857
5858         r = cg_mask_from_string(rvalue, &disabled_mask);
5859         if (r < 0 || disabled_mask <= 0) {
5860                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid cgroup string: %s, ignoring", rvalue);
5861                 return 0;
5862         }
5863
5864         c->disable_controllers |= disabled_mask;
5865
5866         return 0;
5867 }
5868
5869 int config_parse_ip_filter_bpf_progs(
5870                 const char *unit,
5871                 const char *filename,
5872                 unsigned line,
5873                 const char *section,
5874                 unsigned section_line,
5875                 const char *lvalue,
5876                 int ltype,
5877                 const char *rvalue,
5878                 void *data,
5879                 void *userdata) {
5880
5881         _cleanup_free_ char *resolved = NULL;
5882         const Unit *u = userdata;
5883         char ***paths = ASSERT_PTR(data);
5884         int r;
5885
5886         assert(filename);
5887         assert(lvalue);
5888         assert(rvalue);
5889
5890         if (isempty(rvalue)) {
5891                 *paths = strv_free(*paths);
5892                 return 0;
5893         }
5894
5895         r = unit_path_printf(u, rvalue, &resolved);
5896         if (r < 0) {
5897                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);
5898                 return 0;
5899         }
5900
5901         r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5902         if (r < 0)
5903                 return 0;
5904
5905         if (strv_contains(*paths, resolved))
5906                 return 0;
5907
5908         r = strv_extend(paths, resolved);
5909         if (r < 0)
5910                 return log_oom();
5911
5912         r = bpf_firewall_supported();
5913         if (r < 0)
5914                 return r;
5915         if (r != BPF_FIREWALL_SUPPORTED_WITH_MULTI) {
5916                 static bool warned = false;
5917
5918                 log_full(warned ? LOG_DEBUG : LOG_WARNING,
5919                          "File %s:%u configures an IP firewall with BPF programs (%s=%s), but the local system does not support BPF/cgroup based firewalling with multiple filters.\n"
5920                          "Starting this unit will fail! (This warning is only shown for the first loaded unit using IP firewalling.)", filename, line, lvalue, rvalue);
5921
5922                 warned = true;
5923         }
5924
5925         return 0;
5926 }
5927
5928 int config_parse_bpf_foreign_program(
5929                 const char *unit,
5930                 const char *filename,
5931                 unsigned line,
5932                 const char *section,
5933                 unsigned section_line,
5934                 const char *lvalue,
5935                 int ltype,
5936                 const char *rvalue,
5937                 void *data,
5938                 void *userdata) {
5939         _cleanup_free_ char *resolved = NULL, *word = NULL;
5940         CGroupContext *c = data;
5941         const char *p = ASSERT_PTR(rvalue);
5942         Unit *u = userdata;
5943         int attach_type, r;
5944
5945         assert(filename);
5946         assert(lvalue);
5947
5948         if (isempty(rvalue)) {
5949                 while (c->bpf_foreign_programs)
5950                         cgroup_context_remove_bpf_foreign_program(c, c->bpf_foreign_programs);
5951
5952                 return 0;
5953         }
5954
5955         r = extract_first_word(&p, &word, ":", 0);
5956         if (r == -ENOMEM)
5957                 return log_oom();
5958         if (r < 0) {
5959                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse foreign BPF program, ignoring: %s", rvalue);
5960                 return 0;
5961         }
5962         if (r == 0 || isempty(p)) {
5963                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid syntax in %s=, ignoring: %s", lvalue, rvalue);
5964                 return 0;
5965         }
5966
5967         attach_type = bpf_cgroup_attach_type_from_string(word);
5968         if (attach_type < 0) {
5969                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown BPF attach type=%s, ignoring: %s", word, rvalue);
5970                 return 0;
5971         }
5972
5973         r = unit_path_printf(u, p, &resolved);
5974         if (r < 0) {
5975                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %s", p, rvalue);
5976                 return 0;
5977         }
5978
5979         r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
5980         if (r < 0)
5981                 return 0;
5982
5983         r = cgroup_context_add_bpf_foreign_program(c, attach_type, resolved);
5984         if (r < 0)
5985                 return log_error_errno(r, "Failed to add foreign BPF program to cgroup context: %m");
5986
5987         return 0;
5988 }
5989
5990 int config_parse_cgroup_socket_bind(
5991                 const char *unit,
5992                 const char *filename,
5993                 unsigned line,
5994                 const char *section,
5995                 unsigned section_line,
5996                 const char *lvalue,
5997                 int ltype,
5998                 const char *rvalue,
5999                 void *data,
6000                 void *userdata) {
6001         _cleanup_free_ CGroupSocketBindItem *item = NULL;
6002         CGroupSocketBindItem **head = data;
6003         uint16_t nr_ports, port_min;
6004         int af, ip_protocol, r;
6005
6006         if (isempty(rvalue)) {
6007                 cgroup_context_remove_socket_bind(head);
6008                 return 0;
6009         }
6010
6011         r = parse_socket_bind_item(rvalue, &af, &ip_protocol, &nr_ports, &port_min);
6012         if (r == -ENOMEM)
6013                 return log_oom();
6014         if (r < 0) {
6015                 log_syntax(unit, LOG_WARNING, filename, line, r,
6016                            "Unable to parse %s= assignment, ignoring: %s", lvalue, rvalue);
6017                 return 0;
6018         }
6019
6020         item = new(CGroupSocketBindItem, 1);
6021         if (!item)
6022                 return log_oom();
6023         *item = (CGroupSocketBindItem) {
6024                 .address_family = af,
6025                 .ip_protocol = ip_protocol,
6026                 .nr_ports = nr_ports,
6027                 .port_min = port_min,
6028         };
6029
6030         LIST_PREPEND(socket_bind_items, *head, TAKE_PTR(item));
6031
6032         return 0;
6033 }
6034
6035 int config_parse_restrict_network_interfaces(
6036                 const char *unit,
6037                 const char *filename,
6038                 unsigned line,
6039                 const char *section,
6040                 unsigned section_line,
6041                 const char *lvalue,
6042                 int ltype,
6043                 const char *rvalue,
6044                 void *data,
6045                 void *userdata) {
6046         CGroupContext *c = ASSERT_PTR(data);
6047         bool is_allow_rule = true;
6048         int r;
6049
6050         assert(filename);
6051         assert(lvalue);
6052         assert(rvalue);
6053
6054         if (isempty(rvalue)) {
6055                 /* Empty assignment resets the list */
6056                 c->restrict_network_interfaces = set_free_free(c->restrict_network_interfaces);
6057                 return 0;
6058         }
6059
6060         if (rvalue[0] == '~') {
6061                 is_allow_rule = false;
6062                 rvalue++;
6063         }
6064
6065         if (set_isempty(c->restrict_network_interfaces))
6066                 /* Only initialize this when creating the set */
6067                 c->restrict_network_interfaces_is_allow_list = is_allow_rule;
6068
6069         for (const char *p = rvalue;;) {
6070                 _cleanup_free_ char *word = NULL;
6071
6072                 r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
6073                 if (r == 0)
6074                         break;
6075                 if (r == -ENOMEM)
6076                         return log_oom();
6077                 if (r < 0) {
6078                         log_syntax(unit, LOG_WARNING, filename, line, r,
6079                                    "Trailing garbage in %s, ignoring: %s", lvalue, rvalue);
6080                         break;
6081                 }
6082
6083                 if (!ifname_valid(word)) {
6084                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid interface name, ignoring: %s", word);
6085                         continue;
6086                 }
6087
6088                 if (c->restrict_network_interfaces_is_allow_list != is_allow_rule)
6089                         free(set_remove(c->restrict_network_interfaces, word));
6090                 else {
6091                         r = set_put_strdup(&c->restrict_network_interfaces, word);
6092                         if (r < 0)
6093                                 return log_oom();
6094                 }
6095         }
6096
6097         return 0;
6098 }
6099
6100 static int merge_by_names(Unit *u, Set *names, const char *id) {
6101         char *k;
6102         int r;
6103
6104         assert(u);
6105
6106         /* Let's try to add in all names that are aliases of this unit */
6107         while ((k = set_steal_first(names))) {
6108                 _cleanup_free_ _unused_ char *free_k = k;
6109
6110                 /* First try to merge in the other name into our unit */
6111                 r = unit_merge_by_name(u, k);
6112                 if (r < 0) {
6113                         Unit *other;
6114
6115                         /* Hmm, we couldn't merge the other unit into ours? Then let's try it the other way
6116                          * round. */
6117
6118                         other = manager_get_unit(u->manager, k);
6119                         if (!other)
6120                                 return r; /* return previous failure */
6121
6122                         r = unit_merge(other, u);
6123                         if (r < 0)
6124                                 return r;
6125
6126                         return merge_by_names(other, names, NULL);
6127                 }
6128
6129                 if (streq_ptr(id, k))
6130                         unit_choose_id(u, id);
6131         }
6132
6133         return 0;
6134 }
6135
6136 int unit_load_fragment(Unit *u) {
6137         const char *fragment;
6138         _cleanup_set_free_free_ Set *names = NULL;
6139         int r;
6140
6141         assert(u);
6142         assert(u->load_state == UNIT_STUB);
6143         assert(u->id);
6144
6145         if (u->transient) {
6146                 u->access_selinux_context = mfree(u->access_selinux_context);
6147                 u->load_state = UNIT_LOADED;
6148                 return 0;
6149         }
6150
6151         /* Possibly rebuild the fragment map to catch new units */
6152         r = unit_file_build_name_map(&u->manager->lookup_paths,
6153                                      &u->manager->unit_cache_timestamp_hash,
6154                                      &u->manager->unit_id_map,
6155                                      &u->manager->unit_name_map,
6156                                      &u->manager->unit_path_cache);
6157         if (r < 0)
6158                 return log_error_errno(r, "Failed to rebuild name map: %m");
6159
6160         r = unit_file_find_fragment(u->manager->unit_id_map,
6161                                     u->manager->unit_name_map,
6162                                     u->id,
6163                                     &fragment,
6164                                     &names);
6165         if (r < 0 && r != -ENOENT)
6166                 return r;
6167
6168         if (fragment) {
6169                 /* Open the file, check if this is a mask, otherwise read. */
6170                 _cleanup_fclose_ FILE *f = NULL;
6171                 struct stat st;
6172
6173                 /* Try to open the file name. A symlink is OK, for example for linked files or masks. We
6174                  * expect that all symlinks within the lookup paths have been already resolved, but we don't
6175                  * verify this here. */
6176                 f = fopen(fragment, "re");
6177                 if (!f)
6178                         return log_unit_notice_errno(u, errno, "Failed to open %s: %m", fragment);
6179
6180                 if (fstat(fileno(f), &st) < 0)
6181                         return -errno;
6182
6183                 r = free_and_strdup(&u->fragment_path, fragment);
6184                 if (r < 0)
6185                         return r;
6186
6187                 if (null_or_empty(&st)) {
6188                         /* Unit file is masked */
6189
6190                         u->load_state = u->perpetual ? UNIT_LOADED : UNIT_MASKED; /* don't allow perpetual units to ever be masked */
6191                         u->fragment_mtime = 0;
6192                         u->access_selinux_context = mfree(u->access_selinux_context);
6193                 } else {
6194 #if HAVE_SELINUX
6195                         if (mac_selinux_use()) {
6196                                 _cleanup_freecon_ char *selcon = NULL;
6197
6198                                 /* Cache the SELinux context of the unit file here. We'll make use of when checking access permissions to loaded units */
6199                                 r = fgetfilecon_raw(fileno(f), &selcon);
6200                                 if (r < 0)
6201                                         log_unit_warning_errno(u, r, "Failed to read SELinux context of '%s', ignoring: %m", fragment);
6202
6203                                 r = free_and_strdup(&u->access_selinux_context, selcon);
6204                                 if (r < 0)
6205                                         return r;
6206                         } else
6207 #endif
6208                                 u->access_selinux_context = mfree(u->access_selinux_context);
6209
6210                         u->load_state = UNIT_LOADED;
6211                         u->fragment_mtime = timespec_load(&st.st_mtim);
6212
6213                         /* Now, parse the file contents */
6214                         r = config_parse(u->id, fragment, f,
6215                                          UNIT_VTABLE(u)->sections,
6216                                          config_item_perf_lookup, load_fragment_gperf_lookup,
6217                                          0,
6218                                          u,
6219                                          NULL);
6220                         if (r == -ENOEXEC)
6221                                 log_unit_notice_errno(u, r, "Unit configuration has fatal error, unit will not be started.");
6222                         if (r < 0)
6223                                 return r;
6224                 }
6225         }
6226
6227         /* Call merge_by_names with the name derived from the fragment path as the preferred name.
6228          *
6229          * We do the merge dance here because for some unit types, the unit might have aliases which are not
6230          * declared in the file system. In particular, this is true (and frequent) for device and swap units.
6231          */
6232         const char *id = u->id;
6233         _cleanup_free_ char *filename = NULL, *free_id = NULL;
6234
6235         if (fragment) {
6236                 r = path_extract_filename(fragment, &filename);
6237                 if (r < 0)
6238                         return log_debug_errno(r, "Failed to extract filename from fragment '%s': %m", fragment);
6239                 id = filename;
6240
6241                 if (unit_name_is_valid(id, UNIT_NAME_TEMPLATE)) {
6242                         assert(u->instance); /* If we're not trying to use a template for non-instanced unit,
6243                                               * this must be set. */
6244
6245                         r = unit_name_replace_instance(id, u->instance, &free_id);
6246                         if (r < 0)
6247                                 return log_debug_errno(r, "Failed to build id (%s + %s): %m", id, u->instance);
6248                         id = free_id;
6249                 }
6250         }
6251
6252         return merge_by_names(u, names, id);
6253 }
6254
6255 void unit_dump_config_items(FILE *f) {
6256         static const struct {
6257                 const ConfigParserCallback callback;
6258                 const char *rvalue;
6259         } table[] = {
6260                 { config_parse_warn_compat,           "NOTSUPPORTED" },
6261                 { config_parse_int,                   "INTEGER" },
6262                 { config_parse_unsigned,              "UNSIGNED" },
6263                 { config_parse_iec_size,              "SIZE" },
6264                 { config_parse_iec_uint64,            "SIZE" },
6265                 { config_parse_si_uint64,             "SIZE" },
6266                 { config_parse_bool,                  "BOOLEAN" },
6267                 { config_parse_string,                "STRING" },
6268                 { config_parse_path,                  "PATH" },
6269                 { config_parse_unit_path_printf,      "PATH" },
6270                 { config_parse_colon_separated_paths, "PATH" },
6271                 { config_parse_strv,                  "STRING [...]" },
6272                 { config_parse_exec_nice,             "NICE" },
6273                 { config_parse_exec_oom_score_adjust, "OOMSCOREADJUST" },
6274                 { config_parse_exec_io_class,         "IOCLASS" },
6275                 { config_parse_exec_io_priority,      "IOPRIORITY" },
6276                 { config_parse_exec_cpu_sched_policy, "CPUSCHEDPOLICY" },
6277                 { config_parse_exec_cpu_sched_prio,   "CPUSCHEDPRIO" },
6278                 { config_parse_exec_cpu_affinity,     "CPUAFFINITY" },
6279                 { config_parse_mode,                  "MODE" },
6280                 { config_parse_unit_env_file,         "FILE" },
6281                 { config_parse_exec_output,           "OUTPUT" },
6282                 { config_parse_exec_input,            "INPUT" },
6283                 { config_parse_log_facility,          "FACILITY" },
6284                 { config_parse_log_level,             "LEVEL" },
6285                 { config_parse_exec_secure_bits,      "SECUREBITS" },
6286                 { config_parse_capability_set,        "BOUNDINGSET" },
6287                 { config_parse_rlimit,                "LIMIT" },
6288                 { config_parse_unit_deps,             "UNIT [...]" },
6289                 { config_parse_exec,                  "PATH [ARGUMENT [...]]" },
6290                 { config_parse_service_type,          "SERVICETYPE" },
6291                 { config_parse_service_exit_type,     "SERVICEEXITTYPE" },
6292                 { config_parse_service_restart,       "SERVICERESTART" },
6293                 { config_parse_service_restart_mode,  "SERVICERESTARTMODE" },
6294                 { config_parse_service_timeout_failure_mode, "TIMEOUTMODE" },
6295                 { config_parse_kill_mode,             "KILLMODE" },
6296                 { config_parse_signal,                "SIGNAL" },
6297                 { config_parse_socket_listen,         "SOCKET [...]" },
6298                 { config_parse_socket_bind,           "SOCKETBIND" },
6299                 { config_parse_socket_bindtodevice,   "NETWORKINTERFACE" },
6300                 { config_parse_sec,                   "SECONDS" },
6301                 { config_parse_nsec,                  "NANOSECONDS" },
6302                 { config_parse_namespace_path_strv,   "PATH [...]" },
6303                 { config_parse_bind_paths,            "PATH[:PATH[:OPTIONS]] [...]" },
6304                 { config_parse_unit_requires_mounts_for,
6305                                                       "PATH [...]" },
6306                 { config_parse_exec_mount_propagation_flag,
6307                                                       "MOUNTFLAG" },
6308                 { config_parse_unit_string_printf,    "STRING" },
6309                 { config_parse_trigger_unit,          "UNIT" },
6310                 { config_parse_timer,                 "TIMER" },
6311                 { config_parse_path_spec,             "PATH" },
6312                 { config_parse_notify_access,         "ACCESS" },
6313                 { config_parse_ip_tos,                "TOS" },
6314                 { config_parse_unit_condition_path,   "CONDITION" },
6315                 { config_parse_unit_condition_string, "CONDITION" },
6316                 { config_parse_unit_slice,            "SLICE" },
6317                 { config_parse_documentation,         "URL" },
6318                 { config_parse_service_timeout,       "SECONDS" },
6319                 { config_parse_emergency_action,      "ACTION" },
6320                 { config_parse_set_status,            "STATUS" },
6321                 { config_parse_service_sockets,       "SOCKETS" },
6322                 { config_parse_environ,               "ENVIRON" },
6323 #if HAVE_SECCOMP
6324                 { config_parse_syscall_filter,        "SYSCALLS" },
6325                 { config_parse_syscall_archs,         "ARCHS" },
6326                 { config_parse_syscall_errno,         "ERRNO" },
6327                 { config_parse_syscall_log,           "SYSCALLS" },
6328                 { config_parse_address_families,      "FAMILIES" },
6329                 { config_parse_restrict_namespaces,   "NAMESPACES"  },
6330 #endif
6331                 { config_parse_restrict_filesystems,  "FILESYSTEMS"  },
6332                 { config_parse_cpu_shares,            "SHARES" },
6333                 { config_parse_cg_weight,             "WEIGHT" },
6334                 { config_parse_cg_cpu_weight,         "CPUWEIGHT" },
6335                 { config_parse_memory_limit,          "LIMIT" },
6336                 { config_parse_device_allow,          "DEVICE" },
6337                 { config_parse_device_policy,         "POLICY" },
6338                 { config_parse_io_limit,              "LIMIT" },
6339                 { config_parse_io_device_weight,      "DEVICEWEIGHT" },
6340                 { config_parse_io_device_latency,     "DEVICELATENCY" },
6341                 { config_parse_blockio_bandwidth,     "BANDWIDTH" },
6342                 { config_parse_blockio_weight,        "WEIGHT" },
6343                 { config_parse_blockio_device_weight, "DEVICEWEIGHT" },
6344                 { config_parse_long,                  "LONG" },
6345                 { config_parse_socket_service,        "SERVICE" },
6346 #if HAVE_SELINUX
6347                 { config_parse_exec_selinux_context,  "LABEL" },
6348 #endif
6349                 { config_parse_job_mode,              "MODE" },
6350                 { config_parse_job_mode_isolate,      "BOOLEAN" },
6351                 { config_parse_personality,           "PERSONALITY" },
6352                 { config_parse_log_filter_patterns,   "REGEX" },
6353         };
6354
6355         const char *prev = NULL;
6356
6357         assert(f);
6358
6359         NULSTR_FOREACH(i, load_fragment_gperf_nulstr) {
6360                 const char *rvalue = "OTHER", *lvalue;
6361                 const ConfigPerfItem *p;
6362                 const char *dot;
6363
6364                 assert_se(p = load_fragment_gperf_lookup(i, strlen(i)));
6365
6366                 /* Hide legacy settings */
6367                 if (p->parse == config_parse_warn_compat &&
6368                     p->ltype == DISABLED_LEGACY)
6369                         continue;
6370
6371                 for (size_t j = 0; j < ELEMENTSOF(table); j++)
6372                         if (p->parse == table[j].callback) {
6373                                 rvalue = table[j].rvalue;
6374                                 break;
6375                         }
6376
6377                 dot = strchr(i, '.');
6378                 lvalue = dot ? dot + 1 : i;
6379
6380                 if (dot) {
6381                         size_t prefix_len = dot - i;
6382
6383                         if (!prev || !strneq(prev, i, prefix_len+1)) {
6384                                 if (prev)
6385                                         fputc('\n', f);
6386
6387                                 fprintf(f, "[%.*s]\n", (int) prefix_len, i);
6388                         }
6389                 }
6390
6391                 fprintf(f, "%s=%s\n", lvalue, rvalue);
6392                 prev = i;
6393         }
6394 }
6395
6396 int config_parse_cpu_affinity2(
6397                 const char *unit,
6398                 const char *filename,
6399                 unsigned line,
6400                 const char *section,
6401                 unsigned section_line,
6402                 const char *lvalue,
6403                 int ltype,
6404                 const char *rvalue,
6405                 void *data,
6406                 void *userdata) {
6407
6408         CPUSet *affinity = ASSERT_PTR(data);
6409
6410         (void) parse_cpu_set_extend(rvalue, affinity, true, unit, filename, line, lvalue);
6411
6412         return 0;
6413 }
6414
6415 int config_parse_show_status(
6416                 const char* unit,
6417                 const char *filename,
6418                 unsigned line,
6419                 const char *section,
6420                 unsigned section_line,
6421                 const char *lvalue,
6422                 int ltype,
6423                 const char *rvalue,
6424                 void *data,
6425                 void *userdata) {
6426
6427         int k;
6428         ShowStatus *b = ASSERT_PTR(data);
6429
6430         assert(filename);
6431         assert(lvalue);
6432         assert(rvalue);
6433
6434         k = parse_show_status(rvalue, b);
6435         if (k < 0)
6436                 log_syntax(unit, LOG_WARNING, filename, line, k, "Failed to parse show status setting, ignoring: %s", rvalue);
6437
6438         return 0;
6439 }
6440
6441 int config_parse_output_restricted(
6442                 const char* unit,
6443                 const char *filename,
6444                 unsigned line,
6445                 const char *section,
6446                 unsigned section_line,
6447                 const char *lvalue,
6448                 int ltype,
6449                 const char *rvalue,
6450                 void *data,
6451                 void *userdata) {
6452
6453         ExecOutput t, *eo = ASSERT_PTR(data);
6454         bool obsolete = false;
6455
6456         assert(filename);
6457         assert(lvalue);
6458         assert(rvalue);
6459
6460         if (streq(rvalue, "syslog")) {
6461                 t = EXEC_OUTPUT_JOURNAL;
6462                 obsolete = true;
6463         } else if (streq(rvalue, "syslog+console")) {
6464                 t = EXEC_OUTPUT_JOURNAL_AND_CONSOLE;
6465                 obsolete = true;
6466         } else {
6467                 t = exec_output_from_string(rvalue);
6468                 if (t < 0) {
6469                         log_syntax(unit, LOG_WARNING, filename, line, t, "Failed to parse output type, ignoring: %s", rvalue);
6470                         return 0;
6471                 }
6472
6473                 if (IN_SET(t, EXEC_OUTPUT_SOCKET, EXEC_OUTPUT_NAMED_FD, EXEC_OUTPUT_FILE, EXEC_OUTPUT_FILE_APPEND, EXEC_OUTPUT_FILE_TRUNCATE)) {
6474                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Standard output types socket, fd:, file:, append:, truncate: are not supported as defaults, ignoring: %s", rvalue);
6475                         return 0;
6476                 }
6477         }
6478
6479         if (obsolete)
6480                 log_syntax(unit, LOG_NOTICE, filename, line, 0,
6481                            "Standard output type %s is obsolete, automatically updating to %s. Please update your configuration.",
6482                            rvalue, exec_output_to_string(t));
6483
6484         *eo = t;
6485         return 0;
6486 }
6487
6488 int config_parse_crash_chvt(
6489                 const char* unit,
6490                 const char *filename,
6491                 unsigned line,
6492                 const char *section,
6493                 unsigned section_line,
6494                 const char *lvalue,
6495                 int ltype,
6496                 const char *rvalue,
6497                 void *data,
6498                 void *userdata) {
6499
6500         int r;
6501
6502         assert(filename);
6503         assert(lvalue);
6504         assert(rvalue);
6505         assert(data);
6506
6507         r = parse_crash_chvt(rvalue, data);
6508         if (r < 0)
6509                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse CrashChangeVT= setting, ignoring: %s", rvalue);
6510
6511         return 0;
6512 }
6513
6514 int config_parse_swap_priority(
6515                 const char *unit,
6516                 const char *filename,
6517                 unsigned line,
6518                 const char *section,
6519                 unsigned section_line,
6520                 const char *lvalue,
6521                 int ltype,
6522                 const char *rvalue,
6523                 void *data,
6524                 void *userdata) {
6525
6526         Swap *s = ASSERT_PTR(userdata);
6527         int r, priority;
6528
6529         assert(filename);
6530         assert(lvalue);
6531         assert(rvalue);
6532         assert(data);
6533
6534         if (isempty(rvalue)) {
6535                 s->parameters_fragment.priority = -1;
6536                 s->parameters_fragment.priority_set = false;
6537                 return 0;
6538         }
6539
6540         r = safe_atoi(rvalue, &priority);
6541         if (r < 0) {
6542                 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid swap priority '%s', ignoring.", rvalue);
6543                 return 0;
6544         }
6545
6546         if (priority < -1) {
6547                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Sorry, swap priorities smaller than -1 may only be assigned by the kernel itself, ignoring: %s", rvalue);
6548                 return 0;
6549         }
6550
6551         if (priority > 32767) {
6552                 log_syntax(unit, LOG_WARNING, filename, line, 0, "Swap priority out of range, ignoring: %s", rvalue);
6553                 return 0;
6554         }
6555
6556         s->parameters_fragment.priority = priority;
6557         s->parameters_fragment.priority_set = true;
6558         return 0;
6559 }
6560
6561 int config_parse_watchdog_sec(
6562                 const char *unit,
6563                 const char *filename,
6564                 unsigned line,
6565                 const char *section,
6566                 unsigned section_line,
6567                 const char *lvalue,
6568                 int ltype,
6569                 const char *rvalue,
6570                 void *data,
6571                 void *userdata) {
6572
6573         usec_t *usec = data;
6574
6575         assert(filename);
6576         assert(lvalue);
6577         assert(rvalue);
6578
6579         /* This is called for {Runtime,Reboot,KExec}WatchdogSec= where "default" maps to
6580          * USEC_INFINITY internally. */
6581
6582         if (streq(rvalue, "default"))
6583                 *usec = USEC_INFINITY;
6584         else if (streq(rvalue, "off"))
6585                 *usec = 0;
6586         else
6587                 return config_parse_sec(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
6588
6589         return 0;
6590 }
6591
6592 int config_parse_tty_size(
6593                 const char *unit,
6594                 const char *filename,
6595                 unsigned line,
6596                 const char *section,
6597                 unsigned section_line,
6598                 const char *lvalue,
6599                 int ltype,
6600                 const char *rvalue,
6601                 void *data,
6602                 void *userdata) {
6603
6604         unsigned *sz = data;
6605
6606         assert(filename);
6607         assert(lvalue);
6608         assert(rvalue);
6609
6610         if (isempty(rvalue)) {
6611                 *sz = UINT_MAX;
6612                 return 0;
6613         }
6614
6615         return config_parse_unsigned(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
6616 }
6617
6618 int config_parse_log_filter_patterns(
6619                 const char *unit,
6620                 const char *filename,
6621                 unsigned line,
6622                 const char *section,
6623                 unsigned section_line,
6624                 const char *lvalue,
6625                 int ltype,
6626                 const char *rvalue,
6627                 void *data,
6628                 void *userdata) {
6629
6630         ExecContext *c = ASSERT_PTR(data);
6631         const char *pattern = ASSERT_PTR(rvalue);
6632         bool is_allowlist = true;
6633         int r;
6634
6635         assert(filename);
6636         assert(lvalue);
6637
6638         if (isempty(pattern)) {
6639                 /* Empty assignment resets the lists. */
6640                 c->log_filter_allowed_patterns = set_free_free(c->log_filter_allowed_patterns);
6641                 c->log_filter_denied_patterns = set_free_free(c->log_filter_denied_patterns);
6642                 return 0;
6643         }
6644
6645         if (pattern[0] == '~') {
6646                 is_allowlist = false;
6647                 pattern++;
6648                 if (isempty(pattern))
6649                         /* LogFilterPatterns=~ is not considered a valid pattern. */
6650                         return log_syntax(unit, LOG_WARNING, filename, line, 0,
6651                                           "Regex pattern invalid, ignoring: %s=%s", lvalue, rvalue);
6652         }
6653
6654         if (pattern_compile_and_log(pattern, 0, NULL) < 0)
6655                 return 0;
6656
6657         r = set_put_strdup(is_allowlist ? &c->log_filter_allowed_patterns : &c->log_filter_denied_patterns,
6658                            pattern);
6659         if (r < 0) {
6660                 log_syntax(unit, LOG_WARNING, filename, line, r,
6661                            "Failed to store log filtering pattern, ignoring: %s=%s", lvalue, rvalue);
6662                 return 0;
6663         }
6664
6665         return 0;
6666 }
6667
6668 int config_parse_open_file(
6669                 const char *unit,
6670                 const char *filename,
6671                 unsigned line,
6672                 const char *section,
6673                 unsigned section_line,
6674                 const char *lvalue,
6675                 int ltype,
6676                 const char *rvalue,
6677                 void *data,
6678                 void *userdata) {
6679
6680         _cleanup_(open_file_freep) OpenFile *of = NULL;
6681         OpenFile **head = ASSERT_PTR(data);
6682         int r;
6683
6684         assert(filename);
6685         assert(lvalue);
6686         assert(rvalue);
6687
6688         if (isempty(rvalue)) {
6689                 open_file_free_many(head);
6690                 return 0;
6691         }
6692
6693         r = open_file_parse(rvalue, &of);
6694         if (r < 0) {
6695                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse OpenFile= setting, ignoring: %s", rvalue);
6696                 return 0;
6697         }
6698
6699         LIST_APPEND(open_files, *head, TAKE_PTR(of));
6700
6701         return 0;
6702 }
6703
6704 int config_parse_cgroup_nft_set(
6705                 const char *unit,
6706                 const char *filename,
6707                 unsigned line,
6708                 const char *section,
6709                 unsigned section_line,
6710                 const char *lvalue,
6711                 int ltype,
6712                 const char *rvalue,
6713                 void *data,
6714                 void *userdata) {
6715
6716         CGroupContext *c = ASSERT_PTR(data);
6717         Unit *u = ASSERT_PTR(userdata);
6718
6719         return config_parse_nft_set(unit, filename, line, section, section_line, lvalue, ltype, rvalue, &c->nft_set_context, u);
6720 }