#include <errno.h>

#include <fcntl.h>

#include <linux/fs.h>

#include <linux/oom.h>

#if HAVE_SECCOMP

#include <seccomp.h>

#include <sched.h>

#include <sys/resource.h>

#include "sd-messages.h"

#include "af-list.h"

#include "all-units.h"

#include "alloc-util.h"

#include "bpf-firewall.h"

#include "bpf-lsm.h"

#include "bpf-program.h"

#include "bpf-socket-bind.h"

#include "bus-error.h"

#include "bus-internal.h"

#include "bus-util.h"

#include "cap-list.h"

#include "capability-util.h"

#include "cgroup-setup.h"

#include "conf-parser.h"

#include "core-varlink.h"

#include "cpu-set-util.h"

#include "creds-util.h"

#include "env-util.h"

#include "errno-list.h"

#include "escape.h"

#include "fd-util.h"

#include "fileio.h"

#include "fs-util.h"

#include "hexdecoct.h"

#include "io-util.h"

#include "ioprio-util.h"

#include "ip-protocol-list.h"

#include "journal-file.h"

#include "limits-util.h"

#include "load-fragment.h"

#include "log.h"

#include "missing_ioprio.h"

#include "mountpoint-util.h"

#include "nulstr-util.h"

#include "parse-socket-bind-item.h"

#include "parse-util.h"

#include "path-util.h"

#include "percent-util.h"

#include "process-util.h"

#if HAVE_SECCOMP

#include "seccomp-util.h"

#include "securebits-util.h"

#include "signal-util.h"

#include "socket-netlink.h"

#include "specifier.h"

#include "stat-util.h"

#include "string-util.h"

#include "strv.h"

#include "syslog-util.h"

#include "time-util.h"

#include "unit-name.h"

#include "unit-printf.h"

#include "user-util.h"

#include "utf8.h"

#include "web-util.h"

static int parse_socket_protocol(const char *s) {

int r;

r = parse_ip_protocol(s);

if (r < 0)

return r;

if (!IN_SET(r, IPPROTO_UDPLITE, IPPROTO_SCTP))

return -EPROTONOSUPPORT;

return r;

}

int parse_crash_chvt(const char *value, int *data) {

int b;

if (safe_atoi(value, data) >= 0)

return 0;

b = parse_boolean(value);

if (b < 0)

return b;

if (b > 0)

*data = 0; /* switch to where kmsg goes */

else

*data = -1; /* turn off switching */

return 0;

}

int parse_confirm_spawn(const char *value, char **console) {

char *s;

int r;

r = value ? parse_boolean(value) : 1;

if (r == 0) {

*console = NULL;

return 0;

} else if (r > 0) /* on with default tty */

s = strdup("/dev/console");

else if (is_path(value)) /* on with fully qualified path */

s = strdup(value);

else /* on with only a tty file name, not a fully qualified path */

s = path_join("/dev/", value);

if (!s)

return -ENOMEM;

*console = s;

return 0;

}

DEFINE_CONFIG_PARSE(config_parse_socket_protocol, parse_socket_protocol, "Failed to parse socket protocol");

DEFINE_CONFIG_PARSE(config_parse_exec_secure_bits, secure_bits_from_string, "Failed to parse secure bits");

DEFINE_CONFIG_PARSE_ENUM(config_parse_collect_mode, collect_mode, CollectMode, "Failed to parse garbage collection mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_device_policy, cgroup_device_policy, CGroupDevicePolicy, "Failed to parse device policy");

DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_keyring_mode, exec_keyring_mode, ExecKeyringMode, "Failed to parse keyring mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_proc, protect_proc, ProtectProc, "Failed to parse /proc/ protection mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_proc_subset, proc_subset, ProcSubset, "Failed to parse /proc/ subset mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode, "Failed to parse utmp mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_job_mode, job_mode, JobMode, "Failed to parse job mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier");

DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_home, protect_home, ProtectHome, "Failed to parse protect home value");

DEFINE_CONFIG_PARSE_ENUM(config_parse_protect_system, protect_system, ProtectSystem, "Failed to parse protect system value");

DEFINE_CONFIG_PARSE_ENUM(config_parse_runtime_preserve_mode, exec_preserve_mode, ExecPreserveMode, "Failed to parse runtime directory preserve mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type");

