#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 "def.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-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 "string-util.h"

#include "strv.h"

#include "syslog-util.h"

#include "time-util.h"

#include "utf8.h"

int config_item_table_lookup(

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(

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 name '%s' in section '%s', ignoring.", lvalue, 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;

const char *t;

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;

}

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

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, (char**) 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;

}

int config_parse_many_nulstr(

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

}

int config_parse_many(

Hashmap **ret_stats_by_path) {

_cleanup_strv_free_ char **dropin_dirs = NULL;

_cleanup_strv_free_ char **files = NULL;

const char *suffix;

int r;

suffix = strjoina("/", dropin_dirname);

r = strv_extend_strv_concat(&dropin_dirs, (char**) conf_file_dirs, suffix);

if (r < 0)

return r;

r = conf_files_list_strv(&files, ".conf", NULL, 0, (const char* const*) dropin_dirs);

if (r < 0)

return r;

return config_parse_many_files(conf_files, files, sections, lookup, table, flags, userdata, ret_stats_by_path);

}

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(

void *userdata) {

size_t *sz = data;

uint64_t v;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

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(

void *userdata) {

uint64_t *sz = data;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

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(

void *userdata) {

uint64_t *bytes = data;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

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(

void *userdata) {

uint64_t *bytes = data;

assert(rvalue);

assert(data);

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(

void *userdata) {

int k;

bool *b = data;

bool fatal = ltype;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

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(

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(

void *userdata) {

int k, *t = data;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

/* A tristate is pretty much a boolean, except that it can also take an empty string,

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(

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(

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(

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(

void *userdata) {

_cleanup_free_ char *n = NULL;

bool fatal = ltype;

char **s = data;

int r;

assert(filename);

assert(lvalue);