#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <assert.h>

#include <stdlib.h>

#include <netinet/ether.h>

#include "conf-parser.h"

#include "util.h"

#include "macro.h"

#include "strv.h"

#include "log.h"

#include "utf8.h"

#include "path-util.h"

#include "set.h"

#include "exit-status.h"

#include "sd-messages.h"

int log_syntax_internal(const char *unit, int level,

const char *file, unsigned line, const char *func,

const char *config_file, unsigned config_line,

int error, const char *format, ...) {

_cleanup_free_ char *msg = NULL;

int r;

va_list ap;

va_start(ap, format);

r = vasprintf(&msg, format, ap);

va_end(ap);

if (r < 0)

return log_oom();

if (unit)

r = log_struct_internal(level,

file, line, func,

getpid() == 1 ? "UNIT=%s" : "USER_UNIT=%s", unit,

MESSAGE_ID(SD_MESSAGE_CONFIG_ERROR),

"CONFIG_FILE=%s", config_file,

"CONFIG_LINE=%u", config_line,

"ERRNO=%d", error > 0 ? error : EINVAL,

"MESSAGE=[%s:%u] %s", config_file, config_line, msg,

NULL);

else

r = log_struct_internal(level,

file, line, func,

MESSAGE_ID(SD_MESSAGE_CONFIG_ERROR),

"CONFIG_FILE=%s", config_file,

"CONFIG_LINE=%u", config_line,

"ERRNO=%d", error > 0 ? error : EINVAL,

"MESSAGE=[%s:%u] %s", config_file, config_line, msg,

NULL);

return r;

}

int config_item_table_lookup(

void *table,

const char *section,

const char *lvalue,

ConfigParserCallback *func,

int *ltype,

void **data,

void *userdata) {

ConfigTableItem *t;

assert(table);

assert(lvalue);

assert(func);

assert(ltype);

assert(data);

for (t = table; t->lvalue; t++) {

if (!streq(lvalue, t->lvalue))

continue;

if (!streq_ptr(section, t->section))

continue;

*func = t->parse;

*ltype = t->ltype;

*data = t->data;

return 1;

}

return 0;

}

int config_item_perf_lookup(

void *table,

const char *section,

const char *lvalue,

ConfigParserCallback *func,

int *ltype,

void **data,

void *userdata) {

ConfigPerfItemLookup lookup = (ConfigPerfItemLookup) table;

const ConfigPerfItem *p;

assert(table);

assert(lvalue);

assert(func);

assert(ltype);

assert(data);

if (!section)

p = lookup(lvalue, strlen(lvalue));

else {

char *key;

key = strjoin(section, ".", lvalue, NULL);

if (!key)

return -ENOMEM;

p = lookup(key, strlen(key));

free(key);

}

if (!p)

return 0;

*func = p->parse;

*ltype = p->ltype;

*data = (uint8_t*) userdata + p->offset;

return 1;

}

static int next_assignment(const char *unit,

const char *filename,

unsigned line,

ConfigItemLookup lookup,

void *table,

const char *section,

unsigned section_line,

const char *lvalue,

const char *rvalue,

bool relaxed,

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 func(unit, filename, line, section, section_line,

lvalue, ltype, rvalue, data, userdata);

return 0;

}

/* Warn about unknown non-extension fields. */

if (!relaxed && !startswith(lvalue, "X-"))

log_syntax(unit, LOG_WARNING, filename, line, EINVAL,

"Unknown lvalue '%s' in section '%s'", lvalue, section);

return 0;

}