DEFINE_CONFIG_PARSE_ENUM(config_parse_service_exit_type, service_exit_type, ServiceExitType, "Failed to parse service exit type");

DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier");

DEFINE_CONFIG_PARSE_ENUM(config_parse_service_timeout_failure_mode, service_timeout_failure_mode, ServiceTimeoutFailureMode, "Failed to parse timeout failure mode");

DEFINE_CONFIG_PARSE_ENUM(config_parse_socket_bind, socket_address_bind_ipv6_only_or_bool, SocketAddressBindIPv6Only, "Failed to parse bind IPv6 only value");

DEFINE_CONFIG_PARSE_ENUM(config_parse_oom_policy, oom_policy, OOMPolicy, "Failed to parse OOM policy");

DEFINE_CONFIG_PARSE_ENUM(config_parse_managed_oom_preference, managed_oom_preference, ManagedOOMPreference, "Failed to parse ManagedOOMPreference=");

DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_ip_tos, ip_tos, int, -1, "Failed to parse IP TOS value");

DEFINE_CONFIG_PARSE_PTR(config_parse_blockio_weight, cg_blkio_weight_parse, uint64_t, "Invalid block IO weight");

DEFINE_CONFIG_PARSE_PTR(config_parse_cg_weight, cg_weight_parse, uint64_t, "Invalid weight");

DEFINE_CONFIG_PARSE_PTR(config_parse_cpu_shares, cg_cpu_shares_parse, uint64_t, "Invalid CPU shares");

DEFINE_CONFIG_PARSE_PTR(config_parse_exec_mount_flags, mount_propagation_flags_from_string, unsigned long, "Failed to parse mount flag");

DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_numa_policy, mpol, int, -1, "Invalid NUMA policy type");

DEFINE_CONFIG_PARSE_ENUM(config_parse_status_unit_format, status_unit_format, StatusUnitFormat, "Failed to parse status unit format");

DEFINE_CONFIG_PARSE_ENUM_FULL(config_parse_socket_timestamping, socket_timestamping_from_string_harder, SocketTimestamping, "Failed to parse timestamping precision");

bool contains_instance_specifier_superset(const char *s) {

const char *p, *q;

bool percent = false;

assert(s);

p = strchr(s, '@');

if (!p)

return false;

p++; /* Skip '@' */

q = strrchr(p, '.');

if (!q)

q = p + strlen(p);

/* If the string is just the instance specifier, it's not a superset of the instance. */

if (memcmp_nn(p, q - p, "%i", strlen("%i")) == 0)

return false;

/* %i, %n and %N all expand to the instance or a superset of it. */

for (; p < q; p++) {

if (*p == '%')

percent = !percent;

else if (percent) {

if (IN_SET(*p, 'n', 'N', 'i'))

return true;

percent = false;

}

}

return false;

}

