HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/load-fragment.c

243,452 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: cced46d969833bd05c914c99959caab3cb02b542

Lines 4001–5000 of 6,900

 
                        cc = cgroup_controller_from_string(word);
                        if (cc < 0) {
                                log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid controller name '%s', ignoring", word);
                                continue;
                        }
 
                        mask |= CGROUP_CONTROLLER_TO_MASK(cc);
                }
 
                c->delegate = true;
                c->delegate_controllers |= mask;
 
        } else if (r > 0) {
                c->delegate = true;
                c->delegate_controllers = CGROUP_MASK_DELEGATE;
        } else {
                c->delegate = false;
                c->delegate_controllers = 0;
        }
 
        return 0;
}
 
int config_parse_delegate_subgroup(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        CGroupContext *c = ASSERT_PTR(data);
        UnitType t;
 
        t = unit_name_to_type(unit);
        assert(t >= 0);
 
        if (!unit_vtable[t]->can_delegate) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "DelegateSubgroup= setting not supported for this unit type, ignoring.");
                return 0;
        }
 
        if (isempty(rvalue)) {
                c->delegate_subgroup = mfree(c->delegate_subgroup);
                return 0;
        }
 
        if (cg_needs_escape(rvalue)) { /* Insist that specified names don't need escaping */
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid control group name, ignoring: %s", rvalue);
                return 0;
        }
 
        return free_and_strdup_warn(&c->delegate_subgroup, rvalue);
}
 
int config_parse_managed_oom_mode(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ManagedOOMMode *mode = data, m;
        UnitType t;
 
        t = unit_name_to_type(unit);
        assert(t != _UNIT_TYPE_INVALID);
 
        if (!unit_vtable[t]->can_set_managed_oom)
                return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
 
        if (isempty(rvalue)) {
                *mode = MANAGED_OOM_AUTO;
                return 0;
        }
 
        m = managed_oom_mode_from_string(rvalue);
        if (m < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, m, "Invalid syntax, ignoring: %s", rvalue);
                return 0;
        }
 
        *mode = m;
        return 0;
}
 
int config_parse_managed_oom_mem_pressure_limit(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        uint32_t *limit = data;
        UnitType t;
        int r;
 
        t = unit_name_to_type(unit);
        assert(t != _UNIT_TYPE_INVALID);
 
        if (!unit_vtable[t]->can_set_managed_oom)
                return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
 
        if (isempty(rvalue)) {
                *limit = 0;
                return 0;
        }
 
        r = parse_permyriad(rvalue);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse memory pressure limit value, ignoring: %s", rvalue);
                return 0;
        }
 
        /* Normalize to 2^32-1 == 100% */
        *limit = UINT32_SCALE_FROM_PERMYRIAD(r);
        return 0;
}
 
int config_parse_managed_oom_mem_pressure_duration_sec(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        usec_t usec, *duration = ASSERT_PTR(data);
        UnitType t;
        int r;
 
        t = unit_name_to_type(unit);
        assert(t != _UNIT_TYPE_INVALID);
 
        if (!unit_vtable[t]->can_set_managed_oom)
                return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
 
        if (isempty(rvalue)) {
                *duration = USEC_INFINITY;
                return 0;
        }
 
        r = parse_sec(rvalue, &usec);
        if (r < 0)
                return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
 
        if (usec < 1 * USEC_PER_SEC || usec == USEC_INFINITY)
                return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= must be at least 1s and less than infinity, ignoring: %s", lvalue, rvalue);
 
        *duration = usec;
        return 0;
}
 
