mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-21 13:34:40 +03:00
2293567c8c
Add --config for overriding most config file settings from cmdline. Quote arguments when printing command line. Remove linefeed from 'initialising logging' message. Add 'Completed' debug message. Don't attempt library exit after reloading config files. Always compile with libdevmapper, even if device-mapper is disabled.
1121 lines
22 KiB
C
1121 lines
22 KiB
C
/*
|
|
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
|
|
* Copyright (C) 2004 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This file is part of LVM2.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU General Public License v.2.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "lib.h"
|
|
#include "config.h"
|
|
#include "crc.h"
|
|
#include "device.h"
|
|
#include "str_list.h"
|
|
#include "toolcontext.h"
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
|
|
enum {
|
|
TOK_INT,
|
|
TOK_FLOAT,
|
|
TOK_STRING,
|
|
TOK_EQ,
|
|
TOK_SECTION_B,
|
|
TOK_SECTION_E,
|
|
TOK_ARRAY_B,
|
|
TOK_ARRAY_E,
|
|
TOK_IDENTIFIER,
|
|
TOK_COMMA,
|
|
TOK_EOF
|
|
};
|
|
|
|
struct parser {
|
|
const char *fb, *fe; /* file limits */
|
|
|
|
int t; /* token limits and type */
|
|
const char *tb, *te;
|
|
|
|
int fd; /* descriptor for file being parsed */
|
|
int line; /* line number we are on */
|
|
|
|
struct dm_pool *mem;
|
|
};
|
|
|
|
struct cs {
|
|
struct config_tree cft;
|
|
struct dm_pool *mem;
|
|
time_t timestamp;
|
|
char *filename;
|
|
int exists;
|
|
};
|
|
|
|
static void _get_token(struct parser *p, int tok_prev);
|
|
static void _eat_space(struct parser *p);
|
|
static struct config_node *_file(struct parser *p);
|
|
static struct config_node *_section(struct parser *p);
|
|
static struct config_value *_value(struct parser *p);
|
|
static struct config_value *_type(struct parser *p);
|
|
static int _match_aux(struct parser *p, int t);
|
|
static struct config_value *_create_value(struct parser *p);
|
|
static struct config_node *_create_node(struct parser *p);
|
|
static char *_dup_tok(struct parser *p);
|
|
|
|
static const int sep = '/';
|
|
|
|
#define MAX_INDENT 32
|
|
|
|
#define match(t) do {\
|
|
if (!_match_aux(p, (t))) {\
|
|
log_error("Parse error at byte %d (line %d): unexpected token", p->tb - p->fb + 1, p->line); \
|
|
return 0;\
|
|
} \
|
|
} while(0);
|
|
|
|
static int _tok_match(const char *str, const char *b, const char *e)
|
|
{
|
|
while (*str && (b != e)) {
|
|
if (*str++ != *b++)
|
|
return 0;
|
|
}
|
|
|
|
return !(*str || (b != e));
|
|
}
|
|
|
|
/*
|
|
* public interface
|
|
*/
|
|
struct config_tree *create_config_tree(const char *filename)
|
|
{
|
|
struct cs *c;
|
|
struct dm_pool *mem = dm_pool_create("config", 10 * 1024);
|
|
|
|
if (!mem) {
|
|
log_error("Failed to allocate config pool.");
|
|
return 0;
|
|
}
|
|
|
|
if (!(c = dm_pool_zalloc(mem, sizeof(*c)))) {
|
|
log_error("Failed to allocate config tree.");
|
|
dm_pool_destroy(mem);
|
|
return 0;
|
|
}
|
|
|
|
c->mem = mem;
|
|
c->cft.root = (struct config_node *) NULL;
|
|
c->timestamp = 0;
|
|
c->exists = 0;
|
|
if (filename)
|
|
c->filename = dm_pool_strdup(c->mem, filename);
|
|
return &c->cft;
|
|
}
|
|
|
|
void destroy_config_tree(struct config_tree *cft)
|
|
{
|
|
dm_pool_destroy(((struct cs *) cft)->mem);
|
|
}
|
|
|
|
static int _parse_config_file(struct parser *p, struct config_tree *cft)
|
|
{
|
|
p->tb = p->te = p->fb;
|
|
p->line = 1;
|
|
_get_token(p, TOK_SECTION_E);
|
|
if (!(cft->root = _file(p)))
|
|
return_0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
struct config_tree *create_config_tree_from_string(struct cmd_context *cmd,
|
|
const char *config_settings)
|
|
{
|
|
struct cs *c;
|
|
struct config_tree *cft;
|
|
struct parser *p;
|
|
|
|
if (!(cft = create_config_tree(NULL)))
|
|
return_NULL;
|
|
|
|
c = (struct cs *) cft;
|
|
if (!(p = dm_pool_alloc(c->mem, sizeof(*p)))) {
|
|
log_error("Failed to allocate config tree parser.");
|
|
destroy_config_tree(cft);
|
|
return NULL;
|
|
}
|
|
|
|
p->mem = c->mem;
|
|
p->fb = config_settings;
|
|
p->fe = config_settings + strlen(config_settings);
|
|
|
|
if (!_parse_config_file(p, cft)) {
|
|
destroy_config_tree(cft);
|
|
return_NULL;
|
|
}
|
|
|
|
return cft;
|
|
}
|
|
|
|
int read_config_fd(struct config_tree *cft, struct device *dev,
|
|
off_t offset, size_t size, off_t offset2, size_t size2,
|
|
checksum_fn_t checksum_fn, uint32_t checksum)
|
|
{
|
|
struct cs *c = (struct cs *) cft;
|
|
struct parser *p;
|
|
int r = 0;
|
|
int use_mmap = 1;
|
|
off_t mmap_offset = 0;
|
|
char *buf;
|
|
|
|
if (!(p = dm_pool_alloc(c->mem, sizeof(*p)))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
p->mem = c->mem;
|
|
|
|
/* Only use mmap with regular files */
|
|
if (!(dev->flags & DEV_REGULAR) || size2)
|
|
use_mmap = 0;
|
|
|
|
if (use_mmap) {
|
|
mmap_offset = offset % getpagesize();
|
|
/* memory map the file */
|
|
p->fb = mmap((caddr_t) 0, size + mmap_offset, PROT_READ,
|
|
MAP_PRIVATE, dev_fd(dev), offset - mmap_offset);
|
|
if (p->fb == (caddr_t) (-1)) {
|
|
log_sys_error("mmap", dev_name(dev));
|
|
goto out;
|
|
}
|
|
p->fb = p->fb + mmap_offset;
|
|
} else {
|
|
if (!(buf = dm_malloc(size + size2))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
if (!dev_read(dev, (uint64_t) offset, size, buf)) {
|
|
log_error("Read from %s failed", dev_name(dev));
|
|
goto out;
|
|
}
|
|
if (size2) {
|
|
if (!dev_read(dev, (uint64_t) offset2, size2,
|
|
buf + size)) {
|
|
log_error("Circular read from %s failed",
|
|
dev_name(dev));
|
|
goto out;
|
|
}
|
|
}
|
|
p->fb = buf;
|
|
}
|
|
|
|
if (checksum_fn && checksum !=
|
|
(checksum_fn(checksum_fn(INITIAL_CRC, p->fb, size),
|
|
p->fb + size, size2))) {
|
|
log_error("%s: Checksum error", dev_name(dev));
|
|
goto out;
|
|
}
|
|
|
|
p->fe = p->fb + size + size2;
|
|
|
|
if (!_parse_config_file(p, cft)) {
|
|
stack;
|
|
goto out;
|
|
}
|
|
|
|
r = 1;
|
|
|
|
out:
|
|
if (!use_mmap)
|
|
dm_free(buf);
|
|
else {
|
|
/* unmap the file */
|
|
if (munmap((char *) (p->fb - mmap_offset), size + mmap_offset)) {
|
|
log_sys_error("munmap", dev_name(dev));
|
|
r = 0;
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
int read_config_file(struct config_tree *cft)
|
|
{
|
|
struct cs *c = (struct cs *) cft;
|
|
struct stat info;
|
|
struct device *dev;
|
|
int r = 1;
|
|
|
|
if (stat(c->filename, &info)) {
|
|
log_sys_error("stat", c->filename);
|
|
c->exists = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (!S_ISREG(info.st_mode)) {
|
|
log_error("%s is not a regular file", c->filename);
|
|
c->exists = 0;
|
|
return 0;
|
|
}
|
|
|
|
c->exists = 1;
|
|
|
|
if (info.st_size == 0) {
|
|
log_verbose("%s is empty", c->filename);
|
|
return 1;
|
|
}
|
|
|
|
if (!(dev = dev_create_file(c->filename, NULL, NULL, 1))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
r = read_config_fd(cft, dev, 0, (size_t) info.st_size, 0, 0,
|
|
(checksum_fn_t) NULL, 0);
|
|
|
|
dev_close(dev);
|
|
|
|
c->timestamp = info.st_mtime;
|
|
|
|
return r;
|
|
}
|
|
|
|
time_t config_file_timestamp(struct config_tree *cft)
|
|
{
|
|
struct cs *c = (struct cs *) cft;
|
|
|
|
return c->timestamp;
|
|
}
|
|
|
|
/*
|
|
* Return 1 if config files ought to be reloaded
|
|
*/
|
|
int config_file_changed(struct config_tree *cft)
|
|
{
|
|
struct cs *c = (struct cs *) cft;
|
|
struct stat info;
|
|
|
|
if (!c->filename)
|
|
return 0;
|
|
|
|
if (stat(c->filename, &info) == -1) {
|
|
/* Ignore a deleted config file: still use original data */
|
|
if (errno == ENOENT) {
|
|
if (!c->exists)
|
|
return 0;
|
|
log_very_verbose("Config file %s has disappeared!",
|
|
c->filename);
|
|
goto reload;
|
|
}
|
|
log_sys_error("stat", c->filename);
|
|
log_error("Failed to reload configuration files");
|
|
return 0;
|
|
}
|
|
|
|
if (!S_ISREG(info.st_mode)) {
|
|
log_error("Configuration file %s is not a regular file",
|
|
c->filename);
|
|
goto reload;
|
|
}
|
|
|
|
/* Unchanged? */
|
|
if (c->timestamp == info.st_mtime)
|
|
return 0;
|
|
|
|
reload:
|
|
log_verbose("Detected config file change to %s", c->filename);
|
|
return 1;
|
|
}
|
|
|
|
static void _write_value(FILE *fp, struct config_value *v)
|
|
{
|
|
switch (v->type) {
|
|
case CFG_STRING:
|
|
fprintf(fp, "\"%s\"", v->v.str);
|
|
break;
|
|
|
|
case CFG_FLOAT:
|
|
fprintf(fp, "%f", v->v.r);
|
|
break;
|
|
|
|
case CFG_INT:
|
|
fprintf(fp, "%d", v->v.i);
|
|
break;
|
|
|
|
case CFG_EMPTY_ARRAY:
|
|
fprintf(fp, "[]");
|
|
break;
|
|
|
|
default:
|
|
log_error("_write_value: Unknown value type: %d", v->type);
|
|
|
|
}
|
|
}
|
|
|
|
static int _write_config(struct config_node *n, FILE *fp, int level)
|
|
{
|
|
char space[MAX_INDENT + 1];
|
|
int l = (level < MAX_INDENT) ? level : MAX_INDENT;
|
|
int i;
|
|
|
|
if (!n)
|
|
return 1;
|
|
|
|
for (i = 0; i < l; i++)
|
|
space[i] = '\t';
|
|
space[i] = '\0';
|
|
|
|
while (n) {
|
|
fprintf(fp, "%s%s", space, n->key);
|
|
if (!n->v) {
|
|
/* it's a sub section */
|
|
fprintf(fp, " {\n");
|
|
_write_config(n->child, fp, level + 1);
|
|
fprintf(fp, "%s}", space);
|
|
} else {
|
|
/* it's a value */
|
|
struct config_value *v = n->v;
|
|
fprintf(fp, "=");
|
|
if (v->next) {
|
|
fprintf(fp, "[");
|
|
while (v) {
|
|
_write_value(fp, v);
|
|
v = v->next;
|
|
if (v)
|
|
fprintf(fp, ", ");
|
|
}
|
|
fprintf(fp, "]");
|
|
} else
|
|
_write_value(fp, v);
|
|
}
|
|
fprintf(fp, "\n");
|
|
n = n->sib;
|
|
}
|
|
/* FIXME: add error checking */
|
|
return 1;
|
|
}
|
|
|
|
int write_config_file(struct config_tree *cft, const char *file)
|
|
{
|
|
int r = 1;
|
|
FILE *fp;
|
|
|
|
if (!file) {
|
|
fp = stdout;
|
|
file = "stdout";
|
|
} else if (!(fp = fopen(file, "w"))) {
|
|
log_sys_error("open", file);
|
|
return 0;
|
|
}
|
|
|
|
log_verbose("Dumping configuration to %s", file);
|
|
if (!_write_config(cft->root, fp, 0)) {
|
|
log_error("Failure while writing configuration");
|
|
r = 0;
|
|
}
|
|
|
|
if (fp != stdout)
|
|
fclose(fp);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* parser
|
|
*/
|
|
static struct config_node *_file(struct parser *p)
|
|
{
|
|
struct config_node *root = NULL, *n, *l = NULL;
|
|
while (p->t != TOK_EOF) {
|
|
if (!(n = _section(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (!root)
|
|
root = n;
|
|
else
|
|
l->sib = n;
|
|
l = n;
|
|
}
|
|
return root;
|
|
}
|
|
|
|
static struct config_node *_section(struct parser *p)
|
|
{
|
|
/* IDENTIFIER '{' VALUE* '}' */
|
|
struct config_node *root, *n, *l = NULL;
|
|
if (!(root = _create_node(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (!(root->key = _dup_tok(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
match(TOK_IDENTIFIER);
|
|
|
|
if (p->t == TOK_SECTION_B) {
|
|
match(TOK_SECTION_B);
|
|
while (p->t != TOK_SECTION_E) {
|
|
if (!(n = _section(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (!root->child)
|
|
root->child = n;
|
|
else
|
|
l->sib = n;
|
|
l = n;
|
|
}
|
|
match(TOK_SECTION_E);
|
|
} else {
|
|
match(TOK_EQ);
|
|
if (!(root->v = _value(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return root;
|
|
}
|
|
|
|
static struct config_value *_value(struct parser *p)
|
|
{
|
|
/* '[' TYPE* ']' | TYPE */
|
|
struct config_value *h = NULL, *l, *ll = NULL;
|
|
if (p->t == TOK_ARRAY_B) {
|
|
match(TOK_ARRAY_B);
|
|
while (p->t != TOK_ARRAY_E) {
|
|
if (!(l = _type(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
|
|
if (!h)
|
|
h = l;
|
|
else
|
|
ll->next = l;
|
|
ll = l;
|
|
|
|
if (p->t == TOK_COMMA)
|
|
match(TOK_COMMA);
|
|
}
|
|
match(TOK_ARRAY_E);
|
|
/*
|
|
* Special case for an empty array.
|
|
*/
|
|
if (!h) {
|
|
if (!(h = _create_value(p)))
|
|
return NULL;
|
|
|
|
h->type = CFG_EMPTY_ARRAY;
|
|
}
|
|
|
|
} else
|
|
h = _type(p);
|
|
|
|
return h;
|
|
}
|
|
|
|
static struct config_value *_type(struct parser *p)
|
|
{
|
|
/* [+-]{0,1}[0-9]+ | [0-9]*\.[0-9]* | ".*" */
|
|
struct config_value *v = _create_value(p);
|
|
|
|
if (!v)
|
|
return NULL;
|
|
|
|
switch (p->t) {
|
|
case TOK_INT:
|
|
v->type = CFG_INT;
|
|
v->v.i = strtol(p->tb, NULL, 0); /* FIXME: check error */
|
|
match(TOK_INT);
|
|
break;
|
|
|
|
case TOK_FLOAT:
|
|
v->type = CFG_FLOAT;
|
|
v->v.r = strtod(p->tb, NULL); /* FIXME: check error */
|
|
match(TOK_FLOAT);
|
|
break;
|
|
|
|
case TOK_STRING:
|
|
v->type = CFG_STRING;
|
|
|
|
p->tb++, p->te--; /* strip "'s */
|
|
if (!(v->v.str = _dup_tok(p))) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
p->te++;
|
|
match(TOK_STRING);
|
|
break;
|
|
|
|
default:
|
|
log_error("Parse error at byte %d (line %d): expected a value", p->tb - p->fb + 1, p->line);
|
|
return 0;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static int _match_aux(struct parser *p, int t)
|
|
{
|
|
if (p->t != t)
|
|
return 0;
|
|
|
|
_get_token(p, t);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* tokeniser
|
|
*/
|
|
static void _get_token(struct parser *p, int tok_prev)
|
|
{
|
|
int values_allowed = 0;
|
|
|
|
p->tb = p->te;
|
|
_eat_space(p);
|
|
if (p->tb == p->fe || !*p->tb) {
|
|
p->t = TOK_EOF;
|
|
return;
|
|
}
|
|
|
|
/* Should next token be interpreted as value instead of identifier? */
|
|
if (tok_prev == TOK_EQ || tok_prev == TOK_ARRAY_B ||
|
|
tok_prev == TOK_COMMA)
|
|
values_allowed = 1;
|
|
|
|
p->t = TOK_INT; /* fudge so the fall through for
|
|
floats works */
|
|
switch (*p->te) {
|
|
case '{':
|
|
p->t = TOK_SECTION_B;
|
|
p->te++;
|
|
break;
|
|
|
|
case '}':
|
|
p->t = TOK_SECTION_E;
|
|
p->te++;
|
|
break;
|
|
|
|
case '[':
|
|
p->t = TOK_ARRAY_B;
|
|
p->te++;
|
|
break;
|
|
|
|
case ']':
|
|
p->t = TOK_ARRAY_E;
|
|
p->te++;
|
|
break;
|
|
|
|
case ',':
|
|
p->t = TOK_COMMA;
|
|
p->te++;
|
|
break;
|
|
|
|
case '=':
|
|
p->t = TOK_EQ;
|
|
p->te++;
|
|
break;
|
|
|
|
case '"':
|
|
p->t = TOK_STRING;
|
|
p->te++;
|
|
while ((p->te != p->fe) && (*p->te) && (*p->te != '"')) {
|
|
if ((*p->te == '\\') && (p->te + 1 != p->fe) &&
|
|
*(p->te + 1))
|
|
p->te++;
|
|
p->te++;
|
|
}
|
|
|
|
if ((p->te != p->fe) && (*p->te))
|
|
p->te++;
|
|
break;
|
|
|
|
case '\'':
|
|
p->t = TOK_STRING;
|
|
p->te++;
|
|
while ((p->te != p->fe) && (*p->te) && (*p->te != '\''))
|
|
p->te++;
|
|
|
|
if ((p->te != p->fe) && (*p->te))
|
|
p->te++;
|
|
break;
|
|
|
|
case '.':
|
|
p->t = TOK_FLOAT;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case '+':
|
|
case '-':
|
|
if (values_allowed) {
|
|
p->te++;
|
|
while ((p->te != p->fe) && (*p->te)) {
|
|
if (*p->te == '.') {
|
|
if (p->t == TOK_FLOAT)
|
|
break;
|
|
p->t = TOK_FLOAT;
|
|
} else if (!isdigit((int) *p->te))
|
|
break;
|
|
p->te++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
p->t = TOK_IDENTIFIER;
|
|
while ((p->te != p->fe) && (*p->te) && !isspace(*p->te) &&
|
|
(*p->te != '#') && (*p->te != '=') && (*p->te != '{') &&
|
|
(*p->te != '}'))
|
|
p->te++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void _eat_space(struct parser *p)
|
|
{
|
|
while ((p->tb != p->fe) && (*p->tb)) {
|
|
if (*p->te == '#') {
|
|
while ((p->te != p->fe) && (*p->te) && (*p->te != '\n'))
|
|
p->te++;
|
|
p->line++;
|
|
}
|
|
|
|
else if (isspace(*p->te)) {
|
|
while ((p->te != p->fe) && (*p->te) && isspace(*p->te)) {
|
|
if (*p->te == '\n')
|
|
p->line++;
|
|
p->te++;
|
|
}
|
|
}
|
|
|
|
else
|
|
return;
|
|
|
|
p->tb = p->te;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* memory management
|
|
*/
|
|
static struct config_value *_create_value(struct parser *p)
|
|
{
|
|
struct config_value *v = dm_pool_alloc(p->mem, sizeof(*v));
|
|
|
|
if (v)
|
|
memset(v, 0, sizeof(*v));
|
|
|
|
return v;
|
|
}
|
|
|
|
static struct config_node *_create_node(struct parser *p)
|
|
{
|
|
struct config_node *n = dm_pool_alloc(p->mem, sizeof(*n));
|
|
|
|
if (n)
|
|
memset(n, 0, sizeof(*n));
|
|
|
|
return n;
|
|
}
|
|
|
|
static char *_dup_tok(struct parser *p)
|
|
{
|
|
size_t len = p->te - p->tb;
|
|
char *str = dm_pool_alloc(p->mem, len + 1);
|
|
if (!str) {
|
|
stack;
|
|
return 0;
|
|
}
|
|
strncpy(str, p->tb, len);
|
|
str[len] = '\0';
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
* utility functions
|
|
*/
|
|
static struct config_node *_find_config_node(const struct config_node *cn,
|
|
const char *path)
|
|
{
|
|
const char *e;
|
|
|
|
while (cn) {
|
|
/* trim any leading slashes */
|
|
while (*path && (*path == sep))
|
|
path++;
|
|
|
|
/* find the end of this segment */
|
|
for (e = path; *e && (*e != sep); e++) ;
|
|
|
|
/* hunt for the node */
|
|
while (cn) {
|
|
if (_tok_match(cn->key, path, e))
|
|
break;
|
|
|
|
cn = cn->sib;
|
|
}
|
|
|
|
if (cn && *e)
|
|
cn = cn->child;
|
|
else
|
|
break; /* don't move into the last node */
|
|
|
|
path = e;
|
|
}
|
|
|
|
return (struct config_node *) cn;
|
|
}
|
|
|
|
static struct config_node *_find_first_config_node(const struct config_node *cn1,
|
|
const struct config_node *cn2,
|
|
const char *path)
|
|
{
|
|
struct config_node *cn;
|
|
|
|
if (cn1 && (cn = _find_config_node(cn1, path)))
|
|
return cn;
|
|
|
|
if (cn2 && (cn = _find_config_node(cn2, path)))
|
|
return cn;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
struct config_node *find_config_node(const struct config_node *cn,
|
|
const char *path)
|
|
{
|
|
return _find_config_node(cn, path);
|
|
}
|
|
|
|
static const char *_find_config_str(const struct config_node *cn1,
|
|
const struct config_node *cn2,
|
|
const char *path, const char *fail)
|
|
{
|
|
const struct config_node *n = _find_first_config_node(cn1, cn2, path);
|
|
|
|
/* Empty strings are ignored */
|
|
if ((n && n->v->type == CFG_STRING) && (*n->v->v.str)) {
|
|
log_very_verbose("Setting %s to %s", path, n->v->v.str);
|
|
return n->v->v.str;
|
|
}
|
|
|
|
if (fail)
|
|
log_very_verbose("%s not found in config: defaulting to %s",
|
|
path, fail);
|
|
return fail;
|
|
}
|
|
|
|
const char *find_config_str(const struct config_node *cn,
|
|
const char *path, const char *fail)
|
|
{
|
|
return _find_config_str(cn, NULL, path, fail);
|
|
}
|
|
|
|
static int _find_config_int(const struct config_node *cn1,
|
|
const struct config_node *cn2,
|
|
const char *path, int fail)
|
|
{
|
|
const struct config_node *n = _find_first_config_node(cn1, cn2, path);
|
|
|
|
if (n && n->v->type == CFG_INT) {
|
|
log_very_verbose("Setting %s to %d", path, n->v->v.i);
|
|
return n->v->v.i;
|
|
}
|
|
|
|
log_very_verbose("%s not found in config: defaulting to %d",
|
|
path, fail);
|
|
return fail;
|
|
}
|
|
|
|
int find_config_int(const struct config_node *cn, const char *path, int fail)
|
|
{
|
|
return _find_config_int(cn, NULL, path, fail);
|
|
}
|
|
|
|
static float _find_config_float(const struct config_node *cn1,
|
|
const struct config_node *cn2,
|
|
const char *path, float fail)
|
|
{
|
|
const struct config_node *n = _find_first_config_node(cn1, cn2, path);
|
|
|
|
if (n && n->v->type == CFG_FLOAT) {
|
|
log_very_verbose("Setting %s to %f", path, n->v->v.r);
|
|
return n->v->v.r;
|
|
}
|
|
|
|
log_very_verbose("%s not found in config: defaulting to %f",
|
|
path, fail);
|
|
|
|
return fail;
|
|
|
|
}
|
|
|
|
float find_config_float(const struct config_node *cn, const char *path,
|
|
float fail)
|
|
{
|
|
return _find_config_float(cn, NULL, path, fail);
|
|
}
|
|
|
|
struct config_node *find_config_tree_node(struct cmd_context *cmd,
|
|
const char *path)
|
|
{
|
|
return _find_first_config_node(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path);
|
|
}
|
|
|
|
const char *find_config_tree_str(struct cmd_context *cmd,
|
|
const char *path, const char *fail)
|
|
{
|
|
return _find_config_str(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
|
|
}
|
|
|
|
int find_config_tree_int(struct cmd_context *cmd, const char *path,
|
|
int fail)
|
|
{
|
|
return _find_config_int(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
|
|
}
|
|
|
|
float find_config_tree_float(struct cmd_context *cmd, const char *path,
|
|
float fail)
|
|
{
|
|
return _find_config_float(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
|
|
}
|
|
|
|
static int _str_in_array(const char *str, const char *values[])
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; values[i]; i++)
|
|
if (!strcasecmp(str, values[i]))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int _str_to_bool(const char *str, int fail)
|
|
{
|
|
static const char *_true_values[] = { "y", "yes", "on", "true", NULL };
|
|
static const char *_false_values[] =
|
|
{ "n", "no", "off", "false", NULL };
|
|
|
|
if (_str_in_array(str, _true_values))
|
|
return 1;
|
|
|
|
if (_str_in_array(str, _false_values))
|
|
return 0;
|
|
|
|
return fail;
|
|
}
|
|
|
|
static int _find_config_bool(const struct config_node *cn1,
|
|
const struct config_node *cn2,
|
|
const char *path, int fail)
|
|
{
|
|
const struct config_node *n = _find_first_config_node(cn1, cn2, path);
|
|
struct config_value *v;
|
|
|
|
if (!n)
|
|
return fail;
|
|
|
|
v = n->v;
|
|
|
|
switch (v->type) {
|
|
case CFG_INT:
|
|
return v->v.i ? 1 : 0;
|
|
|
|
case CFG_STRING:
|
|
return _str_to_bool(v->v.str, fail);
|
|
}
|
|
|
|
return fail;
|
|
}
|
|
|
|
int find_config_bool(const struct config_node *cn, const char *path, int fail)
|
|
{
|
|
return _find_config_bool(cn, NULL, path, fail);
|
|
}
|
|
|
|
int find_config_tree_bool(struct cmd_context *cmd, const char *path, int fail)
|
|
{
|
|
return _find_config_bool(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
|
|
}
|
|
|
|
int get_config_uint32(const struct config_node *cn, const char *path,
|
|
uint32_t *result)
|
|
{
|
|
const struct config_node *n;
|
|
|
|
n = find_config_node(cn, path);
|
|
|
|
if (!n || !n->v || n->v->type != CFG_INT)
|
|
return 0;
|
|
|
|
*result = n->v->v.i;
|
|
return 1;
|
|
}
|
|
|
|
int get_config_uint64(const struct config_node *cn, const char *path,
|
|
uint64_t *result)
|
|
{
|
|
const struct config_node *n;
|
|
|
|
n = find_config_node(cn, path);
|
|
|
|
if (!n || !n->v || n->v->type != CFG_INT)
|
|
return 0;
|
|
|
|
/* FIXME Support 64-bit value! */
|
|
*result = (uint64_t) n->v->v.i;
|
|
return 1;
|
|
}
|
|
|
|
int get_config_str(const struct config_node *cn, const char *path,
|
|
char **result)
|
|
{
|
|
const struct config_node *n;
|
|
|
|
n = find_config_node(cn, path);
|
|
|
|
if (!n || !n->v || n->v->type != CFG_STRING)
|
|
return 0;
|
|
|
|
*result = n->v->v.str;
|
|
return 1;
|
|
}
|
|
|
|
/* Insert cn2 after cn1 */
|
|
static void _insert_config_node(struct config_node **cn1,
|
|
struct config_node *cn2)
|
|
{
|
|
if (!*cn1) {
|
|
*cn1 = cn2;
|
|
cn2->sib = NULL;
|
|
} else {
|
|
cn2->sib = (*cn1)->sib;
|
|
(*cn1)->sib = cn2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Merge section cn2 into section cn1 (which has the same name)
|
|
* overwriting any existing cn1 nodes with matching names.
|
|
*/
|
|
static void _merge_section(struct config_node *cn1, struct config_node *cn2)
|
|
{
|
|
struct config_node *cn, *nextn, *oldn;
|
|
struct config_value *cv;
|
|
|
|
for (cn = cn2->child; cn; cn = nextn) {
|
|
nextn = cn->sib;
|
|
|
|
/* Skip "tags" */
|
|
if (!strcmp(cn->key, "tags"))
|
|
continue;
|
|
|
|
/* Subsection? */
|
|
if (!cn->v)
|
|
/* Ignore - we don't have any of these yet */
|
|
continue;
|
|
/* Not already present? */
|
|
if (!(oldn = find_config_node(cn1->child, cn->key))) {
|
|
_insert_config_node(&cn1->child, cn);
|
|
continue;
|
|
}
|
|
/* Merge certain value lists */
|
|
if ((!strcmp(cn1->key, "activation") &&
|
|
!strcmp(cn->key, "volume_list")) ||
|
|
(!strcmp(cn1->key, "devices") &&
|
|
(!strcmp(cn->key, "filter") || !strcmp(cn->key, "types")))) {
|
|
cv = cn->v;
|
|
while (cv->next)
|
|
cv = cv->next;
|
|
cv->next = oldn->v;
|
|
}
|
|
|
|
/* Replace values */
|
|
oldn->v = cn->v;
|
|
}
|
|
}
|
|
|
|
static int _match_host_tags(struct list *tags, struct config_node *tn)
|
|
{
|
|
struct config_value *tv;
|
|
const char *str;
|
|
|
|
for (tv = tn->v; tv; tv = tv->next) {
|
|
if (tv->type != CFG_STRING)
|
|
continue;
|
|
str = tv->v.str;
|
|
if (*str == '@')
|
|
str++;
|
|
if (!*str)
|
|
continue;
|
|
if (str_list_match_item(tags, str))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Destructively merge a new config tree into an existing one */
|
|
int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
|
|
struct config_tree *newdata)
|
|
{
|
|
struct config_node *root = cft->root;
|
|
struct config_node *cn, *nextn, *oldn, *tn, *cn2;
|
|
|
|
for (cn = newdata->root; cn; cn = nextn) {
|
|
nextn = cn->sib;
|
|
/* Ignore tags section */
|
|
if (!strcmp(cn->key, "tags"))
|
|
continue;
|
|
/* If there's a tags node, skip if host tags don't match */
|
|
if ((tn = find_config_node(cn->child, "tags"))) {
|
|
if (!_match_host_tags(&cmd->tags, tn))
|
|
continue;
|
|
}
|
|
if (!(oldn = find_config_node(root, cn->key))) {
|
|
_insert_config_node(&cft->root, cn);
|
|
/* Remove any "tags" nodes */
|
|
for (cn2 = cn->child; cn2; cn2 = cn2->sib) {
|
|
if (!strcmp(cn2->key, "tags")) {
|
|
cn->child = cn2->sib;
|
|
continue;
|
|
}
|
|
if (cn2->sib && !strcmp(cn2->sib->key, "tags")) {
|
|
cn2->sib = cn2->sib->sib;
|
|
continue;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
_merge_section(oldn, cn);
|
|
}
|
|
|
|
return 1;
|
|
}
|