int unit_is_likely_recursive_template_dependency(Unit *u, const char *name, const char *format) {

const char *fragment_path;

int r;

assert(u);

assert(name);

/* If a template unit has a direct dependency on itself that includes the unit instance as part of

if (!unit_name_is_valid(name, UNIT_NAME_INSTANCE))

return false;

if (!unit_name_prefix_equal(u->id, name))

return false;

if (u->type != unit_name_to_type(name))

return false;

r = unit_file_find_fragment(u->manager->unit_id_map, u->manager->unit_name_map, name, &fragment_path, NULL);

if (r < 0)

return r;

/* Fragment paths should also be equal as a custom fragment for a specific template instance

if (!path_equal_ptr(u->fragment_path, fragment_path))

return false;

if (!contains_instance_specifier_superset(format))

return false;

return true;

}

int config_parse_unit_deps(

void *userdata) {

UnitDependency d = ltype;

Unit *u = userdata;

assert(filename);

assert(lvalue);

assert(rvalue);

for (const char *p = rvalue;;) {

_cleanup_free_ char *word = NULL, *k = NULL;

int r;

r = extract_first_word(&p, &word, NULL, EXTRACT_RETAIN_ESCAPE);

if (r == 0)

return 0;

if (r == -ENOMEM)

return log_oom();

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);

return 0;

}

r = unit_name_printf(u, word, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", word);

continue;

}

r = unit_is_likely_recursive_template_dependency(u, k, word);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to determine if '%s' is a recursive dependency, ignoring: %m", k);

continue;

}

if (r > 0) {

log_syntax(unit, LOG_DEBUG, filename, line, 0,

"Dropping dependency %s=%s that likely leads to infinite recursion.",

unit_dependency_to_string(d), word);

continue;

}

r = unit_add_dependency_by_name(u, d, k, true, UNIT_DEPENDENCY_FILE);

if (r < 0)

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);

}

}

int config_parse_obsolete_unit_deps(

void *userdata) {

log_syntax(unit, LOG_WARNING, filename, line, 0,

"Unit dependency type %s= is obsolete, replacing by %s=, please update your unit file", lvalue, unit_dependency_to_string(ltype));

return config_parse_unit_deps(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);

}

int config_parse_unit_string_printf(

void *userdata) {

_cleanup_free_ char *k = NULL;

const Unit *u = userdata;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(u);

r = unit_full_printf(u, rvalue, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);

return 0;

}

return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);

}

int config_parse_unit_strv_printf(

void *userdata) {

const Unit *u = userdata;

_cleanup_free_ char *k = NULL;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(u);

r = unit_full_printf(u, rvalue, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);

return 0;

}

return config_parse_strv(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);

}

int config_parse_unit_path_printf(

void *userdata) {

_cleanup_free_ char *k = NULL;

const Unit *u = userdata;

int r;

bool fatal = ltype;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(u);

r = unit_path_printf(u, rvalue, &k);

if (r < 0) {

log_syntax(unit, fatal ? LOG_ERR : LOG_WARNING, filename, line, r,

"Failed to resolve unit specifiers in '%s'%s: %m",

rvalue, fatal ? "" : ", ignoring");

return fatal ? -ENOEXEC : 0;

}

return config_parse_path(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);

}

int config_parse_colon_separated_paths(

void *userdata) {

char ***sv = data;

const Unit *u = userdata;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

/* Empty assignment resets the list */

*sv = strv_free(*sv);

return 0;

}

for (const char *p = rvalue;;) {

_cleanup_free_ char *word = NULL, *k = NULL;

r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);

if (r == -ENOMEM)

return log_oom();

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract first word, ignoring: %s", rvalue);

return 0;

}

if (r == 0)

break;

r = unit_path_printf(u, word, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r,

"Failed to resolve unit specifiers in '%s', ignoring: %m", word);

return 0;

}

r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);

if (r < 0)

return 0;

r = strv_consume(sv, TAKE_PTR(k));

if (r < 0)

return log_oom();

}

return 0;

}

int config_parse_unit_path_strv_printf(

void *userdata) {

char ***x = data;

const Unit *u = userdata;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(u);

if (isempty(rvalue)) {

*x = strv_free(*x);

return 0;

}

for (const char *p = rvalue;;) {

_cleanup_free_ char *word = NULL, *k = NULL;

r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);

if (r == 0)

return 0;

if (r == -ENOMEM)

return log_oom();

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r,

"Invalid syntax, ignoring: %s", rvalue);

return 0;

}

r = unit_path_printf(u, word, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r,

"Failed to resolve unit specifiers in '%s', ignoring: %m", word);

return 0;

}

r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);

if (r < 0)

return 0;

r = strv_consume(x, TAKE_PTR(k));

if (r < 0)

return log_oom();

}

}

static int patch_var_run(

char **path) {

const char *e;

char *z;

e = path_startswith(*path, "/var/run/");

if (!e)

return 0;

z = path_join("/run/", e);

if (!z)

return log_oom();

log_syntax(unit, LOG_NOTICE, filename, line, 0,

"%s= references a path below legacy directory /var/run/, updating %s → %s; "

"please update the unit file accordingly.", lvalue, *path, z);

free_and_replace(*path, z);

return 1;

}

int config_parse_socket_listen(

void *userdata) {

_cleanup_free_ SocketPort *p = NULL;

SocketPort *tail;

Socket *s;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

s = SOCKET(data);

if (isempty(rvalue)) {

/* An empty assignment removes all ports */

socket_free_ports(s);

return 0;

}

p = new0(SocketPort, 1);

if (!p)

return log_oom();

if (ltype != SOCKET_SOCKET) {

_cleanup_free_ char *k = NULL;

r = unit_path_printf(UNIT(s), rvalue, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);

return 0;

}

r = path_simplify_and_warn(k, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);

if (r < 0)

return 0;

if (ltype == SOCKET_FIFO) {

r = patch_var_run(unit, filename, line, lvalue, &k);

if (r < 0)

return r;

}

free_and_replace(p->path, k);

p->type = ltype;

} else if (streq(lvalue, "ListenNetlink")) {

_cleanup_free_ char *k = NULL;

r = unit_path_printf(UNIT(s), rvalue, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);

return 0;

}

