| /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| |
| #include <errno.h> |
| #include <limits.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <sys/types.h> |
| |
| #include "alloc-util.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 "hostname-util.h" |
| #include "in-addr-util.h" |
| #include "log.h" |
| #include "macro.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 "sd-id128.h" |
| #include "set.h" |
| #include "signal-util.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" |
| |
| 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) { |
| |
| const ConfigTableItem *t; |
| |
| assert(table); |
| assert(lvalue); |
| assert(ret_func); |
| assert(ret_ltype); |
| assert(ret_data); |
| |
| for (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 name '%s' in section '%s', ignoring.", lvalue, 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); |
| |
| 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)) |
| return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EBADMSG), "Bad characters in section header '%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); |
| |
| r = hashmap_ensure_allocated(stats_by_path, &path_hash_ops_free_free); |
| if (r < 0) |
| return r; |
| |
| st_copy = newdup(struct stat, st, 1); |
| if (!st_copy) |
| return -ENOMEM; |
| |
| path_copy = strdup(path); |
| if (!path) |
| return -ENOMEM; |
| |
| r = hashmap_put(*stats_by_path, 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* 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; |
| struct stat st; |
| int r; |
| |
| if (ret_stats_by_path) { |
| stats_by_path = hashmap_new(&path_hash_ops_free_free); |
| if (!stats_by_path) |
| return -ENOMEM; |
| } |
| |
| /* First read the first found main config file. */ |
| STRV_FOREACH(fn, conf_files) { |
| r = config_parse(NULL, *fn, NULL, sections, lookup, table, flags, userdata, &st); |
| if (r < 0) |
| return r; |
| if (r == 0) |
| continue; |
| |
| if (ret_stats_by_path) { |
| r = hashmap_put_stats_by_path(&stats_by_path, *fn, &st); |
| if (r < 0) |
| return r; |
| } |
| |
| break; |
| } |
| |
| /* Then read all the drop-ins. */ |
| STRV_FOREACH(fn, files) { |
| r = config_parse(NULL, *fn, NULL, sections, lookup, table, flags, userdata, &st); |
| if (r < 0) |
| return r; |
| if (r == 0) |
| continue; |
| |
| if (ret_stats_by_path) { |
| r = hashmap_put_stats_by_path(&stats_by_path, *fn, &st); |
| if (r < 0) |
| return r; |
| } |
| } |
| |
| if (ret_stats_by_path) |
| *ret_stats_by_path = TAKE_PTR(stats_by_path); |
| |
| return 0; |
| } |
| |
| /* Parse each config file in the directories specified as nulstr. */ |
| int config_parse_many_nulstr( |
| const char *conf_file, |
| const char *conf_file_dirs, |
| const char *sections, |
| ConfigItemLookup lookup, |
| const void *table, |
| ConfigParseFlags flags, |
| void *userdata, |
| Hashmap **ret_stats_by_path) { |
| |
| _cleanup_strv_free_ char **files = NULL; |
| int r; |
| |
| r = conf_files_list_nulstr(&files, ".conf", NULL, 0, conf_file_dirs); |
| if (r < 0) |
| return r; |
| |
| return config_parse_many_files(STRV_MAKE_CONST(conf_file), |
| files, sections, lookup, table, flags, userdata, |
| ret_stats_by_path); |
| } |
| |
| static int config_get_dropin_files( |
| const char* const* conf_file_dirs, |
| const char *dropin_dirname, |
| char ***ret) { |
| |
| _cleanup_strv_free_ char **dropin_dirs = NULL; |
| const char *suffix; |
| int r; |
| |
| assert(conf_file_dirs); |
| assert(dropin_dirname); |
| assert(ret); |
| |
| suffix = strjoina("/", dropin_dirname); |
| r = strv_extend_strv_concat(&dropin_dirs, (char**) conf_file_dirs, suffix); |
| if (r < 0) |
| return r; |
| |
| return conf_files_list_strv(ret, ".conf", NULL, 0, (const char* const*) dropin_dirs); |
| } |
| |
| /* Parse each config file in the directories specified as strv. */ |
| int config_parse_many( |
| const char* const* conf_files, |
| const char* const* conf_file_dirs, |
| const char *dropin_dirname, |
| 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(sections); |
| assert(table); |
| |
| r = config_get_dropin_files(conf_file_dirs, dropin_dirname, &files); |
| if (r < 0) |
| return r; |
| |
| r = config_parse_many_files(conf_files, files, sections, lookup, table, flags, userdata, ret_stats_by_path); |
| if (r < 0) |
| return r; |
| |
| if (ret_dropin_files) |
| *ret_dropin_files = TAKE_PTR(files); |
| |
| return 0; |
| } |
| |
| 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 = config_get_dropin_files(conf_file_dirs, dropin_dirname, &files); |
| 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, |
| unsigned 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; |
| } |
| |
| 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; |
| } |
| |
| static void config_section_hash_func(const ConfigSection *c, struct siphash *state) { |
| siphash24_compress_string(c->filename, state); |
| siphash24_compress(&c->line, sizeof(c->line), state); |
| } |
| |
| static 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 **s) { |
| ConfigSection *cs; |
| |
| cs = malloc0(offsetof(ConfigSection, filename) + strlen(filename) + 1); |
| if (!cs) |
| return -ENOMEM; |
| |
| strcpy(cs->filename, filename); |
| cs->line = line; |
| |
| *s = TAKE_PTR(cs); |
| |
| return 0; |
| } |
| |
| unsigned hashmap_find_free_section_line(Hashmap *hashmap) { |
| ConfigSection *cs; |
| unsigned n = 0; |
| void *entry; |
| |
| HASHMAP_FOREACH_KEY(entry, cs, hashmap) |
| if (n < cs->line) |
| n = cs->line; |
| |
| return n + 1; |
| } |
| |
| #define DEFINE_PARSER(type, vartype, conv_func) \ |
| DEFINE_CONFIG_PARSE_PTR(config_parse_##type, conv_func, vartype, "Failed to parse " #type " value") |
| |
| 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 && (uint64_t) (size_t) v != v) |
| r = -ERANGE; |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse size value '%s', ignoring: %m", rvalue); |
| return 0; |
| } |
| |
| *sz = (size_t) v; |
| return 0; |
| } |
| |
| int config_parse_si_uint64( |
| 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) { |
| |
| uint64_t *sz = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| r = parse_size(rvalue, 1000, sz); |
| if (r < 0) |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse size value '%s', ignoring: %m", rvalue); |
| |
| return 0; |
| } |
| |
| int config_parse_iec_uint64( |
| 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) { |
| |
| uint64_t *bytes = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| r = parse_size(rvalue, 1024, bytes); |
| if (r < 0) |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse size value, ignoring: %s", rvalue); |
| |
| return 0; |
| } |
| |
| int config_parse_iec_uint64_infinity( |
| 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) { |
| |
| uint64_t *bytes = ASSERT_PTR(data); |
| |
| assert(rvalue); |
| |
| if (streq(rvalue, "infinity")) { |
| *bytes = UINT64_MAX; |
| return 0; |
| } |
| |
| return config_parse_iec_uint64(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata); |
| } |
| |
| int config_parse_bool( |
| 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) { |
| |
| int k; |
| bool *b = ASSERT_PTR(data); |
| bool fatal = ltype; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| k = parse_boolean(rvalue); |
| if (k < 0) { |
| log_syntax(unit, fatal ? LOG_ERR : LOG_WARNING, filename, line, k, |
| "Failed to parse boolean value%s: %s", |
| fatal ? "" : ", ignoring", rvalue); |
| return fatal ? -ENOEXEC : 0; |
| } |
| |
| *b = k; |
| return 0; |
| } |
| |
| int config_parse_id128( |
| 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) { |
| |
| sd_id128_t t, *result = data; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| r = sd_id128_from_string(rvalue, &t); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128bit ID/UUID, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| if (sd_id128_is_null(t)) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, "128bit ID/UUID is all 0, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| *result = t; |
| return 0; |
| } |
| |
| int config_parse_tristate( |
| 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) { |
| |
| int k, *t = ASSERT_PTR(data); |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| /* A tristate is pretty much a boolean, except that it can also take an empty string, |
| * indicating "uninitialized", much like NULL is for a pointer type. */ |
| |
| if (isempty(rvalue)) { |
| *t = -1; |
| return 0; |
| } |
| |
| k = parse_boolean(rvalue); |
| if (k < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, k, |
| "Failed to parse boolean value for %s=, ignoring: %s", lvalue, rvalue); |
| return 0; |
| } |
| |
| *t = k; |
| return 0; |
| } |
| |
| int config_parse_string( |
| 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 **s = ASSERT_PTR(data); |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *s = mfree(*s); |
| return 0; |
| } |
| |
| if (FLAGS_SET(ltype, CONFIG_PARSE_STRING_SAFE) && !string_is_safe(rvalue)) { |
| _cleanup_free_ char *escaped = NULL; |
| |
| escaped = cescape(rvalue); |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Specified string contains unsafe characters, ignoring: %s", strna(escaped)); |
| return 0; |
| } |
| |
| if (FLAGS_SET(ltype, CONFIG_PARSE_STRING_ASCII) && !ascii_is_valid(rvalue)) { |
| _cleanup_free_ char *escaped = NULL; |
| |
| escaped = cescape(rvalue); |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Specified string contains invalid ASCII characters, ignoring: %s", strna(escaped)); |
| return 0; |
| } |
| |
| return free_and_strdup_warn(s, empty_to_null(rvalue)); |
| } |
| |
| int config_parse_dns_name( |
| 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 **hostname = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *hostname = mfree(*hostname); |
| return 0; |
| } |
| |
| r = dns_name_is_valid(rvalue); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Failed to check validity of DNS domain name '%s', ignoring assignment: %m", rvalue); |
| return 0; |
| } |
| if (r == 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Specified invalid DNS domain name, ignoring assignment: %s", rvalue); |
| return 0; |
| } |
| |
| return free_and_strdup_warn(hostname, rvalue); |
| } |
| |
| int config_parse_hostname( |
| 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 **hostname = ASSERT_PTR(data); |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *hostname = mfree(*hostname); |
| return 0; |
| } |
| |
| if (!hostname_is_valid(rvalue, 0)) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Specified invalid hostname, ignoring assignment: %s", rvalue); |
| return 0; |
| } |
| |
| return config_parse_dns_name(unit, filename, line, section, section_line, |
| lvalue, ltype, rvalue, data, userdata); |
| } |
| |
| int config_parse_path( |
| 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 *n = NULL; |
| bool fatal = ltype; |
| char **s = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) |
| goto finalize; |
| |
| n = strdup(rvalue); |
| if (!n) |
| return log_oom(); |
| |
| r = path_simplify_and_warn(n, PATH_CHECK_ABSOLUTE | (fatal ? PATH_CHECK_FATAL : 0), unit, filename, line, lvalue); |
| if (r < 0) |
| return fatal ? -ENOEXEC : 0; |
| |
| finalize: |
| return free_and_replace(*s, n); |
| } |
| |
| int config_parse_strv( |
| 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); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *sv = strv_free(*sv); |
| return 0; |
| } |
| |
| for (const char *p = rvalue;;) { |
| char *word = NULL; |
| |
| r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE|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 = strv_consume(sv, word); |
| if (r < 0) |
| return log_oom(); |
| } |
| } |
| |
| int config_parse_warn_compat( |
| 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) { |
| |
| Disabled reason = ltype; |
| |
| switch (reason) { |
| |
| case DISABLED_CONFIGURATION: |
| log_syntax(unit, LOG_DEBUG, filename, line, 0, |
| "Support for option %s= has been disabled at compile time and it is ignored", lvalue); |
| break; |
| |
| case DISABLED_LEGACY: |
| log_syntax(unit, LOG_INFO, filename, line, 0, |
| "Support for option %s= has been removed and it is ignored", lvalue); |
| break; |
| |
| case DISABLED_EXPERIMENTAL: |
| log_syntax(unit, LOG_INFO, filename, line, 0, |
| "Support for option %s= has not yet been enabled and it is ignored", lvalue); |
| break; |
| } |
| |
| return 0; |
| } |
| |
| int config_parse_log_facility( |
| 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) { |
| |
| int *o = data, x; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| x = log_facility_unshifted_from_string(rvalue); |
| if (x < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, x, "Failed to parse log facility, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| *o = (x << 3) | LOG_PRI(*o); |
| |
| return 0; |
| } |
| |
| int config_parse_log_level( |
| 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) { |
| |
| int *o = data, x; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| x = log_level_from_string(rvalue); |
| if (x < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, x, "Failed to parse log level, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| if (*o < 0) /* if it wasn't initialized so far, assume zero facility */ |
| *o = x; |
| else |
| *o = (*o & LOG_FACMASK) | x; |
| |
| return 0; |
| } |
| |
| int config_parse_signal( |
| 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) { |
| |
| int *sig = data, r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(sig); |
| |
| r = signal_from_string(rvalue); |
| if (r <= 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse signal name, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| *sig = r; |
| return 0; |
| } |
| |
| int config_parse_personality( |
| 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) { |
| |
| unsigned long *personality = data, p; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(personality); |
| |
| if (isempty(rvalue)) |
| p = PERSONALITY_INVALID; |
| else { |
| p = personality_from_string(rvalue); |
| if (p == PERSONALITY_INVALID) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, "Failed to parse personality, ignoring: %s", rvalue); |
| return 0; |
| } |
| } |
| |
| *personality = p; |
| return 0; |
| } |
| |
| int config_parse_ifname( |
| 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 **s = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *s = mfree(*s); |
| return 0; |
| } |
| |
| if (!ifname_valid(rvalue)) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, "Interface name is not valid or too long, ignoring assignment: %s", rvalue); |
| return 0; |
| } |
| |
| r = free_and_strdup(s, rvalue); |
| if (r < 0) |
| return log_oom(); |
| |
| return 0; |
| } |
| |
| int config_parse_ifnames( |
| 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_strv_free_ char **names = NULL; |
| char ***s = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *s = strv_free(*s); |
| return 0; |
| } |
| |
| for (const char *p = rvalue;;) { |
| _cleanup_free_ char *word = NULL; |
| |
| r = extract_first_word(&p, &word, NULL, 0); |
| if (r == -ENOMEM) |
| return log_oom(); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Failed to extract interface name, ignoring assignment: %s", |
| rvalue); |
| return 0; |
| } |
| if (r == 0) |
| break; |
| |
| if (!ifname_valid_full(word, ltype)) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Interface name is not valid or too long, ignoring assignment: %s", |
| word); |
| continue; |
| } |
| |
| r = strv_consume(&names, TAKE_PTR(word)); |
| if (r < 0) |
| return log_oom(); |
| } |
| |
| r = strv_extend_strv(s, names, true); |
| if (r < 0) |
| return log_oom(); |
| |
| return 0; |
| } |
| |
| int config_parse_ip_port( |
| 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) { |
| |
| uint16_t *s = ASSERT_PTR(data); |
| uint16_t port; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *s = 0; |
| return 0; |
| } |
| |
| r = parse_ip_port(rvalue, &port); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse port '%s'.", rvalue); |
| return 0; |
| } |
| |
| *s = port; |
| |
| return 0; |
| } |
| |
| int config_parse_mtu( |
| 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 *mtu = ASSERT_PTR(data); |
| int r; |
| |
| assert(rvalue); |
| |
| r = parse_mtu(ltype, rvalue, mtu); |
| if (r == -ERANGE) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Maximum transfer unit (MTU) value out of range. Permitted range is %" PRIu32 "…%" PRIu32 ", ignoring: %s", |
| (uint32_t) (ltype == AF_INET6 ? IPV6_MIN_MTU : IPV4_MIN_MTU), (uint32_t) UINT32_MAX, |
| rvalue); |
| return 0; |
| } |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Failed to parse MTU value '%s', ignoring: %m", rvalue); |
| return 0; |
| } |
| |
| return 0; |
| } |
| |
| int config_parse_rlimit( |
| 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) { |
| |
| struct rlimit **rl = data, d = {}; |
| int r; |
| |
| assert(rvalue); |
| assert(rl); |
| |
| r = rlimit_parse(ltype, rvalue, &d); |
| if (r == -EILSEQ) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Soft resource limit chosen higher than hard limit, ignoring: %s", rvalue); |
| return 0; |
| } |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse resource value, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| if (rl[ltype]) |
| *rl[ltype] = d; |
| else { |
| rl[ltype] = newdup(struct rlimit, &d, 1); |
| if (!rl[ltype]) |
| return log_oom(); |
| } |
| |
| return 0; |
| } |
| |
| int config_parse_permille( |
| 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) { |
| |
| unsigned *permille = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| r = parse_permille(rvalue); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Failed to parse permille value, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| *permille = (unsigned) r; |
| |
| return 0; |
| } |
| |
| int config_parse_vlanprotocol( |
| 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) { |
| |
| int *vlan_protocol = data; |
| |
| assert(filename); |
| assert(lvalue); |
| |
| if (isempty(rvalue)) { |
| *vlan_protocol = -1; |
| return 0; |
| } |
| |
| if (STR_IN_SET(rvalue, "802.1ad", "802.1AD")) |
| *vlan_protocol = ETH_P_8021AD; |
| else if (STR_IN_SET(rvalue, "802.1q", "802.1Q")) |
| *vlan_protocol = ETH_P_8021Q; |
| else { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Failed to parse VLAN protocol value, ignoring: %s", rvalue); |
| return 0; |
| } |
| |
| return 0; |
| } |
| |
| int config_parse_hw_addr( |
| 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) { |
| |
| struct hw_addr_data a, *hwaddr = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *hwaddr = HW_ADDR_NULL; |
| return 0; |
| } |
| |
| r = parse_hw_addr_full(rvalue, ltype, &a); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Not a valid hardware address, ignoring assignment: %s", rvalue); |
| return 0; |
| } |
| |
| *hwaddr = a; |
| return 0; |
| } |
| |
| int config_parse_hw_addrs( |
| 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) { |
| |
| Set **hwaddrs = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| /* Empty assignment resets the list */ |
| *hwaddrs = set_free(*hwaddrs); |
| return 0; |
| } |
| |
| for (const char *p = rvalue;;) { |
| _cleanup_free_ char *word = NULL; |
| _cleanup_free_ struct hw_addr_data *n = NULL; |
| |
| r = extract_first_word(&p, &word, NULL, 0); |
| 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; |
| } |
| |
| n = new(struct hw_addr_data, 1); |
| if (!n) |
| return log_oom(); |
| |
| r = parse_hw_addr_full(word, ltype, n); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Not a valid hardware address, ignoring: %s", word); |
| continue; |
| } |
| |
| r = set_ensure_consume(hwaddrs, &hw_addr_hash_ops_free, TAKE_PTR(n)); |
| if (r < 0) |
| return log_oom(); |
| } |
| } |
| |
| int config_parse_ether_addr( |
| 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_ struct ether_addr *n = NULL; |
| struct ether_addr **hwaddr = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| *hwaddr = mfree(*hwaddr); |
| return 0; |
| } |
| |
| n = new0(struct ether_addr, 1); |
| if (!n) |
| return log_oom(); |
| |
| r = parse_ether_addr(rvalue, n); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Not a valid MAC address, ignoring assignment: %s", rvalue); |
| return 0; |
| } |
| |
| free_and_replace(*hwaddr, n); |
| |
| return 0; |
| } |
| |
| int config_parse_ether_addrs( |
| 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) { |
| |
| Set **hwaddrs = ASSERT_PTR(data); |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| |
| if (isempty(rvalue)) { |
| /* Empty assignment resets the list */ |
| *hwaddrs = set_free(*hwaddrs); |
| return 0; |
| } |
| |
| for (const char *p = rvalue;;) { |
| _cleanup_free_ char *word = NULL; |
| _cleanup_free_ struct ether_addr *n = NULL; |
| |
| r = extract_first_word(&p, &word, NULL, 0); |
| 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; |
| } |
| |
| n = new(struct ether_addr, 1); |
| if (!n) |
| return log_oom(); |
| |
| r = parse_ether_addr(word, n); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Not a valid MAC address, ignoring: %s", word); |
| continue; |
| } |
| |
| r = set_ensure_consume(hwaddrs, ðer_addr_hash_ops_free, TAKE_PTR(n)); |
| if (r < 0) |
| return log_oom(); |
| } |
| } |
| |
| int config_parse_in_addr_non_null( |
| 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) { |
| |
| /* data must be a pointer to struct in_addr or in6_addr, and the type is determined by ltype. */ |
| struct in_addr *ipv4 = ASSERT_PTR(data); |
| struct in6_addr *ipv6 = ASSERT_PTR(data); |
| union in_addr_union a; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(IN_SET(ltype, AF_INET, AF_INET6)); |
| |
| if (isempty(rvalue)) { |
| if (ltype == AF_INET) |
| *ipv4 = (struct in_addr) {}; |
| else |
| *ipv6 = (struct in6_addr) {}; |
| return 0; |
| } |
| |
| r = in_addr_from_string(ltype, rvalue, &a); |
| if (r < 0) { |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue); |
| return 0; |
| } |
| |
| if (!in_addr_is_set(ltype, &a)) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "%s= cannot be the ANY address, ignoring: %s", lvalue, rvalue); |
| return 0; |
| } |
| |
| if (ltype == AF_INET) |
| *ipv4 = a.in; |
| else |
| *ipv6 = a.in6; |
| return 0; |
| } |
| |
| DEFINE_CONFIG_PARSE(config_parse_percent, parse_percent, "Failed to parse percent value"); |
| DEFINE_CONFIG_PARSE(config_parse_permyriad, parse_permyriad, "Failed to parse permyriad value"); |
| DEFINE_CONFIG_PARSE_PTR(config_parse_sec_fix_0, parse_sec_fix_0, usec_t, "Failed to parse time value"); |
