libvirt/src/util/virconf.c

1619 lines
42 KiB
C
Raw Normal View History

2012-12-12 16:35:35 +00:00
/*
* virconf.c: parser for a subset of the Python encoded Xen configuration files
*
* Copyright (C) 2006-2014 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
* Daniel Veillard <veillard@redhat.com>
*/
#include <config.h>
Use gnulib, starting with its physmem and getaddrinfo modules. New files go into these directories: gnulib/lib gnulib/m4 gnulib/tests * bootstrap: A wrapper around gnulib-tool. * configure.in: Invoke gl_EARLY and gl_INIT, being careful to put gl_EARLY before any macro that uses AC_COMPILE_IFELSE. (AC_OUTPUT): Add lib/Makefile and gl-tests/Makefile. Remove m4/Makefile. * Makefile.am (SUBDIRS): Add gnulib/lib and remove m4. Add gnulib/tests early enough that those tests run before any libvirt unit tests. * m4/Makefile.am: Remove file. Not needed. * src/Makefile.am (INCLUDES): Add -I$(top_srcdir)/gnulib/lib -I../gnulib/lib. (LDADDS, libvirt_la_LIBADD): Add ../gnulib/lib/libgnu.la. * src/nodeinfo.c: Include "physmem.h". * qemud/qemud.c, src/remote_internal.c: Include "getaddrinfo.h". (MEMINFO_PATH, linuxNodeInfoMemPopulate): Remove definitions. (virNodeInfoPopulate): Use physmem_total, not linuxNodeInfoMemPopulate. * tests/Makefile.am (INCLUDES): Add -I$(top_srcdir)/gnulib/lib -I../gnulib/lib. (LDADDS): Add ../gnulib/lib/libgnu.la. * qemud/Makefile.am (libvirtd_LDADD): Add ../gnulib/lib/libgnu.la. * tests/nodeinfotest.c (linuxTestCompareFiles): No longer read total memory from a file. Update expected output not to include "Memory: NNNN" * tests/nodeinfodata/linux-nodeinfo-1.txt: * tests/nodeinfodata/linux-nodeinfo-2.txt: * tests/nodeinfodata/linux-nodeinfo-3.txt: * tests/nodeinfodata/linux-nodeinfo-4.txt: * tests/nodeinfodata/linux-nodeinfo-5.txt: * tests/nodeinfodata/linux-nodeinfo-6.txt: * src/test.c [WITH_TEST]: Remove definition of _GNU_SOURCE that would conflict with the one now in "config.h". * autogen.sh: Add -I gnulib/m4. * src/conf.c, src/sexpr.c: Don't define _GNU_SOURCE. Instead, include "config.h". * qemud/qemud.c: Remove definition of _GNU_SOURCE. * src/openvz_driver.c: Likewise. * src/qemu_driver.c: Likewise. * src/remote_internal.c: Likewise. * configure.in: Use AC_CONFIG_AUX_DIR(build-aux), so that a bunch of gettextize-generated files go into build-aux/, rather than in the top-level directory. * .cvsignore: Adjust. * build-aux/.cvsignore: New file. Author: Jim Meyering <meyering@redhat.com>
2007-12-05 21:31:07 +00:00
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "virerror.h"
#include "virbuffer.h"
2012-12-12 16:35:35 +00:00
#include "virconf.h"
2012-12-13 17:44:57 +00:00
#include "virutil.h"
#include "c-ctype.h"
2012-12-12 17:59:27 +00:00
#include "virlog.h"
2012-12-12 18:06:53 +00:00
#include "viralloc.h"
#include "virfile.h"
#include "virstring.h"
#include "configmake.h"
#define VIR_FROM_THIS VIR_FROM_CONF
VIR_LOG_INIT("util.conf");
/************************************************************************
* *
* Structures and macros used by the mini parser *
* *
************************************************************************/
typedef struct _virConfParserCtxt virConfParserCtxt;
typedef virConfParserCtxt *virConfParserCtxtPtr;
struct _virConfParserCtxt {
const char* filename;
const char* base;
const char* cur;
const char *end;
int line;
virConfPtr conf;
};
#define CUR (*ctxt->cur)
#define NEXT if (ctxt->cur < ctxt->end) ctxt->cur++;
#define IS_EOL(c) (((c) == '\n') || ((c) == '\r'))
#define SKIP_BLANKS_AND_EOL \
do { while ((ctxt->cur < ctxt->end) && (c_isblank(CUR) || IS_EOL(CUR))) { \
if (CUR == '\n') ctxt->line++; \
ctxt->cur++; } } while (0)
#define SKIP_BLANKS \
do { while ((ctxt->cur < ctxt->end) && (c_isblank(CUR))) \
ctxt->cur++; } while (0)
/************************************************************************
* *
* Structures used by configuration data *
* *
************************************************************************/
VIR_ENUM_IMPL(virConf, VIR_CONF_LAST,
"*unexpected*",
"long",
"unsigned long",
"string",
"list");
typedef struct _virConfEntry virConfEntry;
typedef virConfEntry *virConfEntryPtr;
struct _virConfEntry {
virConfEntryPtr next;
char* name;
char* comment;
virConfValuePtr value;
};
struct _virConf {
char *filename;
unsigned int flags;
virConfEntryPtr entries;
};
/**
* virConfError:
* @ctxt: the parser context if available or NULL
* @error: the error number
* @info: extra information string
*
* Handle an error at the xend daemon interface
*/
#define virConfError(ctxt, error, info) \
virConfErrorHelper(__FILE__, __FUNCTION__, __LINE__, ctxt, error, info)
static void
virConfErrorHelper(const char *file, const char *func, size_t line,
virConfParserCtxtPtr ctxt,
virErrorNumber error, const char *info)
{
if (error == VIR_ERR_OK)
return;
/* Construct the string 'filename:line: info' if we have that. */
if (ctxt && ctxt->filename) {
virReportErrorHelper(VIR_FROM_CONF, error, file, func, line,
_("%s:%d: %s"), ctxt->filename, ctxt->line, info);
} else {
virReportErrorHelper(VIR_FROM_CONF, error, file, func, line,
"%s", info);
}
}
/************************************************************************
* *
* Structures allocations and deallocations *
* *
************************************************************************/
/**
* virConfFreeList:
* @list: the list to free
*
* Free a list
*/
static void
virConfFreeList(virConfValuePtr list)
{
virConfValuePtr next;
while (list != NULL) {
next = list->next;
list->next = NULL;
virConfFreeValue(list);
list = next;
}
}
/**
* virConfFreeValue:
* @val: the value to free
*
* Free a value
*/
void
2008-11-17 11:03:25 +00:00
virConfFreeValue(virConfValuePtr val)
{
if (val == NULL)
return;
if (val->type == VIR_CONF_STRING &&
val->str != NULL)
VIR_FREE(val->str);
if (val->type == VIR_CONF_LIST &&
val->list != NULL)
virConfFreeList(val->list);
VIR_FREE(val);
}
2007-03-09 20:47:12 +00:00
virConfPtr
2008-11-17 11:03:25 +00:00
virConfNew(void)
{
virConfPtr ret;
if (VIR_ALLOC(ret) < 0)
return NULL;
ret->filename = NULL;
ret->flags = 0;
return ret;
}
/**
* virConfCreate:
* @filename: the name to report errors
* @flags: combination of virConfFlag(s)
*
* Create a configuration internal structure
*
* Returns a pointer or NULL in case of error.
*/
static virConfPtr
virConfCreate(const char *filename, unsigned int flags)
{
virConfPtr ret = virConfNew();
if (!ret)
return NULL;
if (VIR_STRDUP(ret->filename, filename) < 0) {
VIR_FREE(ret);
return NULL;
}
ret->flags = flags;
return ret;
}
/**
* virConfAddEntry:
* @conf: the conf structure
* @name: name of the entry or NULL for comment
* @value: the value if any
* @comm: extra comment for that entry if any
*
* add one entry to the conf, the parameters are included in the conf
* if successful and freed on virConfFree()
*
* Returns a pointer to the entry or NULL in case of failure
*/
static virConfEntryPtr
virConfAddEntry(virConfPtr conf, char *name, virConfValuePtr value, char *comm)
{
virConfEntryPtr ret, prev;
if (conf == NULL)
return NULL;
if ((comm == NULL) && (name == NULL))
return NULL;
/* don't log fully commented out lines */
if (name)
VIR_DEBUG("Add entry %s %p", name, value);
if (VIR_ALLOC(ret) < 0)
return NULL;
ret->name = name;
ret->value = value;
ret->comment = comm;
if (conf->entries == NULL) {
conf->entries = ret;
} else {
prev = conf->entries;
while (prev->next != NULL)
prev = prev->next;
prev->next = ret;
}
return ret;
}
/************************************************************************
* *
* Serialization *
* *
************************************************************************/
/**
* virConfSaveValue:
* @buf: output buffer
* @val: a value
*
* Serialize the value to the buffer
*
* Returns 0 in case of success, -1 in case of error.
*/
static int
virConfSaveValue(virBufferPtr buf, virConfValuePtr val)
{
if (val == NULL)
return -1;
switch (val->type) {
case VIR_CONF_NONE:
return -1;
case VIR_CONF_LLONG:
virBufferAsprintf(buf, "%lld", val->l);
break;
case VIR_CONF_ULLONG:
virBufferAsprintf(buf, "%llu", val->l);
break;
case VIR_CONF_STRING:
virConfSaveValue: protect against a NULL pointer reference Fix xlconfigtest runs build for --enable-test-oom on Xen XL-2-XML Parse channel-pty Program received signal SIGSEGV, Segmentation fault. #0 0x00007ffff3c2b373 in __strchr_sse2 () from /lib64/libc.so.6 ==> #1 0x00007ffff7875701 in virConfSaveValue (buf=buf@entry=0x7fffffffd8a0, val=val@entry=0x674750) at util/virconf.c:290 #2 0x00007ffff7875668 in virConfSaveValue (buf=buf@entry=0x7fffffffd8a0, val=<optimized out>) at util/virconf.c:306 #3 0x00007ffff78757ef in virConfSaveEntry (buf=buf@entry=0x7fffffffd8a0, cur=cur@entry=0x674780) at util/virconf.c:338 #4 0x00007ffff78783eb in virConfWriteMem (memory=0x665570 "", len=len@entry=0x7fffffffd910, conf=conf@entry=0x65b940) at util/virconf.c:1543 #5 0x000000000040eccb in testCompareParseXML (replaceVars=<optimized out>, xml=<optimized out>, xlcfg=0x662c00 "/home/wtenhave/WORK/libvirt/OOMtesting/libvirt-devel/tests/xlconfigdata/test-channel-pty.cfg") at xlconfigtest.c:108 #6 testCompareHelper (data=<optimized out>) at xlconfigtest.c:205 #7 0x0000000000410b3a in virTestRun (title=title@entry=0x432cc0 "Xen XL-2-XML Parse channel-pty", body=body@entry=0x40e9b0 <testCompareHelper>, data=data@entry=0x7fffffffd9f0) at testutils.c:247 #8 0x000000000040f322 in mymain () at xlconfigtest.c:278 #9 0x0000000000411410 in virTestMain (argc=1, argv=0x7fffffffdba8, func=0x40f660 <mymain>) at testutils.c:992 #10 0x00007ffff3bc0401 in __libc_start_main () from /lib64/libc.so.6 #11 0x000000000040e86a in _start () (gdb) frame 1 #1 0x00007ffff7875701 in virConfSaveValue (buf=buf@entry=0x7fffffffd8a0, val=val@entry=0x674750) at util/virconf.c:290 290 if (strchr(val->str, '\n') != NULL) { (gdb) print *val $1 = {type = VIR_CONF_STRING, next = 0x0, l = 0, str = 0x0, list = 0x0} Signed-off-by: Wim ten Have <wim.ten.have@oracle.com>
2017-03-27 20:20:43 +00:00
if (val->str) {
if (strchr(val->str, '\n') != NULL) {
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
} else if (strchr(val->str, '"') == NULL) {
virBufferAsprintf(buf, "\"%s\"", val->str);
} else if (strchr(val->str, '\'') == NULL) {
virBufferAsprintf(buf, "'%s'", val->str);
} else {
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
}
}
break;
case VIR_CONF_LIST: {
virConfValuePtr cur;
cur = val->list;
virBufferAddLit(buf, "[ ");
if (cur != NULL) {
virConfSaveValue(buf, cur);
cur = cur->next;
while (cur != NULL) {
virBufferAddLit(buf, ", ");
virConfSaveValue(buf, cur);
cur = cur->next;
}
}
virBufferAddLit(buf, " ]");
break;
}
default:
return -1;
}
return 0;
}
/**
* virConfSaveEntry:
* @buf: output buffer
* @cur: a conf entry
*
* Serialize the entry to the buffer
*
* Returns 0 in case of success, -1 in case of error.
*/
static int
virConfSaveEntry(virBufferPtr buf, virConfEntryPtr cur)
{
if (cur->name != NULL) {
virBufferAdd(buf, cur->name, -1);
virBufferAddLit(buf, " = ");
virConfSaveValue(buf, cur->value);
if (cur->comment != NULL) {
virBufferAddLit(buf, " #");
virBufferAdd(buf, cur->comment, -1);
}
} else if (cur->comment != NULL) {
virBufferAddLit(buf, "#");
virBufferAdd(buf, cur->comment, -1);
}
virBufferAddLit(buf, "\n");
return 0;
}
/************************************************************************
* *
* The parser core *
* *
************************************************************************/
/**
* virConfParseLong:
* @ctxt: the parsing context
* @val: the result
*
* Parse one long int value
*
* Returns 0 in case of success and -1 in case of error
*/
static int
virConfParseLong(virConfParserCtxtPtr ctxt, long long *val)
{
long long l = 0;
int neg = 0;
if (CUR == '-') {
neg = 1;
NEXT;
} else if (CUR == '+') {
NEXT;
}
if ((ctxt->cur >= ctxt->end) || (!c_isdigit(CUR))) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated number"));
return -1;
}
while ((ctxt->cur < ctxt->end) && (c_isdigit(CUR))) {
l = l * 10 + (CUR - '0');
NEXT;
}
if (neg)
l = -l;
*val = l;
return 0;
}
/**
* virConfParseString:
* @ctxt: the parsing context
*
* Parse one string
*
* Returns a pointer to the string or NULL in case of error
*/
static char *
virConfParseString(virConfParserCtxtPtr ctxt)
{
const char *base;
char *ret = NULL;
if (CUR == '\'') {
NEXT;
base = ctxt->cur;
while ((ctxt->cur < ctxt->end) && (CUR != '\'') && (!IS_EOL(CUR)))
NEXT;
if (CUR != '\'') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
return NULL;
}
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
return NULL;
NEXT;
} else if ((ctxt->cur + 6 < ctxt->end) &&
(STRPREFIX(ctxt->cur, "\"\"\""))) {
/* String starts with python-style triple quotes """ */
ctxt->cur += 3;
base = ctxt->cur;
/* Find the ending triple quotes */
while ((ctxt->cur + 2 < ctxt->end) &&
!(STRPREFIX(ctxt->cur, "\"\"\""))) {
if (CUR == '\n')
ctxt->line++;
NEXT;
}
if (!STRPREFIX(ctxt->cur, "\"\"\"")) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
return NULL;
}
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
return NULL;
ctxt->cur += 3;
} else if (CUR == '"') {
NEXT;
base = ctxt->cur;
while ((ctxt->cur < ctxt->end) && (CUR != '"') && (!IS_EOL(CUR)))
NEXT;
if (CUR != '"') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
return NULL;
}
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
return NULL;
NEXT;
} else if (ctxt->conf->flags & VIR_CONF_FLAG_LXC_FORMAT) {
base = ctxt->cur;
/* LXC config format doesn't support comments after the value */
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR)))
NEXT;
/* Reverse to exclude the trailing blanks from the value */
while ((ctxt->cur > base) && (c_isblank(CUR)))
ctxt->cur--;
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
return NULL;
}
return ret;
}
/**
* virConfParseValue:
* @ctxt: the parsing context
*
* Parse one value
*
* Returns a pointer to the value or NULL in case of error
*/
static virConfValuePtr
virConfParseValue(virConfParserCtxtPtr ctxt)
{
virConfValuePtr ret, lst = NULL, tmp, prev;
virConfType type = VIR_CONF_NONE;
char *str = NULL;
long long l = 0;
SKIP_BLANKS;
if (ctxt->cur >= ctxt->end) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
return NULL;
}
if ((CUR == '"') || (CUR == '\'') ||
(ctxt->conf->flags & VIR_CONF_FLAG_LXC_FORMAT)) {
type = VIR_CONF_STRING;
str = virConfParseString(ctxt);
if (str == NULL)
return NULL;
} else if (CUR == '[') {
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("lists not allowed in VMX format"));
return NULL;
}
type = VIR_CONF_LIST;
NEXT;
SKIP_BLANKS_AND_EOL;
if ((ctxt->cur < ctxt->end) && (CUR != ']')) {
if ((lst = virConfParseValue(ctxt)) == NULL)
return NULL;
SKIP_BLANKS_AND_EOL;
}
while ((ctxt->cur < ctxt->end) && (CUR != ']')) {
/* Tell Clang that when execution reaches this point
"lst" is guaranteed to be non-NULL. This stops it
from issuing an invalid NULL-dereference warning about
"prev = lst; while (prev->next..." below. */
sa_assert(lst);
if (CUR != ',') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("expecting a separator in list"));
virConfFreeList(lst);
return NULL;
}
NEXT;
SKIP_BLANKS_AND_EOL;
if (CUR == ']')
break;
tmp = virConfParseValue(ctxt);
if (tmp == NULL) {
virConfFreeList(lst);
return NULL;
}
prev = lst;
while (prev->next != NULL) prev = prev->next;
prev->next = tmp;
SKIP_BLANKS_AND_EOL;
}
if (CUR == ']') {
NEXT;
} else {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("list is not closed with ]"));
virConfFreeList(lst);
return NULL;
}
} else if (c_isdigit(CUR) || (CUR == '-') || (CUR == '+')) {
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
_("numbers not allowed in VMX format"));
return NULL;
}
type = (CUR == '-') ? VIR_CONF_LLONG : VIR_CONF_ULLONG;
if (virConfParseLong(ctxt, &l) < 0)
return NULL;
} else {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
return NULL;
}
if (VIR_ALLOC(ret) < 0) {
virConfFreeList(lst);
VIR_FREE(str);
return NULL;
}
ret->type = type;
ret->l = l;
ret->str = str;
ret->list = lst;
return ret;
}
/**
* virConfParseName:
* @ctxt: the parsing context
*
* Parse one name
*
* Returns a copy of the new string, NULL in case of error
*/
static char *
virConfParseName(virConfParserCtxtPtr ctxt)
{
const char *base;
char *ret;
SKIP_BLANKS;
base = ctxt->cur;
/* TODO: probably need encoding support and UTF-8 parsing ! */
if (!c_isalpha(CUR) &&
!((ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) && (CUR == '.'))) {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a name"));
return NULL;
}
while ((ctxt->cur < ctxt->end) &&
(c_isalnum(CUR) || (CUR == '_') ||
((ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) &&
((CUR == ':') || (CUR == '.') || (CUR == '-'))) ||
((ctxt->conf->flags & VIR_CONF_FLAG_LXC_FORMAT) &&
(CUR == '.'))))
NEXT;
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
return NULL;
return ret;
}
/**
* virConfParseComment:
* @ctxt: the parsing context
*
* Parse one standalone comment in the configuration file
*
* Returns 0 in case of success and -1 in case of error
*/
static int
virConfParseComment(virConfParserCtxtPtr ctxt)
{
const char *base;
char *comm;
if (CUR != '#')
return -1;
NEXT;
base = ctxt->cur;
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
if (VIR_STRNDUP(comm, base, ctxt->cur - base) < 0)
return -1;
if (virConfAddEntry(ctxt->conf, NULL, NULL, comm) == NULL) {
VIR_FREE(comm);
return -1;
}
return 0;
}
/**
* virConfParseSeparator:
* @ctxt: the parsing context
*
* Parse one separator between statement if not at the end.
*
* Returns 0 in case of success and -1 in case of error
*/
static int
virConfParseSeparator(virConfParserCtxtPtr ctxt)
{
SKIP_BLANKS;
if (ctxt->cur >= ctxt->end)
return 0;
if (IS_EOL(CUR)) {
SKIP_BLANKS_AND_EOL;
} else if (CUR == ';') {
NEXT;
SKIP_BLANKS_AND_EOL;
} else {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a separator"));
return -1;
}
return 0;
}
/**
* virConfParseStatement:
* @ctxt: the parsing context
*
* Parse one statement in the conf file
*
* Returns 0 in case of success and -1 in case of error
*/
static int
virConfParseStatement(virConfParserCtxtPtr ctxt)
{
const char *base;
char *name;
virConfValuePtr value;
char *comm = NULL;
SKIP_BLANKS_AND_EOL;
if (CUR == '#')
return virConfParseComment(ctxt);
name = virConfParseName(ctxt);
if (name == NULL)
return -1;
SKIP_BLANKS;
if (CUR != '=') {
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting an assignment"));
VIR_FREE(name);
return -1;
}
NEXT;
SKIP_BLANKS;
value = virConfParseValue(ctxt);
if (value == NULL) {
VIR_FREE(name);
return -1;
}
SKIP_BLANKS;
if (CUR == '#') {
NEXT;
base = ctxt->cur;
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
if (VIR_STRNDUP(comm, base, ctxt->cur - base) < 0) {
VIR_FREE(name);
virConfFreeValue(value);
return -1;
}
}
if (virConfAddEntry(ctxt->conf, name, value, comm) == NULL) {
VIR_FREE(name);
virConfFreeValue(value);
VIR_FREE(comm);
return -1;
}
return 0;
}
/**
* virConfParse:
* @filename: the name to report errors
* @content: the configuration content in memory
* @len: the length in bytes
* @flags: combination of virConfFlag(s)
*
* Parse the subset of the Python language needed to handle simple
* Xen configuration files.
*
* Returns a handle to lookup settings or NULL if it failed to
* read or parse the file, use virConfFree() to free the data.
*/
static virConfPtr
virConfParse(const char *filename, const char *content, int len,
unsigned int flags)
{
virConfParserCtxt ctxt;
ctxt.filename = filename;
ctxt.base = ctxt.cur = content;
ctxt.end = content + len - 1;
ctxt.line = 1;
ctxt.conf = virConfCreate(filename, flags);
if (ctxt.conf == NULL)
return NULL;
while (ctxt.cur < ctxt.end) {
if (virConfParseStatement(&ctxt) < 0)
goto error;
if (virConfParseSeparator(&ctxt) < 0)
goto error;
}
return ctxt.conf;
error:
virConfFree(ctxt.conf);
return NULL;
}
/************************************************************************
* *
* The module entry points *
* *
************************************************************************/
/* 10 MB limit on config file size as a sanity check */
#define MAX_CONFIG_FILE_SIZE (1024*1024*10)
/**
2008-11-17 11:03:25 +00:00
* virConfReadFile:
* @filename: the path to the configuration file.
* @flags: combination of virConfFlag(s)
*
* Reads a configuration file.
*
* Returns a handle to lookup settings or NULL if it failed to
* read or parse the file, use virConfFree() to free the data.
*/
virConfPtr
virConfReadFile(const char *filename, unsigned int flags)
{
char *content;
int len;
virConfPtr conf = NULL;
VIR_DEBUG("filename=%s", NULLSTR(filename));
if (filename == NULL) {
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
return NULL;
}
if ((len = virFileReadAll(filename, MAX_CONFIG_FILE_SIZE, &content)) < 0)
return NULL;
if (len && len < MAX_CONFIG_FILE_SIZE && content[len - 1] != '\n') {
VIR_DEBUG("appending newline to busted config file %s", filename);
if (VIR_REALLOC_N(content, len + 2) < 0)
goto cleanup;
content[len++] = '\n';
content[len] = '\0';
}
conf = virConfParse(filename, content, len, flags);
cleanup:
VIR_FREE(content);
return conf;
}
/**
* virConfReadString:
* @memory: pointer to the content of the configuration file
* @flags: combination of virConfFlag(s)
*
* Reads a configuration file loaded in memory. The string must be
* zero terminated.
*
* Returns a handle to lookup settings or NULL if it failed to
* parse the content, use virConfFree() to free the data.
*/
virConfPtr
virConfReadString(const char *memory, unsigned int flags)
{
size_t len;
if (memory == NULL) {
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
return NULL;
}
len = strlen(memory);
return virConfParse("memory conf", memory, len, flags);
}
/**
2008-11-17 11:03:25 +00:00
* virConfFree:
* @conf: a configuration file handle
*
* Frees all data associated to the handle
*
* Returns 0 in case of success, -1 in case of error.
*/
int
2008-11-17 11:03:25 +00:00
virConfFree(virConfPtr conf)
{
virConfEntryPtr tmp;
if (conf == NULL)
return 0;
tmp = conf->entries;
while (tmp) {
virConfEntryPtr next;
VIR_FREE(tmp->name);
virConfFreeValue(tmp->value);
VIR_FREE(tmp->comment);
next = tmp->next;
VIR_FREE(tmp);
tmp = next;
}
VIR_FREE(conf->filename);
VIR_FREE(conf);
return 0;
}
/**
2008-11-17 11:03:25 +00:00
* virConfGetValue:
* @conf: a configuration file handle
* @setting: the name of the entry
*
* Lookup the value associated to this entry in the configuration file
*
* Returns a pointer to the value or NULL if the lookup failed, the data
* associated will be freed when virConfFree() is called
*/
virConfValuePtr
2008-11-17 11:03:25 +00:00
virConfGetValue(virConfPtr conf, const char *setting)
{
virConfEntryPtr cur;
if (conf == NULL)
return NULL;
cur = conf->entries;
while (cur != NULL) {
if ((cur->name != NULL) &&
((conf->flags & VIR_CONF_FLAG_VMX_FORMAT &&
STRCASEEQ(cur->name, setting)) ||
STREQ(cur->name, setting)))
return cur->value;
cur = cur->next;
}
return NULL;
}
/**
* virConfGetValueType:
* @conf: the config object
* @setting: the config entry name
*
* Query the type of the configuration entry @setting.
*
* Returns: the entry type, or VIR_CONF_NONE if not set.
*/
virConfType virConfGetValueType(virConfPtr conf,
const char *setting)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
if (!cval)
return VIR_CONF_NONE;
return cval->type;
}
/**
* virConfGetValueString:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold string value
*
* Get the string value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type.
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueString(virConfPtr conf,
const char *setting,
char **value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value string %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_STRING) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected a string for '%s' parameter"),
conf->filename, setting);
return -1;
}
VIR_FREE(*value);
if (VIR_STRDUP(*value, cval->str) < 0)
return -1;
return 1;
}
/**
* virConfGetValueStringList:
* @conf: the config object
* @setting: the config entry name
* @compatString: true to treat string entry as a 1 element list
* @value: pointer to hold NULL terminated string list
*
* Get the string list value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified. If @compatString is set to true
* and the value is present as a string, this will be turned into
* a 1 element list. The returned @value will be NULL terminated
* if set.
*
* Reports an error if the config entry is set but has
* an unexpected type.
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueStringList(virConfPtr conf,
const char *setting,
bool compatString,
char ***values)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
size_t len;
virConfValuePtr eval;
VIR_DEBUG("Get value string list %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
virStringListFree(*values);
*values = NULL;
switch (cval->type) {
case VIR_CONF_LIST:
/* Calc length and check items */
for (len = 0, eval = cval->list; eval; len++, eval = eval->next) {
if (eval->type != VIR_CONF_STRING) {
virReportError(VIR_ERR_CONF_SYNTAX,
_("%s: expected a string list for '%s' parameter"),
conf->filename, setting);
return -1;
}
}
if (VIR_ALLOC_N(*values, len + 1) < 0)
return -1;
for (len = 0, eval = cval->list; eval; len++, eval = eval->next) {
if (VIR_STRDUP((*values)[len], eval->str) < 0) {
virStringListFree(*values);
*values = NULL;
return -1;
}
}
break;
case VIR_CONF_STRING:
if (compatString) {
if (VIR_ALLOC_N(*values, cval->str ? 2 : 1) < 0)
return -1;
if (cval->str &&
VIR_STRDUP((*values)[0], cval->str) < 0) {
VIR_FREE(*values);
return -1;
}
break;
}
ATTRIBUTE_FALLTHROUGH;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
compatString ?
_("%s: expected a string or string list for '%s' parameter") :
_("%s: expected a string list for '%s' parameter"),
conf->filename, setting);
return -1;
}
return 1;
}
/**
* virConfGetValueBool:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold boolean value
*
* Get the boolean value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value set is not 1 or 0.
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueBool(virConfPtr conf,
const char *setting,
bool *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value bool %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_ULLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected a bool for '%s' parameter"),
conf->filename, setting);
return -1;
}
if (((unsigned long long)cval->l) > 1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be 0 or 1"),
conf->filename, setting);
return -1;
}
*value = cval->l == 1;
return 1;
}
/**
* virConfGetValueInt:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value is outside the
* range that can be stored in an 'int'
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueInt(virConfPtr conf,
const char *setting,
int *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value int %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_LLONG &&
cval->type != VIR_CONF_ULLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected a signed integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
if (cval->l > INT_MAX || cval->l < INT_MIN) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range %d:%d"),
conf->filename, setting, INT_MIN, INT_MAX);
return -1;
}
*value = (int)cval->l;
return 1;
}
/**
* virConfGetValueUInt:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the unsigned integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value is outside the
* range that can be stored in an 'unsigned int'
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueUInt(virConfPtr conf,
const char *setting,
unsigned int *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value uint %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_ULLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected an unsigned integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
if (((unsigned long long)cval->l) > UINT_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range 0:%u"),
conf->filename, setting, UINT_MAX);
return -1;
}
*value = (unsigned int)cval->l;
return 1;
}
/**
* virConfGetValueSizeT:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value is outside the
* range that can be stored in a 'size_t'
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueSizeT(virConfPtr conf,
const char *setting,
size_t *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value size_t %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_ULLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected an unsigned integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
#if ULLONG_MAX > SIZE_MAX
if (((unsigned long long)cval->l) > SIZE_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range 0:%zu"),
conf->filename, setting, SIZE_MAX);
return -1;
}
#endif
*value = (size_t)cval->l;
return 1;
}
/**
* virConfGetValueSSizeT:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value is outside the
* range that can be stored in an 'ssize_t'
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueSSizeT(virConfPtr conf,
const char *setting,
ssize_t *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value ssize_t %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type == VIR_CONF_ULLONG) {
if (((unsigned long long)cval->l) > SSIZE_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range %zd:%zd"),
conf->filename, setting, (ssize_t)-SSIZE_MAX - 1, (ssize_t)SSIZE_MAX);
return -1;
}
} else if (cval->type == VIR_CONF_LLONG) {
#if SSIZE_MAX < LLONG_MAX
if (cval->l < (-SSIZE_MAX - 1) || cval->l > SSIZE_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range %zd:%zd"),
conf->filename, setting, (ssize_t)-SSIZE_MAX - 1, (ssize_t)SSIZE_MAX);
return -1;
}
#endif
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected a signed integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
*value = (ssize_t)cval->l;
return 1;
}
/**
* virConfGetValueLLong:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type, or if the value is outside the
* range that can be stored in an 'long long'
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueLLong(virConfPtr conf,
const char *setting,
long long *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value long long %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type == VIR_CONF_ULLONG) {
if (((unsigned long long)cval->l) > LLONG_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: value for '%s' parameter must be in range %lld:%lld"),
conf->filename, setting, LLONG_MIN, LLONG_MAX);
return -1;
}
} else if (cval->type != VIR_CONF_LLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected a signed integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
*value = cval->l;
return 1;
}
/**
* virConfGetValueULLong:
* @conf: the config object
* @setting: the config entry name
* @value: pointer to hold integer value
*
* Get the integer value of the config name @setting, storing
* it in @value. If the config entry is not present, then
* @value will be unmodified.
*
* Reports an error if the config entry is set but has
* an unexpected type.
*
* Returns: 1 if the value was present, 0 if missing, -1 on error
*/
int virConfGetValueULLong(virConfPtr conf,
const char *setting,
unsigned long long *value)
{
virConfValuePtr cval = virConfGetValue(conf, setting);
VIR_DEBUG("Get value unsigned long long %p %d",
cval, cval ? cval->type : VIR_CONF_NONE);
if (!cval)
return 0;
if (cval->type != VIR_CONF_ULLONG) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s: expected an unsigned integer for '%s' parameter"),
conf->filename, setting);
return -1;
}
*value = (unsigned long long)cval->l;
return 1;
}
/**
2008-11-17 11:03:25 +00:00
* virConfSetValue:
* @conf: a configuration file handle
* @setting: the name of the entry
* @value: the new configuration value
*
* Set (or replace) the value associated to this entry in the configuration
* file. The passed in 'value' will be owned by the conf object upon return
* of this method, even in case of error. It should not be referenced again
* by the caller.
*
* Returns 0 on success, or -1 on failure.
*/
2007-03-09 20:47:12 +00:00
int
virConfSetValue(virConfPtr conf,
const char *setting,
virConfValuePtr value)
2007-03-09 20:47:12 +00:00
{
virConfEntryPtr cur, prev = NULL;
if (value && value->type == VIR_CONF_STRING && value->str == NULL) {
virConfFreeValue(value);
return -1;
}
cur = conf->entries;
while (cur != NULL) {
if (STREQ_NULLABLE(cur->name, setting))
break;
prev = cur;
cur = cur->next;
}
if (!cur) {
if (VIR_ALLOC(cur) < 0) {
virConfFreeValue(value);
return -1;
}
cur->comment = NULL;
if (VIR_STRDUP(cur->name, setting) < 0) {
virConfFreeValue(value);
VIR_FREE(cur);
return -1;
}
cur->value = value;
if (prev) {
cur->next = prev->next;
prev->next = cur;
} else {
cur->next = conf->entries;
conf->entries = cur;
}
} else {
virConfFreeValue(cur->value);
cur->value = value;
}
return 0;
}
/**
* virConfWalk:
* @conf: a configuration file handle
* @callback: the function to call to process each entry
* @opaque: obscure data passed to callback
*
* Walk over all entries of the configuration file and run the callback
* for each with entry name, value and the obscure data.
*
* Returns 0 on success, or -1 on failure.
*/
int virConfWalk(virConfPtr conf,
virConfWalkCallback callback,
void *opaque)
{
virConfEntryPtr cur;
if (!conf)
return 0;
cur = conf->entries;
while (cur != NULL) {
if (cur->name && cur->value &&
callback(cur->name, cur->value, opaque) < 0)
return -1;
cur = cur->next;
}
return 0;
}
/**
2008-11-17 11:03:25 +00:00
* virConfWriteFile:
* @filename: the path to the configuration file.
* @conf: the conf
*
* Writes a configuration file back to a file.
*
* Returns the number of bytes written or -1 in case of error.
*/
int
2008-11-17 11:03:25 +00:00
virConfWriteFile(const char *filename, virConfPtr conf)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virConfEntryPtr cur;
int ret;
int fd;
char *content;
unsigned int use;
if (conf == NULL)
return -1;
cur = conf->entries;
while (cur != NULL) {
virConfSaveEntry(&buf, cur);
cur = cur->next;
}
if (virBufferCheckError(&buf) < 0)
return -1;
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (fd < 0) {
virBufferFreeAndReset(&buf);
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to open file"));
return -1;
}
use = virBufferUse(&buf);
content = virBufferContentAndReset(&buf);
ret = safewrite(fd, content, use);
VIR_FREE(content);
VIR_FORCE_CLOSE(fd);
if (ret != (int)use) {
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to save content"));
return -1;
}
return ret;
}
/**
2008-11-17 11:03:25 +00:00
* virConfWriteMem:
* @memory: pointer to the memory to store the config file
* @len: pointer to the length in bytes of the store, on output the size
* @conf: the conf
*
* Writes a configuration file back to a memory area. @len is an IN/OUT
* parameter, it indicates the size available in bytes, and on output the
* size required for the configuration file (even if the call fails due to
* insufficient space).
*
* Returns the number of bytes written or -1 in case of error.
*/
int
2008-11-17 11:03:25 +00:00
virConfWriteMem(char *memory, int *len, virConfPtr conf)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virConfEntryPtr cur;
char *content;
unsigned int use;
if ((memory == NULL) || (len == NULL) || (*len <= 0) || (conf == NULL))
return -1;
cur = conf->entries;
while (cur != NULL) {
virConfSaveEntry(&buf, cur);
cur = cur->next;
}
if (virBufferCheckError(&buf) < 0)
return -1;
use = virBufferUse(&buf);
content = virBufferContentAndReset(&buf);
if ((int)use >= *len) {
*len = (int)use;
VIR_FREE(content);
return -1;
}
memcpy(memory, content, use);
VIR_FREE(content);
*len = use;
return use;
}
static char *
virConfLoadConfigPath(const char *name)
{
char *path;
if (geteuid() == 0) {
if (virAsprintf(&path, "%s/libvirt/%s",
SYSCONFDIR, name) < 0)
return NULL;
} else {
char *userdir = virGetUserConfigDirectory();
if (!userdir)
return NULL;
if (virAsprintf(&path, "%s/%s",
userdir, name) < 0) {
VIR_FREE(userdir);
return NULL;
}
VIR_FREE(userdir);
}
return path;
}
int
virConfLoadConfig(virConfPtr *conf, const char *name)
{
char *path = NULL;
int ret = -1;
*conf = NULL;
if (!(path = virConfLoadConfigPath(name)))
goto cleanup;
if (!virFileExists(path)) {
ret = 0;
goto cleanup;
}
VIR_DEBUG("Loading config file '%s'", path);
if (!(*conf = virConfReadFile(path, 0)))
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(path);
return ret;
}