r = socket_address_parse_netlink(&p->address, k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse address value in '%s', ignoring: %m", k);

return 0;

}

p->type = SOCKET_SOCKET;

} else {

_cleanup_free_ char *k = NULL;

r = unit_path_printf(UNIT(s), rvalue, &k);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in '%s', ignoring: %m", rvalue);

return 0;

}

if (k[0] == '/') { /* Only for AF_UNIX file system sockets… */

r = patch_var_run(unit, filename, line, lvalue, &k);

if (r < 0)

return r;

}

r = socket_address_parse_and_warn(&p->address, k);

if (r < 0) {

if (r != -EAFNOSUPPORT)

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse address value in '%s', ignoring: %m", k);

return 0;

}

if (streq(lvalue, "ListenStream"))

p->address.type = SOCK_STREAM;

else if (streq(lvalue, "ListenDatagram"))

p->address.type = SOCK_DGRAM;

else {

assert(streq(lvalue, "ListenSequentialPacket"));

p->address.type = SOCK_SEQPACKET;

}

if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {

log_syntax(unit, LOG_WARNING, filename, line, 0, "Address family not supported, ignoring: %s", rvalue);

return 0;

}

p->type = SOCKET_SOCKET;

}

p->fd = -1;

p->auxiliary_fds = NULL;

p->n_auxiliary_fds = 0;

p->socket = s;

LIST_FIND_TAIL(port, s->ports, tail);

LIST_INSERT_AFTER(port, s->ports, tail, p);

p = NULL;

return 0;

}

int config_parse_exec_nice(

void *userdata) {

ExecContext *c = data;

int priority, r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

c->nice_set = false;

return 0;

}

r = parse_nice(rvalue, &priority);

if (r < 0) {

if (r == -ERANGE)

log_syntax(unit, LOG_WARNING, filename, line, r, "Nice priority out of range, ignoring: %s", rvalue);

else

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse nice priority '%s', ignoring: %m", rvalue);

return 0;

}

c->nice = priority;

c->nice_set = true;

return 0;

}

int config_parse_exec_oom_score_adjust(

void *userdata) {

ExecContext *c = data;

int oa, r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

c->oom_score_adjust_set = false;

return 0;

}

r = parse_oom_score_adjust(rvalue, &oa);

if (r < 0) {

if (r == -ERANGE)

log_syntax(unit, LOG_WARNING, filename, line, r, "OOM score adjust value out of range, ignoring: %s", rvalue);

else

log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse the OOM score adjust value '%s', ignoring: %m", rvalue);

return 0;

}

c->oom_score_adjust = oa;

c->oom_score_adjust_set = true;

return 0;

}

int config_parse_exec_coredump_filter(

void *userdata) {

ExecContext *c = data;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

c->coredump_filter = 0;

c->coredump_filter_set = false;

return 0;

}

uint64_t f;

r = coredump_filter_mask_from_string(rvalue, &f);

if (r < 0) {

log_syntax(unit, LOG_WARNING, filename, line, r,

"Failed to parse the CoredumpFilter=%s, ignoring: %m", rvalue);

return 0;

}

c->coredump_filter |= f;

c->oom_score_adjust_set = true;

return 0;

}

int config_parse_kill_mode(

void *userdata) {

KillMode *k = data, m;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

*k = KILL_CONTROL_GROUP;

return 0;

}

m = kill_mode_from_string(rvalue);

if (m < 0) {

log_syntax(unit, LOG_WARNING, filename, line, m,

"Failed to parse kill mode specification, ignoring: %s", rvalue);

return 0;

}

if (m == KILL_NONE)

log_syntax(unit, LOG_WARNING, filename, line, 0,

"Unit configured to use KillMode=none. "

"This is unsafe, as it disables systemd's process lifecycle management for the service. "

"Please update your service to use a safer KillMode=, such as 'mixed' or 'control-group'. "

"Support for KillMode=none is deprecated and will eventually be removed.");

*k = m;

return 0;

}