int config_parse_managed_oom_rules(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        char ***sv = ASSERT_PTR(data);
        UnitType t;
        int r;
 
        assert(rvalue);
 
        t = unit_name_to_type(unit);
        assert(t != _UNIT_TYPE_INVALID);
 
        if (!unit_vtable[t]->can_set_managed_oom)
                return log_syntax(unit, LOG_WARNING, filename, line, 0, "%s= is not supported for this unit type, ignoring.", lvalue);
 
        if (isempty(rvalue)) {
                *sv = strv_free(*sv);
                return 0;
        }
 
        /* Tokenize once: validate each rule name (rulesets are loaded from .oomrule files)
         * and accumulate into a local strv. Invalid rule names are skipped individually
         * with a warning so the rest of the line still applies. */
        _cleanup_strv_free_ char **strv = NULL;
        for (const char *p = rvalue;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r == 0)
                        break;
                if (r < 0)
                        return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
 
                if (!string_is_safe(word, STRING_FILENAME)) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid rule name in %s=, ignoring: %s", lvalue, word);
                        continue;
                }
 
                r = strv_consume(&strv, TAKE_PTR(word));
                if (r < 0)
                        return log_oom();
        }
 
        r = strv_extend_strv_consume(sv, TAKE_PTR(strv), /* filter_duplicates= */ ltype);
        if (r < 0)
                return log_oom();
 
        return 0;
}
 
int config_parse_device_allow(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        _cleanup_free_ char *path = NULL, *resolved = NULL;
        CGroupDevicePermissions permissions;
        CGroupContext *c = data;
        const char *p = rvalue;
        int r;
 
        if (isempty(rvalue)) {
                while (c->device_allow)
                        cgroup_context_free_device_allow(c, c->device_allow);
 
                return 0;
        }
 
        r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
        if (r == -ENOMEM)
                return log_oom();
        if (r <= 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to extract device path and rights from '%s', ignoring.", rvalue);
                return 0;
        }
 
        r = unit_path_printf(userdata, path, &resolved);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
                return 0;
        }
 
        if (!STARTSWITH_SET(resolved, "block-", "char-")) {
 
                r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
                if (r < 0)
                        return 0;
 
                if (!valid_device_node_path(resolved)) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid device node path '%s', ignoring.", resolved);
                        return 0;
                }
        }
 
        permissions = isempty(p) ? 0 : cgroup_device_permissions_from_string(p);
        if (permissions < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, permissions, "Invalid device rights '%s', ignoring.", p);
                return 0;
        }
 
        return cgroup_context_add_device_allow(c, resolved, permissions);
}
 
int config_parse_io_device_weight(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        _cleanup_free_ char *path = NULL, *resolved = NULL;
        CGroupIODeviceWeight *w;
        CGroupContext *c = data;
        const char *p = ASSERT_PTR(rvalue);
        uint64_t u;
        int r;
 
        assert(filename);
        assert(lvalue);
 
        if (isempty(rvalue)) {
                while (c->io_device_weights)
                        cgroup_context_free_io_device_weight(c, c->io_device_weights);
 
                return 0;
        }
 
        r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to extract device path and weight from '%s', ignoring.", rvalue);
                return 0;
        }
        if (r == 0 || isempty(p)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid device path or weight specified in '%s', ignoring.", rvalue);
                return 0;
        }
 
        r = unit_path_printf(userdata, path, &resolved);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
                return 0;
        }
 
        r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
        if (r < 0)
                return 0;
 
        r = cg_weight_parse(p, &u);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "IO weight '%s' invalid, ignoring: %m", p);
                return 0;
        }
 
        assert(u != CGROUP_WEIGHT_INVALID);
 
        w = new0(CGroupIODeviceWeight, 1);
        if (!w)
                return log_oom();
 
        w->path = TAKE_PTR(resolved);
        w->weight = u;
 
        LIST_APPEND(device_weights, c->io_device_weights, w);
        return 0;
}
 
int config_parse_io_device_latency(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        _cleanup_free_ char *path = NULL, *resolved = NULL;
        CGroupIODeviceLatency *l;
        CGroupContext *c = data;
        const char *p = ASSERT_PTR(rvalue);
        usec_t usec;
        int r;
 
        assert(filename);
        assert(lvalue);
 
        if (isempty(rvalue)) {
                while (c->io_device_latencies)
                        cgroup_context_free_io_device_latency(c, c->io_device_latencies);
 
                return 0;
        }
 
        r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to extract device path and latency from '%s', ignoring.", rvalue);
                return 0;
        }
        if (r == 0 || isempty(p)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid device path or latency specified in '%s', ignoring.", rvalue);
                return 0;
        }
 
        r = unit_path_printf(userdata, path, &resolved);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
                return 0;
        }
 
        r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
        if (r < 0)
                return 0;
 
        r = parse_sec(p, &usec);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse timer value, ignoring: %s", p);
                return 0;
        }
 
        l = new0(CGroupIODeviceLatency, 1);
        if (!l)
                return log_oom();
 
        l->path = TAKE_PTR(resolved);
        l->target_usec = usec;
 
        LIST_APPEND(device_latencies, c->io_device_latencies, l);
        return 0;
}
 