static int parse_line(const char* unit,

const char *filename,

unsigned line,

const char *sections,

ConfigItemLookup lookup,

void *table,

bool relaxed,

bool allow_include,

char **section,

unsigned *section_line,

char *l,

void *userdata) {

char *e;

assert(filename);

assert(line > 0);

assert(lookup);

assert(l);

l = strstrip(l);

if (!*l)

return 0;

if (strchr(COMMENTS "\n", *l))

return 0;

if (startswith(l, ".include ")) {

_cleanup_free_ char *fn = NULL;

/* .includes are a bad idea, we only support them here

if (!allow_include) {

log_syntax(unit, LOG_ERR, filename, line, EBADMSG,

".include not allowed here. Ignoring.");

return 0;

}

fn = file_in_same_dir(filename, strstrip(l+9));

if (!fn)

return -ENOMEM;

return config_parse(unit, fn, NULL, sections, lookup, table, relaxed, false, userdata);

}

if (*l == '[') {

size_t k;

char *n;

k = strlen(l);

assert(k > 0);

if (l[k-1] != ']') {

log_syntax(unit, LOG_ERR, filename, line, EBADMSG,

"Invalid section header '%s'", l);

return -EBADMSG;

}

n = strndup(l+1, k-2);

if (!n)

return -ENOMEM;

if (sections && !nulstr_contains(sections, n)) {

if (!relaxed)

log_syntax(unit, LOG_WARNING, filename, line, EINVAL,

"Unknown section '%s'. Ignoring.", n);

free(n);

free(*section);

*section = NULL;

*section_line = 0;

} else {

free(*section);

*section = n;

*section_line = line;

}

return 0;

}

if (sections && !*section) {

if (!relaxed)

log_syntax(unit, LOG_WARNING, filename, line, EINVAL,

"Assignment outside of section. Ignoring.");

return 0;

}

e = strchr(l, '=');

if (!e) {

log_syntax(unit, LOG_WARNING, filename, line, EINVAL, "Missing '='.");

return -EBADMSG;

}

*e = 0;

e++;

return next_assignment(unit,

filename,

line,

lookup,

table,

*section,

*section_line,

strstrip(l),

strstrip(e),

relaxed,

userdata);

}

int config_parse(const char *unit,

const char *filename,

FILE *f,

const char *sections,

ConfigItemLookup lookup,

void *table,

bool relaxed,

bool allow_include,

void *userdata) {

_cleanup_free_ char *section = NULL, *continuation = NULL;

_cleanup_fclose_ FILE *ours = NULL;

unsigned line = 0, section_line = 0;

int r;

assert(filename);

assert(lookup);

if (!f) {

f = ours = fopen(filename, "re");

if (!f) {

log_error("Failed to open configuration file '%s': %m", filename);

return -errno;

}

}

fd_warn_permissions(filename, fileno(f));

while (!feof(f)) {

char l[LINE_MAX], *p, *c = NULL, *e;

bool escaped = false;

if (!fgets(l, sizeof(l), f)) {

if (feof(f))

break;

log_error("Failed to read configuration file '%s': %m", filename);

return -errno;

}

truncate_nl(l);

if (continuation) {

c = strappend(continuation, l);

if (!c)

return -ENOMEM;

free(continuation);

continuation = NULL;

p = c;

} else

p = l;

for (e = p; *e; e++) {

if (escaped)

escaped = false;

else if (*e == '\\')

escaped = true;

}

if (escaped) {

*(e-1) = ' ';

if (c)

continuation = c;

else {

continuation = strdup(l);

if (!continuation)

return -ENOMEM;

}

continue;

}

r = parse_line(unit,

filename,

++line,

sections,

lookup,

table,

relaxed,

allow_include,

&section,

&section_line,

p,

userdata);

free(c);

if (r < 0)

return r;

}

return 0;

}

#define DEFINE_PARSER(type, vartype, conv_func) \

int config_parse_##type(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) { \

\

vartype *i = data; \

int r; \

\

assert(filename); \

assert(lvalue); \

assert(rvalue); \

assert(data); \

\

r = conv_func(rvalue, i); \

if (r < 0) \

log_syntax(unit, LOG_ERR, filename, line, -r, \

"Failed to parse %s value, ignoring: %s", \

#vartype, rvalue); \

\

return 0; \

}

DEFINE_PARSER(int, int, safe_atoi)

DEFINE_PARSER(long, long, safe_atoli)

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)

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 = data;

off_t o;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

r = parse_size(rvalue, 1024, &o);

if (r < 0 || (off_t) (size_t) o != o) {

log_syntax(unit, LOG_ERR, filename, line, r < 0 ? -r : ERANGE, "Failed to parse size value, ignoring: %s", rvalue);

return 0;

}

*sz = (size_t) o;

return 0;

}

int config_parse_si_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 = data;

off_t o;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

r = parse_size(rvalue, 1000, &o);

if (r < 0 || (off_t) (size_t) o != o) {

log_syntax(unit, LOG_ERR, filename, line, r < 0 ? -r : ERANGE, "Failed to parse size value, ignoring: %s", rvalue);

return 0;

}

*sz = (size_t) o;

return 0;

}

int config_parse_iec_off(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) {

off_t *bytes = data;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

assert_cc(sizeof(off_t) == sizeof(uint64_t));

r = parse_size(rvalue, 1024, bytes);

if (r < 0)

log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to parse size value, ignoring: %s", rvalue);

return 0;

}

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 = data;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

k = parse_boolean(rvalue);

if (k < 0) {

log_syntax(unit, LOG_ERR, filename, line, -k,

"Failed to parse boolean value, ignoring: %s", rvalue);

return 0;

}

*b = !!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 = data;

char *n;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

n = strdup(rvalue);

if (!n)

return log_oom();

if (!utf8_is_valid(n)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"String is not UTF-8 clean, ignoring assignment: %s", rvalue);

free(n);

return 0;

}

free(*s);

if (*n)

*s = n;

else {

free(n);

*s = NULL;

}

return 0;

}

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

char **s = data;

char *n;

int offset;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (!utf8_is_valid(rvalue)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"Path is not UTF-8 clean, ignoring assignment: %s", rvalue);

return 0;

}

offset = rvalue[0] == '-' && (streq(lvalue, "InaccessibleDirectories") ||

streq(lvalue, "ReadOnlyDirectories"));

if (!path_is_absolute(rvalue + offset)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"Not an absolute path, ignoring: %s", rvalue);

return 0;

}

n = strdup(rvalue);

if (!n)

return log_oom();

path_kill_slashes(n);

free(*s);

*s = n;

return 0;

}

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 = data, *w, *state;

size_t l;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

char **empty;

/* Empty assignment resets the list. As a special rule

empty = strv_new(NULL, NULL);

if (!empty)

return log_oom();

strv_free(*sv);

*sv = empty;

return 0;

}

FOREACH_WORD_QUOTED(w, l, rvalue, state) {

_cleanup_free_ char *n;

n = cunescape_length(w, l);

if (!n)

return log_oom();

if (!utf8_is_valid(n)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"String is not UTF-8 clean, ignoring: %s", rvalue);

continue;

}

r = strv_extend(sv, n);

if (r < 0)

return log_oom();

}

return 0;

}

int config_parse_path_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 = data, *w, *state;

size_t l;

int r;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

/* Empty assignment resets the list */

strv_free(*sv);

*sv = NULL;

return 0;

}

FOREACH_WORD_QUOTED(w, l, rvalue, state) {

_cleanup_free_ char *n;

int offset;

n = strndup(w, l);

if (!n)

return log_oom();

if (!utf8_is_valid(n)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"Path is not UTF-8 clean, ignoring assignment: %s", rvalue);

continue;

}

offset = n[0] == '-' && (streq(lvalue, "InaccessibleDirectories") ||

streq(lvalue, "ReadOnlyDirectories"));

if (!path_is_absolute(n + offset)) {

log_syntax(unit, LOG_ERR, filename, line, EINVAL,

"Not an absolute path, ignoring: %s", rvalue);

continue;

}

path_kill_slashes(n);

r = strv_extend(sv, n);

if (r < 0)

return log_oom();

}