int config_parse_exec(

void *userdata) {

ExecCommand **e = data;

const Unit *u = userdata;

const char *p;

bool semicolon;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(e);

e += ltype;

if (isempty(rvalue)) {

/* An empty assignment resets the list */

*e = exec_command_free_list(*e);

return 0;

}

p = rvalue;

do {

_cleanup_free_ char *path = NULL, *firstword = NULL;

ExecCommandFlags flags = 0;

bool ignore = false, separate_argv0 = false;

_cleanup_free_ ExecCommand *nce = NULL;

_cleanup_strv_free_ char **n = NULL;

size_t nlen = 0;

const char *f;

semicolon = false;

r = extract_first_word_and_warn(&p, &firstword, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);

if (r <= 0)

return 0;

/* A lone ";" is a separator. Let's make sure we don't treat it as an executable name. */

if (streq(firstword, ";")) {

semicolon = true;

continue;

}

f = firstword;

for (;;) {

/* We accept an absolute path as first argument. If it's prefixed with - and the path doesn't

if (*f == '-' && !(flags & EXEC_COMMAND_IGNORE_FAILURE)) {

flags |= EXEC_COMMAND_IGNORE_FAILURE;

ignore = true;

} else if (*f == '@' && !separate_argv0)

separate_argv0 = true;

else if (*f == ':' && !(flags & EXEC_COMMAND_NO_ENV_EXPAND))

flags |= EXEC_COMMAND_NO_ENV_EXPAND;

else if (*f == '+' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC)))

flags |= EXEC_COMMAND_FULLY_PRIVILEGED;

else if (*f == '!' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC)))

flags |= EXEC_COMMAND_NO_SETUID;

else if (*f == '!' && !(flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_AMBIENT_MAGIC))) {

flags &= ~EXEC_COMMAND_NO_SETUID;

flags |= EXEC_COMMAND_AMBIENT_MAGIC;

} else

break;

f++;

}

r = unit_path_printf(u, f, &path);

if (r < 0) {

log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, r,

"Failed to resolve unit specifiers in '%s'%s: %m",

f, ignore ? ", ignoring" : "");

return ignore ? 0 : -ENOEXEC;

}

if (isempty(path)) {

/* First word is either "-" or "@" with no command. */

log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,

"Empty path in command line%s: '%s'",

ignore ? ", ignoring" : "", rvalue);

return ignore ? 0 : -ENOEXEC;

}

if (!string_is_safe(path)) {

log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,

"Executable name contains special characters%s: %s",

ignore ? ", ignoring" : "", path);

return ignore ? 0 : -ENOEXEC;

}

if (endswith(path, "/")) {

log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,

"Executable path specifies a directory%s: %s",

ignore ? ", ignoring" : "", path);

return ignore ? 0 : -ENOEXEC;

}

if (!(path_is_absolute(path) ? path_is_valid(path) : filename_is_valid(path))) {

log_syntax(unit, ignore ? LOG_WARNING : LOG_ERR, filename, line, 0,

"Neither a valid executable name nor an absolute path%s: %s",

ignore ? ", ignoring" : "", path);

return ignore ? 0 : -ENOEXEC;

}

if (!separate_argv0) {

char *w = NULL;

if (!GREEDY_REALLOC0(n, nlen + 2))

return log_oom();

w = strdup(path);

if (!w)

return log_oom();

n[nlen++] = w;

n[nlen] = NULL;

}

path_simplify(path);

while (!isempty(p)) {

_cleanup_free_ char *word = NULL, *resolved = NULL;

/* Check explicitly for an unquoted semicolon as

if (p[0] == ';' && (!p[1] || strchr(WHITESPACE, p[1]))) {

p++;

p += strspn(p, WHITESPACE);

semicolon = true;

break;

}

/* Check for \; explicitly, to not confuse it with \\; or "\;" or "\\;" etc.

if (p[0] == '\\' && p[1] == ';' && (!p[2] || strchr(WHITESPACE, p[2]))) {

char *w;

p += 2;

p += strspn(p, WHITESPACE);

if (!GREEDY_REALLOC0(n, nlen + 2))

return log_oom();

w = strdup(";");

if (!w)

return log_oom();

n[nlen++] = w;

n[nlen] = NULL;

continue;

}

r = extract_first_word_and_warn(&p, &word, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);

if (r == 0)

break;

if (r < 0)