int config_parse_io_limit(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        _cleanup_free_ char *path = NULL, *resolved = NULL;
        CGroupIODeviceLimit *l = NULL;
        CGroupContext *c = data;
        CGroupIOLimitType type;
        const char *p = ASSERT_PTR(rvalue);
        uint64_t num;
        int r;
 
        assert(filename);
        assert(lvalue);
 
        type = cgroup_io_limit_type_from_string(lvalue);
        assert(type >= 0);
 
        if (isempty(rvalue)) {
                LIST_FOREACH(device_limits, t, c->io_device_limits)
                        t->limits[type] = cgroup_io_limit_defaults[type];
                return 0;
        }
 
        r = extract_first_word(&p, &path, NULL, EXTRACT_UNQUOTE);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to extract device node and bandwidth from '%s', ignoring.", rvalue);
                return 0;
        }
        if (r == 0 || isempty(p)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid device node or bandwidth specified in '%s', ignoring.", rvalue);
                return 0;
        }
 
        r = unit_path_printf(userdata, path, &resolved);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to resolve unit specifiers in '%s', ignoring: %m", path);
                return 0;
        }
 
        r = path_simplify_and_warn(resolved, 0, unit, filename, line, lvalue);
        if (r < 0)
                return 0;
 
        if (streq(p, "infinity"))
                num = CGROUP_LIMIT_MAX;
        else {
                r = parse_size(p, 1000, &num);
                if (r < 0 || num <= 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid IO limit '%s', ignoring.", p);
                        return 0;
                }
        }
 
        LIST_FOREACH(device_limits, t, c->io_device_limits)
                if (path_equal(resolved, t->path)) {
                        l = t;
                        break;
                }
 
        if (!l) {
                l = new0(CGroupIODeviceLimit, 1);
                if (!l)
                        return log_oom();
 
                l->path = TAKE_PTR(resolved);
                for (CGroupIOLimitType i = 0; i < _CGROUP_IO_LIMIT_TYPE_MAX; i++)
                        l->limits[i] = cgroup_io_limit_defaults[i];
 
                LIST_APPEND(device_limits, c->io_device_limits, l);
        }
 
        l->limits[type] = num;
 
        return 0;
}
 
int config_parse_job_mode_isolate(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        JobMode *m = data;
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        r = parse_boolean(rvalue);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse boolean, ignoring: %s", rvalue);
                return 0;
        }
 
        log_notice("%s is deprecated. Please use OnFailureJobMode= instead", lvalue);
 
        *m = r ? JOB_ISOLATE : JOB_REPLACE;
        return 0;
}
 
