#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(

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(

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;

}

static int next_assignment(

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, &ltype, &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;

}

static int parse_line(

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);

}

int config_parse(

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,

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,

&section,

&section_line,

&section_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,

&section,

&section_line,

&section_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(

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, *fn, CHASE_AT_RESOLVE_IN_ROOT|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

_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, *fn, CHASE_AT_RESOLVE_IN_ROOT|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

if (*root_fd >= 0 || IN_SET(*root_fd, AT_FDCWD, XAT_FDROOT)) {

*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;

}

int config_parse_many_full(

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(

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(

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(

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.

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;

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(

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)

return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);

*sz = (size_t) v;

return 1;

}

int config_parse_si_uint64(