return 0;

}

int config_parse_mode(const char *unit,

const char *filename,

unsigned line,

const char *section,

unsigned section_line,

const char *lvalue,

int ltype,

const char *rvalue,

void *data,

void *userdata) {

mode_t *m = data;

long l;

char *x = NULL;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

errno = 0;

l = strtol(rvalue, &x, 8);

if (!x || x == rvalue || *x || errno) {

log_syntax(unit, LOG_ERR, filename, line, errno,

"Failed to parse mode value, ignoring: %s", rvalue);

return 0;

}

if (l < 0000 || l > 07777) {

log_syntax(unit, LOG_ERR, filename, line, ERANGE,

"Mode value out of range, ignoring: %s", rvalue);

return 0;

}

*m = (mode_t) l;

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_ERR, filename, line, EINVAL,

"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_ERR, filename, line, EINVAL,

"Failed to parse log level, ignoring: %s", rvalue);

return 0;

}

*o = (*o & LOG_FACMASK) | x;

return 0;

}

int config_parse_set_status(const char *unit,

const char *filename,

unsigned line,

const char *section,

unsigned section_line,

const char *lvalue,

int ltype,

const char *rvalue,

void *data,

void *userdata) {

char *w;

size_t l;

char *state;

int r;

ExitStatusSet *status_set = data;

assert(filename);

assert(lvalue);

assert(rvalue);

assert(data);

if (isempty(rvalue)) {

/* Empty assignment resets the list */

set_free(status_set->signal);

set_free(status_set->code);

status_set->signal = status_set->code = NULL;

return 0;

}

FOREACH_WORD(w, l, rvalue, state) {

int val;

char *temp;

temp = strndup(w, l);

if (!temp)

return log_oom();

r = safe_atoi(temp, &val);

if (r < 0) {

val = signal_from_string_try_harder(temp);

free(temp);

if (val > 0) {

r = set_ensure_allocated(&status_set->signal, trivial_hash_func, trivial_compare_func);

if (r < 0)

return log_oom();

r = set_put(status_set->signal, INT_TO_PTR(val));

if (r < 0) {

log_syntax(unit, LOG_ERR, filename, line, -r,

"Unable to store: %s", w);

return r;

}

} else {

log_syntax(unit, LOG_ERR, filename, line, -val,

"Failed to parse value, ignoring: %s", w);

return 0;

}

} else {

free(temp);

if (val < 0 || val > 255)

log_syntax(unit, LOG_ERR, filename, line, ERANGE,

"Value %d is outside range 0-255, ignoring", val);

else {

r = set_ensure_allocated(&status_set->code, trivial_hash_func, trivial_compare_func);

if (r < 0)

return log_oom();

r = set_put(status_set->code, INT_TO_PTR(val));

if (r < 0) {

log_syntax(unit, LOG_ERR, filename, line, -r,

"Unable to store: %s", w);

return r;

}

}

}

}

return 0;

}