int config_parse_exec_directories(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExecDirectory *ed = ASSERT_PTR(data);
        const Unit *u = userdata;
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                /* Empty assignment resets the list */
                exec_directory_done(ed);
                return 0;
        }
 
        for (const char *p = rvalue;;) {
                _cleanup_free_ char *tuple = NULL;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Invalid syntax %s=%s, ignoring: %m", lvalue, rvalue);
                        return 0;
                }
                if (r == 0)
                        return 0;
 
                _cleanup_free_ char *src = NULL, *dest = NULL, *flags = NULL;
                const char *q = tuple;
                r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS|EXTRACT_DONT_COALESCE_SEPARATORS, &src, &dest, &flags);
                if (r == -ENOMEM)
                        return log_oom();
                if (r <= 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Invalid syntax in %s=, ignoring: %s", lvalue, tuple);
                        return 0;
                }
 
                _cleanup_free_ char *sresolved = NULL;
                r = unit_path_printf(u, src, &sresolved);
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Failed to resolve unit specifiers in \"%s\", ignoring: %m", src);
                        continue;
                }
 
                r = path_simplify_and_warn(sresolved, PATH_CHECK_RELATIVE, unit, filename, line, lvalue);
                if (r < 0)
                        continue;
 
                if (path_startswith(sresolved, "private")) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0,
                                   "%s= path can't be 'private', ignoring assignment: %s", lvalue, tuple);
                        continue;
                }
 
                if (!isempty(dest) && streq(lvalue, "ConfigurationDirectory")) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0,
                                   "Additional parameter is not supported for ConfigurationDirectory, ignoring: %s", tuple);
                        continue;
                }
 
                /* For State and Runtime directories we support an optional destination parameter, which
                 * will be used to create a symlink to the source. */
                _cleanup_free_ char *dresolved = NULL;
                if (!isempty(dest)) {
                        r = unit_path_printf(u, dest, &dresolved);
                        if (r < 0) {
                                log_syntax(unit, LOG_WARNING, filename, line, r,
                                           "Failed to resolve unit specifiers in \"%s\", ignoring: %m", dest);
                                continue;
                        }
 
                        r = path_simplify_and_warn(dresolved, PATH_CHECK_RELATIVE, unit, filename, line, lvalue);
                        if (r < 0)
                                continue;
                }
 
                ExecDirectoryFlags exec_directory_flags = exec_directory_flags_from_string(flags);
                if (exec_directory_flags < 0 || (exec_directory_flags & ~_EXEC_DIRECTORY_FLAGS_PUBLIC) != 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0,
                                   "Invalid flags for %s=, ignoring: %s", lvalue, flags);
                        continue;
                }
 
                r = exec_directory_add(ed, sresolved, dresolved, exec_directory_flags);
                if (r < 0)
                        return log_oom();
        }
}
 
int config_parse_exec_quota(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExecQuotaLimit *quota_limit = ASSERT_PTR(data);
        uint64_t quota_absolute = UINT64_MAX;
        uint32_t quota_scale = UINT32_MAX;
        int r;
 
        if (isempty(rvalue) || streq(rvalue, "off")) {
                quota_limit->quota_enforce = false;
                quota_limit->quota_absolute = UINT64_MAX;
                quota_limit->quota_scale = UINT32_MAX;
                return 0;
        }
 
        r = parse_permyriad(rvalue);
        if (r < 0) {
                r = parse_size(rvalue, 1024, &quota_absolute);
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse disk quota value, ignoring: %s", rvalue);
                        return 0;
                }
        } else
                /* Normalize to 2^32-1 == 100% */
                quota_scale = UINT32_SCALE_FROM_PERMYRIAD(r);
 
        quota_limit->quota_absolute = quota_absolute;
        quota_limit->quota_scale = quota_scale;
        quota_limit->quota_enforce = true;
 
        return 0;
}
 
int config_parse_set_credential(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExecContext *context = ASSERT_PTR(data);
        const Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                /* Empty assignment resets the list */
                context->set_credentials = hashmap_free(context->set_credentials);
                return 0;
        }
 
        _cleanup_free_ char *word = NULL, *id = NULL;
        const char *p = rvalue;
        bool encrypted = ltype;
 
        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 credential name, ignoring: %s", rvalue);
                return 0;
        }
        if (r == 0 || isempty(p)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid syntax, ignoring: %s", rvalue);
                return 0;
        }
 
        r = unit_cred_printf(u, word, &id);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", word);
                return 0;
        }
        if (!credential_name_valid(id)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name \"%s\" not valid, ignoring.", id);
                return 0;
        }
 
        _cleanup_free_ void *d = NULL;
        size_t size;
 
        if (encrypted) {
                r = unbase64mem_full(p, SIZE_MAX, /* secure= */ true, &d, &size);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r, "Encrypted credential data not valid Base64 data, ignoring: %m");
                        return 0;
                }
        } else {
                ssize_t l;
 
                /* We support escape codes here, so that users can insert trailing \n if they like */
                l = cunescape(p, UNESCAPE_ACCEPT_NUL, (char**) &d);
                if (l == -ENOMEM)
                        return log_oom();
                if (l < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, l, "Can't unescape \"%s\", ignoring: %m", p);
                        return 0;
                }
 
                size = l;
        }
 
        r = exec_context_put_set_credential(context, id, TAKE_PTR(d), size, encrypted);
        if (r < 0)
                return log_error_errno(r, "Failed to store set credential '%s': %m", rvalue);
 
        return 0;
}
 
