HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/conf-parser.c
Git blob: a26d2f8dafed50116e75e7f1cf5c8ffb96e95212
Lines 1–1000 of 2,316
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/ipv6.h>
#include <stdio.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "calendarspec.h"
#include "chase.h"
#include "conf-files.h"
#include "conf-parser.h"
#include "constants.h"
#include "dns-domain.h"
#include "escape.h"
#include "ether-addr-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "hash-funcs.h"
#include "hostname-util.h"
#include "id128-util.h"
#include "in-addr-prefix-util.h"
#include "ip-protocol-list.h"
#include "log.h"
#include "missing-network.h"
#include "nulstr-util.h"
#include "parse-helpers.h"
#include "parse-util.h"
#include "path-util.h"
#include "percent-util.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "set.h"
#include "signal-util.h"
#include "siphash24.h"
#include "socket-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "syslog-util.h"
#include "time-util.h"
#include "utf8.h"
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(config_file_hash_ops_fclose,
char, path_hash_func, path_compare,
FILE, safe_fclose);
int config_item_table_lookup(
const void *table,
const char *section,
const char *lvalue,
ConfigParserCallback *ret_func,
int *ret_ltype,
void **ret_data,
void *userdata) {
assert(table);
assert(lvalue);
assert(ret_func);
assert(ret_ltype);
assert(ret_data);
for (const ConfigTableItem *t = table; t->lvalue; t++) {
if (!streq(lvalue, t->lvalue))
continue;
if (!streq_ptr(section, t->section))
continue;
*ret_func = t->parse;
*ret_ltype = t->ltype;
*ret_data = t->data;
return 1;
}
*ret_func = NULL;
*ret_ltype = 0;
*ret_data = NULL;
return 0;
}
int config_item_perf_lookup(
const void *table,
const char *section,
const char *lvalue,
ConfigParserCallback *ret_func,
int *ret_ltype,
void **ret_data,
void *userdata) {
ConfigPerfItemLookup lookup = (ConfigPerfItemLookup) table;
const ConfigPerfItem *p;
assert(table);
assert(lvalue);
assert(ret_func);
assert(ret_ltype);
assert(ret_data);
if (section) {
const char *key;
key = strjoina(section, ".", lvalue);
p = lookup(key, strlen(key));
} else
p = lookup(lvalue, strlen(lvalue));
if (!p) {
*ret_func = NULL;
*ret_ltype = 0;
*ret_data = NULL;
return 0;
}
*ret_func = p->parse;
*ret_ltype = p->ltype;
*ret_data = (uint8_t*) userdata + p->offset;
return 1;
}
/* Run the user supplied parser for an assignment */
static int next_assignment(
const char *unit,
const char *filename,
unsigned line,
ConfigItemLookup lookup,
const void *table,
const char *section,
unsigned section_line,
const char *lvalue,
const char *rvalue,
ConfigParseFlags flags,
void *userdata) {
ConfigParserCallback func = NULL;
int ltype = 0;
void *data = NULL;
int r;
assert(filename);
assert(line > 0);
assert(lookup);
assert(lvalue);
assert(rvalue);
r = lookup(table, section, lvalue, &func, <ype, &data, userdata);
if (r < 0)
return r;
if (r > 0) {
if (!func)
return 0;
return func(unit, filename, line, section, section_line,
lvalue, ltype, rvalue, data, userdata);
}
/* Warn about unknown non-extension fields. */
if (!(flags & CONFIG_PARSE_RELAXED) && !startswith(lvalue, "X-"))
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Unknown key '%s'%s%s%s, ignoring.",
lvalue,
section ? " in section [" : "",
strempty(section),
section ? "]" : "");
return 0;
}
/* Parse a single logical line */
static int parse_line(
const char *unit,
const char *filename,
unsigned line,
const char *sections,
ConfigItemLookup lookup,
const void *table,
ConfigParseFlags flags,
char **section,
unsigned *section_line,
bool *section_ignored,
char *l, /* is modified */
void *userdata) {
char *e;
assert(filename);
assert(line > 0);
assert(lookup);
assert(l);
assert(section);
assert(section_line);
assert(section_ignored);
l = strstrip(l);
if (isempty(l))
return 0;
if (l[0] == '\n')
return 0;
if (!utf8_is_valid(l))
return log_syntax_invalid_utf8(unit, LOG_WARNING, filename, line, l);
if (l[0] == '[') {
_cleanup_free_ char *n = NULL;
size_t k;
k = strlen(l);
assert(k > 0);
if (l[k-1] != ']')
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EBADMSG), "Invalid section header '%s'", l);
n = strndup(l+1, k-2);
if (!n)
return log_oom();
if (!string_is_safe(n, /* flags= */ 0))
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EBADMSG), "Section header invalid '%s'", l);
if (sections && !nulstr_contains(sections, n)) {
bool ignore;
ignore = (flags & CONFIG_PARSE_RELAXED) || startswith(n, "X-");
if (!ignore)
NULSTR_FOREACH(t, sections)
if (streq_ptr(n, startswith(t, "-"))) { /* Ignore sections prefixed with "-" in valid section list */
ignore = true;
break;
}
if (!ignore)
log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown section '%s'. Ignoring.", n);
*section = mfree(*section);
*section_line = 0;
*section_ignored = true;
} else {
free_and_replace(*section, n);
*section_line = line;
*section_ignored = false;
}
return 0;
}
if (sections && !*section) {
if (!(flags & CONFIG_PARSE_RELAXED) && !*section_ignored)
log_syntax(unit, LOG_WARNING, filename, line, 0, "Assignment outside of section. Ignoring.");
return 0;
}
e = strchr(l, '=');
if (!e)
return log_syntax(unit, LOG_WARNING, filename, line, 0,
"Missing '=', ignoring line.");
if (e == l)
return log_syntax(unit, LOG_WARNING, filename, line, 0,
"Missing key name before '=', ignoring line.");
*e = 0;
e++;
return next_assignment(unit,
filename,
line,
lookup,
table,
*section,
*section_line,
strstrip(l),
strstrip(e),
flags,
userdata);
}
/* Go through the file and parse each line */
int config_parse(
const char *unit,
const char *filename,
FILE *f,
const char *sections,
ConfigItemLookup lookup,
const void *table,
ConfigParseFlags flags,
void *userdata,
struct stat *ret_stat) {
_cleanup_free_ char *section = NULL, *continuation = NULL;
_cleanup_fclose_ FILE *ours = NULL;
unsigned line = 0, section_line = 0;
bool section_ignored = false, bom_seen = false;
struct stat st;
int r, fd;
assert(filename);
assert(lookup);
if (!f) {
f = ours = fopen(filename, "re");
if (!f) {
/* Only log on request, except for ENOENT,
* since we return 0 to the caller. */
if ((flags & CONFIG_PARSE_WARN) || errno == ENOENT)
log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_ERR, errno,
"Failed to open configuration file '%s': %m", filename);
if (errno == ENOENT) {
if (ret_stat)
*ret_stat = (struct stat) {};
return 0;
}
return -errno;
}
}
fd = fileno(f);
if (fd >= 0) { /* stream might not have an fd, let's be careful hence */
if (fstat(fd, &st) < 0)
return log_full_errno(FLAGS_SET(flags, CONFIG_PARSE_WARN) ? LOG_ERR : LOG_DEBUG, errno,
"Failed to fstat(%s): %m", filename);
(void) stat_warn_permissions(filename, &st);
} else
st = (struct stat) {};
for (;;) {
_cleanup_free_ char *buf = NULL;
bool escaped = false;
char *l, *p, *e;
r = read_line(f, LONG_LINE_MAX, &buf);
if (r == 0)
break;
if (r == -ENOBUFS) {
if (flags & CONFIG_PARSE_WARN)
log_error_errno(r, "%s:%u: Line too long", filename, line);
return r;
}
if (r < 0) {
if (FLAGS_SET(flags, CONFIG_PARSE_WARN))
log_error_errno(r, "%s:%u: Error while reading configuration file: %m", filename, line);
return r;
}
line++;
l = skip_leading_chars(buf, WHITESPACE);
if (*l != '\0' && strchr(COMMENTS, *l))
continue;
l = buf;
if (!bom_seen) {
char *q;
q = startswith(buf, UTF8_BYTE_ORDER_MARK);
if (q) {
l = q;
bom_seen = true;
}
}
if (continuation) {
if (strlen(continuation) + strlen(l) > LONG_LINE_MAX) {
if (flags & CONFIG_PARSE_WARN)
log_error("%s:%u: Continuation line too long", filename, line);
return -ENOBUFS;
}
if (!strextend(&continuation, l)) {
if (flags & CONFIG_PARSE_WARN)
log_oom();
return -ENOMEM;
}
p = continuation;
} else
p = l;
for (e = p; *e; e++) {
if (escaped)
escaped = false;
else if (*e == '\\')
escaped = true;
}
if (escaped) {
*(e-1) = ' ';
if (!continuation) {
continuation = strdup(l);
if (!continuation) {
if (flags & CONFIG_PARSE_WARN)
log_oom();
return -ENOMEM;
}
}
continue;
}
r = parse_line(unit,
filename,
line,
sections,
lookup,
table,
flags,
§ion,
§ion_line,
§ion_ignored,
p,
userdata);
if (r < 0) {
if (flags & CONFIG_PARSE_WARN)
log_warning_errno(r, "%s:%u: Failed to parse file: %m", filename, line);
return r;
}
continuation = mfree(continuation);
}
if (continuation) {
r = parse_line(unit,
filename,
++line,
sections,
lookup,
table,
flags,
§ion,
§ion_line,
§ion_ignored,
continuation,
userdata);
if (r < 0) {
if (flags & CONFIG_PARSE_WARN)
log_warning_errno(r, "%s:%u: Failed to parse file: %m", filename, line);
return r;
}
}
if (ret_stat)
*ret_stat = st;
return 1;
}
int hashmap_put_stats_by_path(Hashmap **stats_by_path, const char *path, const struct stat *st) {
_cleanup_free_ struct stat *st_copy = NULL;
_cleanup_free_ char *path_copy = NULL;
int r;
assert(stats_by_path);
assert(path);
assert(st);
st_copy = newdup(struct stat, st, 1);
if (!st_copy)
return -ENOMEM;
path_copy = strdup(path);
if (!path_copy)
return -ENOMEM;
r = hashmap_ensure_put(stats_by_path, &path_hash_ops_free_free, path_copy, st_copy);
if (r < 0)
return r;
assert(r > 0);
TAKE_PTR(path_copy);
TAKE_PTR(st_copy);
return 0;
}
static int config_parse_many_files(
const char *root,
int root_fd,
const char* const* conf_files,
char **files,
const char *sections,
ConfigItemLookup lookup,
const void *table,
ConfigParseFlags flags,
void *userdata,
Hashmap **ret_stats_by_path) {
_cleanup_hashmap_free_ Hashmap *stats_by_path = NULL;
_cleanup_ordered_hashmap_free_ OrderedHashmap *dropins = NULL;
_cleanup_set_free_ Set *inodes = NULL;
struct stat st;
int r, level = FLAGS_SET(flags, CONFIG_PARSE_WARN) ? LOG_WARNING : LOG_DEBUG;
if (ret_stats_by_path) {
stats_by_path = hashmap_new(&path_hash_ops_free_free);
if (!stats_by_path)
return log_oom_full(level);
}
/* Pin and stat() all dropins */
STRV_FOREACH(fn, files) {
_cleanup_fclose_ FILE *f = NULL;
r = chase_and_fopenat_unlocked(root_fd, root_fd, *fn, CHASE_MUST_BE_REGULAR, "re", /* ret_path= */ NULL, &f);
if (r == -ENOENT)
continue;
if (r < 0)
return log_full_errno(level, r, "Failed to open %s: %m", *fn);
int fd = fileno(f);
assert(fd >= 0);
r = ordered_hashmap_ensure_put(&dropins, &config_file_hash_ops_fclose, *fn, f);
if (r < 0) {
assert(r == -ENOMEM);
return log_oom_full(level);
}
assert(r > 0);
TAKE_PTR(f);
/* Get inodes for all drop-ins. Later we'll verify if main config is a symlink to or is
* symlinked as one of them. If so, we skip reading main config file directly. */
_cleanup_free_ struct stat *st_dropin = new(struct stat, 1);
if (!st_dropin)
return log_oom_full(level);
if (fstat(fd, st_dropin) < 0)
return log_full_errno(level, errno, "Failed to stat %s: %m", *fn);
r = set_ensure_consume(&inodes, &inode_hash_ops, TAKE_PTR(st_dropin));
if (r < 0)
return log_oom_full(level);
}
/* First process the first found main config file. */
STRV_FOREACH(fn, conf_files) {
_cleanup_fclose_ FILE *f = NULL;
r = chase_and_fopenat_unlocked(root_fd, root_fd, *fn, CHASE_MUST_BE_REGULAR, "re", /* ret_path= */ NULL, &f);
if (r == -ENOENT)
continue;
if (r < 0)
return log_full_errno(level, r, "Failed to open %s: %m", *fn);
if (inodes) {
if (fstat(fileno(f), &st) < 0)
return log_full_errno(level, errno, "Failed to stat %s: %m", *fn);
if (set_contains(inodes, &st)) {
log_debug("%s: symlink to/symlinked as drop-in, will be read later.", *fn);
break;
}
}
r = config_parse(/* unit= */ NULL, *fn, f, sections, lookup, table, flags, userdata, &st);
if (r < 0)
return r; /* config_parse() logs internally. */
assert(r > 0);
if (ret_stats_by_path) {
r = hashmap_put_stats_by_path(&stats_by_path, *fn, &st);
if (r < 0)
return log_full_errno(level, r, "Failed to save stats of %s: %m", *fn);
}
break;
}
/* Then read all the drop-ins. */
const char *path_dropin;
FILE *f_dropin;
ORDERED_HASHMAP_FOREACH_KEY(f_dropin, path_dropin, dropins) {
r = config_parse(/* unit= */ NULL, path_dropin, f_dropin, sections, lookup, table, flags, userdata, &st);
if (r < 0)
return r; /* config_parse() logs internally. */
assert(r > 0);
if (ret_stats_by_path) {
r = hashmap_put_stats_by_path(&stats_by_path, path_dropin, &st);
if (r < 0)
return log_full_errno(level, r, "Failed to save stats of %s: %m", path_dropin);
}
}
if (ret_stats_by_path)
*ret_stats_by_path = TAKE_PTR(stats_by_path);
return 0;
}
static int normalize_root_fd(const char *root, int *root_fd, int *ret_opened_fd) {
assert(root_fd);
assert(ret_opened_fd);
/* Normalizes a root dir specification: if root_fd is already valid, keep it. Otherwise, we open the
* specified dir */
if (wildcard_fd_is_valid(*root_fd)) {
*ret_opened_fd = -EBADF;
return 0;
}
if (empty_or_root(root)) {
*root_fd = XAT_FDROOT;
*ret_opened_fd = -EBADF;
return 0;
}
int fd = open(root, O_CLOEXEC|O_PATH|O_DIRECTORY);
if (fd < 0)
return log_error_errno(errno, "Failed to open root directory '%s': %m", root);
*ret_opened_fd = *root_fd = fd;
return 0;
}
/* Parse each config file in the directories specified as strv. */
int config_parse_many_full(
const char* const* conf_files,
const char* const* conf_file_dirs,
const char *dropin_dirname,
const char *root,
int root_fd,
const char *sections,
ConfigItemLookup lookup,
const void *table,
ConfigParseFlags flags,
void *userdata,
Hashmap **ret_stats_by_path,
char ***ret_dropin_files) {
_cleanup_strv_free_ char **files = NULL;
int r;
assert(conf_file_dirs);
assert(dropin_dirname);
assert(table);
_cleanup_close_ int opened_root_fd = -EBADF;
r = normalize_root_fd(root, &root_fd, &opened_root_fd);
if (r < 0)
return r;
r = conf_files_list_dropins(
&files,
dropin_dirname,
root,
root_fd,
FLAGS_SET(flags, CONFIG_PARSE_WARN) ? CONF_FILES_WARN : 0,
conf_file_dirs);
if (r < 0)
return log_full_errno(FLAGS_SET(flags, CONFIG_PARSE_WARN) ? LOG_WARNING : LOG_DEBUG, r,
"Failed to list drop-ins in %s: %m", dropin_dirname);
r = config_parse_many_files(
root,
root_fd,
conf_files,
files,
sections,
lookup,
table,
flags,
userdata,
ret_stats_by_path);
if (r < 0)
return r; /* config_parse_many_files() logs internally. */
if (ret_dropin_files)
*ret_dropin_files = TAKE_PTR(files);
return 0;
}
int config_parse_standard_file_with_dropins_full(
const char *root,
int root_fd,
const char *main_file, /* A path like "systemd/frobnicator.conf" */
const char *sections,
ConfigItemLookup lookup,
const void *table,
ConfigParseFlags flags,
void *userdata,
Hashmap **ret_stats_by_path,
char ***ret_dropin_files) {
const char* const *conf_file_dirs = (const char* const*) CONF_PATHS_STRV("");
_cleanup_strv_free_ char **conf_files = NULL;
int r, level = FLAGS_SET(flags, CONFIG_PARSE_WARN) ? LOG_WARNING : LOG_DEBUG;
/* Build the list of main config files */
r = strv_extend_strv_concat(
&conf_files,
conf_file_dirs,
main_file);
if (r < 0)
return log_oom_full(level);
_cleanup_free_ char *dropin_dirname = strjoin(main_file, ".d");
if (!dropin_dirname)
return log_oom_full(level);
return config_parse_many_full(
(const char* const*) conf_files,
conf_file_dirs,
dropin_dirname,
root,
root_fd,
sections,
lookup,
table,
flags,
userdata,
ret_stats_by_path,
ret_dropin_files);
}
static int dropins_get_stats_by_path(
const char* conf_file,
const char* const* conf_file_dirs,
Hashmap **stats_by_path) {
_cleanup_strv_free_ char **files = NULL;
_cleanup_free_ char *dropin_dirname = NULL;
int r;
assert(conf_file);
assert(conf_file_dirs);
assert(stats_by_path);
r = path_extract_filename(conf_file, &dropin_dirname);
if (r < 0)
return r;
if (r == O_DIRECTORY)
return -EINVAL;
if (!strextend(&dropin_dirname, ".d"))
return -ENOMEM;
r = conf_files_list_dropins(
&files,
dropin_dirname,
/* root= */ NULL,
/* root_fd= */ XAT_FDROOT,
/* flags= */ 0,
conf_file_dirs);
if (r < 0)
return r;
STRV_FOREACH(fn, files) {
struct stat st;
if (stat(*fn, &st) < 0) {
if (errno == ENOENT)
continue;
return -errno;
}
r = hashmap_put_stats_by_path(stats_by_path, *fn, &st);
if (r < 0)
return r;
}
return 0;
}
int config_get_stats_by_path(
const char *suffix,
const char *root,
ConfFilesFlags flags,
const char* const* dirs,
bool check_dropins,
Hashmap **ret) {
_cleanup_hashmap_free_ Hashmap *stats_by_path = NULL;
_cleanup_strv_free_ char **files = NULL;
int r;
assert(suffix);
assert(dirs);
assert(ret);
/* Unlike config_parse(), this does not support stream. */
r = conf_files_list_strv(&files, suffix, root, flags, dirs);
if (r < 0)
return r;
STRV_FOREACH(f, files) {
struct stat st;
/* First read the main config file. */
if (stat(*f, &st) < 0) {
if (errno == ENOENT)
continue;
return -errno;
}
/* Skipping an empty file. */
if (null_or_empty(&st))
continue;
r = hashmap_put_stats_by_path(&stats_by_path, *f, &st);
if (r < 0)
return r;
if (!check_dropins)
continue;
/* Then read all the drop-ins if requested. */
r = dropins_get_stats_by_path(*f, dirs, &stats_by_path);
if (r < 0)
return r;
}
*ret = TAKE_PTR(stats_by_path);
return 0;
}
bool stats_by_path_equal(Hashmap *a, Hashmap *b) {
struct stat *st_a, *st_b;
const char *path;
if (hashmap_size(a) != hashmap_size(b))
return false;
HASHMAP_FOREACH_KEY(st_a, path, a) {
st_b = hashmap_get(b, path);
if (!st_b)
return false;
if (!stat_inode_unmodified(st_a, st_b))
return false;
}
return true;
}
int config_section_parse(
const ConfigSectionParser *parsers,
size_t n_parsers,
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *userdata) {
assert(parsers);
assert(n_parsers > 0);
assert(ltype >= 0);
assert((size_t) ltype < n_parsers);
assert(userdata);
const ConfigSectionParser *e = parsers + ltype;
assert(e->parser);
/* This is used when a object is dynamically allocated per [SECTION] in a config parser, e.g.
* [Address] for systemd.network. Takes the allocated object as 'userdata', then it is passed to
* config parsers in the table. The 'data' field points to an element of the passed object, where
* its offset is given by the table. */
return e->parser(unit, filename, line, section, section_line, lvalue, e->ltype, rvalue,
(uint8_t*) userdata + e->offset, userdata);
}
void config_section_hash_func(const ConfigSection *c, struct siphash *state) {
siphash24_compress_string(c->filename, state);
siphash24_compress_typesafe(c->line, state);
}
int config_section_compare_func(const ConfigSection *x, const ConfigSection *y) {
int r;
r = strcmp(x->filename, y->filename);
if (r != 0)
return r;
return CMP(x->line, y->line);
}
DEFINE_HASH_OPS(config_section_hash_ops, ConfigSection, config_section_hash_func, config_section_compare_func);
int config_section_new(const char *filename, unsigned line, ConfigSection **ret) {
ConfigSection *cs;
assert(filename);
assert(line > 0);
assert(ret);
cs = malloc0(offsetof(ConfigSection, filename) + strlen(filename) + 1);
if (!cs)
return -ENOMEM;
strcpy(cs->filename, filename);
cs->line = line;
*ret = TAKE_PTR(cs);
return 0;
}
static int _hashmap_by_section_find_unused_line(
HashmapBase *entries_by_section,
const char *filename,
unsigned *ret) {
ConfigSection *cs;
unsigned n = 0;
void *entry;
assert(ret);
HASHMAP_BASE_FOREACH_KEY(entry, cs, entries_by_section) {
if (filename && !streq(cs->filename, filename))
continue;
n = MAX(n, cs->line);
}
/* overflow? */
if (n >= UINT_MAX)
return -EFBIG;
*ret = n + 1;
return 0;
}
int hashmap_by_section_find_unused_line(
Hashmap *entries_by_section,
const char *filename,
unsigned *ret) {
return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
}
int ordered_hashmap_by_section_find_unused_line(
OrderedHashmap *entries_by_section,
const char *filename,
unsigned *ret) {
return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
}
#define DEFINE_PARSER(type, vartype, conv_func) \
DEFINE_CONFIG_PARSE_PTR(config_parse_##type, conv_func, vartype)
DEFINE_PARSER(int, int, safe_atoi);
DEFINE_PARSER(long, long, safe_atoli);
DEFINE_PARSER(uint8, uint8_t, safe_atou8);
DEFINE_PARSER(uint16, uint16_t, safe_atou16);
DEFINE_PARSER(uint32, uint32_t, safe_atou32);
DEFINE_PARSER(int32, int32_t, safe_atoi32);
DEFINE_PARSER(uint64, uint64_t, safe_atou64);
DEFINE_PARSER(unsigned, unsigned, safe_atou);
DEFINE_PARSER(double, double, safe_atod);
DEFINE_PARSER(nsec, nsec_t, parse_nsec);
DEFINE_PARSER(sec, usec_t, parse_sec);
DEFINE_PARSER(sec_def_infinity, usec_t, parse_sec_def_infinity);
DEFINE_PARSER(mode, mode_t, parse_mode);
DEFINE_PARSER(pid, pid_t, parse_pid);
int config_parse_iec_size(
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) {
size_t *sz = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = parse_size(rvalue, 1024, &v);
if (r >= 0 && v > SIZE_MAX)
r = -ERANGE;
if (r < 0)
return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
*sz = (size_t) v;