int config_parse_load_credential(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExecContext *context = ASSERT_PTR(data);
        const Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                /* Empty assignment resets the list */
                context->load_credentials = hashmap_free(context->load_credentials);
                return 0;
        }
 
        _cleanup_free_ char *word = NULL, *id = NULL, *path = NULL;
        const char *p = rvalue;
        bool encrypted = ltype;
 
        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, "Invalid syntax, ignoring: %s", rvalue);
                return 0;
        }
 
        r = unit_cred_printf(u, word, &id);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", word);
                return 0;
        }
        if (!credential_name_valid(id)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name \"%s\" not valid, ignoring.", id);
                return 0;
        }
 
        if (isempty(p)) {
                /* If only one field is specified take it as shortcut for inheriting a credential named
                 * the same way from our parent */
                path = strdup(id);
                if (!path)
                        return log_oom();
        } else {
                r = unit_path_printf(u, p, &path);
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", p);
                        return 0;
                }
                if (path_is_absolute(path) ? !path_is_normalized(path) : !credential_name_valid(path)) {
                        log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential source \"%s\" not valid, ignoring.", path);
                        return 0;
                }
        }
 
        r = exec_context_put_load_credential(context, id, path, encrypted);
        if (r < 0)
                return log_error_errno(r, "Failed to store load credential '%s': %m", rvalue);
 
        return 0;
}
 
int config_parse_import_credential(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExecContext *context = ASSERT_PTR(data);
        Unit *u = userdata;
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                /* Empty assignment resets the list */
                context->import_credentials = ordered_set_free(context->import_credentials);
                return 0;
        }
 
        const char *p = rvalue;
        _cleanup_free_ char *word = NULL, *glob = 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, "Invalid syntax, ignoring: %s", rvalue);
                return 0;
        }
 
        r = unit_cred_printf(u, word, &glob);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to resolve unit specifiers in \"%s\", ignoring: %m", word);
                return 0;
        }
 
        if (!credential_glob_valid(glob)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name or glob \"%s\" not valid, ignoring.", glob);
                return 0;
        }
 
        if (!isempty(p) && !credential_name_valid(p)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Credential name \"%s\" not valid, ignoring.", p);
                return 0;
        }
 
        r = exec_context_put_import_credential(context, glob, p);
        if (r < 0)
                return log_error_errno(r, "Failed to store import credential '%s': %m", rvalue);
 
        return 0;
}
 
int config_parse_service_refresh_on_reload(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        Service *s = ASSERT_PTR(userdata);
        int r;
 
        if (isempty(rvalue)) {
                s->refresh_on_reload_set = false;
                return 0;
        }
 
        r = parse_boolean(rvalue);
        if (r >= 0) {
                s->refresh_on_reload_flags = r > 0 ? _SERVICE_REFRESH_ON_RELOAD_ALL : 0;
                s->refresh_on_reload_set = true;
                return 0;
        }
 
        ServiceRefreshOnReload f;
        bool invert = false;
 
        if (rvalue[0] == '~') {
                invert = true;
                rvalue++;
        }
 
        r = service_refresh_on_reload_from_string_many(rvalue, &f);
        if (r < 0)
                return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
 
        /* If the first entry is negated, mask off from default; otherwise assign "positive" values directly */
        if (!s->refresh_on_reload_set)
                s->refresh_on_reload_flags = invert ? (SERVICE_REFRESH_ON_RELOAD_DEFAULT & ~f) : f;
        else
                SET_FLAG(s->refresh_on_reload_flags, f, !invert);
 
        s->refresh_on_reload_set = true;
        return 0;
}
 
int config_parse_set_status(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        ExitStatusSet *status_set = ASSERT_PTR(data);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        /* Empty assignment resets the list */
        if (isempty(rvalue)) {
                exit_status_set_free(status_set);
                return 0;
        }
 
        for (const char *p = rvalue;;) {
                _cleanup_free_ char *word = NULL;
                Bitmap *bitmap;