2012-12-12 16:35:35 +00:00
|
|
|
/*
|
|
|
|
* virconf.c: parser for a subset of the Python encoded Xen configuration files
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
2014-03-18 08:14:35 +00:00
|
|
|
* Copyright (C) 2006-2014 Red Hat, Inc.
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
2012-07-27 09:39:53 +00:00
|
|
|
* 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
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-27 09:39:53 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
|
|
|
* Daniel Veillard <veillard@redhat.com>
|
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#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
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
2012-12-13 18:21:53 +00:00
|
|
|
#include "virerror.h"
|
2012-12-04 12:04:07 +00:00
|
|
|
#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"
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
#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"
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2013-05-24 07:19:51 +00:00
|
|
|
#include "virstring.h"
|
2015-10-12 14:09:53 +00:00
|
|
|
#include "configmake.h"
|
2006-08-29 22:27:07 +00:00
|
|
|
|
2009-01-29 12:10:32 +00:00
|
|
|
#define VIR_FROM_THIS VIR_FROM_CONF
|
|
|
|
|
2014-02-28 12:16:17 +00:00
|
|
|
VIR_LOG_INIT("util.conf");
|
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* 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'))
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
|
|
|
|
#define SKIP_BLANKS_AND_EOL \
|
|
|
|
do { while ((ctxt->cur < ctxt->end) && (c_isblank(CUR) || IS_EOL(CUR))) { \
|
|
|
|
if (CUR == '\n') ctxt->line++; \
|
2013-05-24 16:58:25 +00:00
|
|
|
ctxt->cur++; } } while (0)
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
#define SKIP_BLANKS \
|
|
|
|
do { while ((ctxt->cur < ctxt->end) && (c_isblank(CUR))) \
|
|
|
|
ctxt->cur++; } while (0)
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* Structures used by configuration data *
|
|
|
|
* *
|
|
|
|
************************************************************************/
|
|
|
|
|
2014-12-09 13:53:28 +00:00
|
|
|
VIR_ENUM_IMPL(virConf, VIR_CONF_LAST,
|
|
|
|
"*unexpected*",
|
|
|
|
"long",
|
2014-12-09 15:22:09 +00:00
|
|
|
"unsigned long",
|
2014-12-09 13:53:28 +00:00
|
|
|
"string",
|
|
|
|
"list");
|
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
typedef struct _virConfEntry virConfEntry;
|
|
|
|
typedef virConfEntry *virConfEntryPtr;
|
|
|
|
|
|
|
|
struct _virConfEntry {
|
|
|
|
virConfEntryPtr next;
|
|
|
|
char* name;
|
|
|
|
char* comment;
|
|
|
|
virConfValuePtr value;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _virConf {
|
2016-07-07 15:52:47 +00:00
|
|
|
char *filename;
|
2009-06-19 12:34:30 +00:00
|
|
|
unsigned int flags;
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfEntryPtr entries;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConfError:
|
2008-09-17 14:11:21 +00:00
|
|
|
* @ctxt: the parser context if available or NULL
|
2006-08-29 22:27:07 +00:00
|
|
|
* @error: the error number
|
|
|
|
* @info: extra information string
|
|
|
|
*
|
|
|
|
* Handle an error at the xend daemon interface
|
|
|
|
*/
|
2011-11-28 23:13:40 +00:00
|
|
|
#define virConfError(ctxt, error, info) \
|
|
|
|
virConfErrorHelper(__FILE__, __FUNCTION__, __LINE__, ctxt, error, info)
|
2006-08-29 22:27:07 +00:00
|
|
|
static void
|
2011-11-28 23:13:40 +00:00
|
|
|
virConfErrorHelper(const char *file, const char *func, size_t line,
|
|
|
|
virConfParserCtxtPtr ctxt,
|
|
|
|
virErrorNumber error, const char *info)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
|
|
|
if (error == VIR_ERR_OK)
|
|
|
|
return;
|
|
|
|
|
2008-09-17 14:11:21 +00:00
|
|
|
/* Construct the string 'filename:line: info' if we have that. */
|
|
|
|
if (ctxt && ctxt->filename) {
|
2011-11-28 23:13:40 +00:00
|
|
|
virReportErrorHelper(VIR_FROM_CONF, error, file, func, line,
|
|
|
|
_("%s:%d: %s"), ctxt->filename, ctxt->line, info);
|
2008-09-17 14:11:21 +00:00
|
|
|
} else {
|
2011-11-28 23:13:40 +00:00
|
|
|
virReportErrorHelper(VIR_FROM_CONF, error, file, func, line,
|
|
|
|
"%s", info);
|
2008-09-17 14:11:21 +00:00
|
|
|
}
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* 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;
|
2007-01-19 20:10:04 +00:00
|
|
|
list->next = NULL;
|
|
|
|
virConfFreeValue(list);
|
|
|
|
list = next;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConfFreeValue:
|
|
|
|
* @val: the value to free
|
|
|
|
*
|
|
|
|
* Free a value
|
|
|
|
*/
|
2008-05-29 19:20:22 +00:00
|
|
|
void
|
2008-11-17 11:03:25 +00:00
|
|
|
virConfFreeValue(virConfValuePtr val)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
|
|
|
if (val == NULL)
|
|
|
|
return;
|
2007-01-19 20:10:04 +00:00
|
|
|
if (val->type == VIR_CONF_STRING &&
|
|
|
|
val->str != NULL)
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(val->str);
|
2007-01-19 20:10:04 +00:00
|
|
|
if (val->type == VIR_CONF_LIST &&
|
|
|
|
val->list != NULL)
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfFreeList(val->list);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(val);
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
2007-03-09 20:47:12 +00:00
|
|
|
virConfPtr
|
2008-11-17 11:03:25 +00:00
|
|
|
virConfNew(void)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
|
|
|
virConfPtr ret;
|
|
|
|
|
2013-07-04 10:17:18 +00:00
|
|
|
if (VIR_ALLOC(ret) < 0)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-11-15 19:46:23 +00:00
|
|
|
ret->filename = NULL;
|
2009-06-19 12:34:30 +00:00
|
|
|
ret->flags = 0;
|
2006-11-15 19:46:23 +00:00
|
|
|
|
2012-03-22 11:33:35 +00:00
|
|
|
return ret;
|
2006-11-15 19:46:23 +00:00
|
|
|
}
|
2006-08-29 22:27:07 +00:00
|
|
|
|
2006-11-15 19:46:23 +00:00
|
|
|
/**
|
|
|
|
* virConfCreate:
|
|
|
|
* @filename: the name to report errors
|
2009-06-19 12:34:30 +00:00
|
|
|
* @flags: combination of virConfFlag(s)
|
2006-11-15 19:46:23 +00:00
|
|
|
*
|
|
|
|
* Create a configuration internal structure
|
|
|
|
*
|
|
|
|
* Returns a pointer or NULL in case of error.
|
|
|
|
*/
|
|
|
|
static virConfPtr
|
2009-06-19 12:34:30 +00:00
|
|
|
virConfCreate(const char *filename, unsigned int flags)
|
2006-11-15 19:46:23 +00:00
|
|
|
{
|
|
|
|
virConfPtr ret = virConfNew();
|
2016-07-07 15:52:47 +00:00
|
|
|
if (!ret)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (VIR_STRDUP(ret->filename, filename) < 0) {
|
|
|
|
VIR_FREE(ret);
|
|
|
|
return NULL;
|
2009-06-19 12:34:30 +00:00
|
|
|
}
|
2016-07-07 15:52:47 +00:00
|
|
|
|
|
|
|
ret->flags = flags;
|
2012-03-22 11:33:35 +00:00
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
if ((comm == NULL) && (name == NULL))
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-02-05 19:27:37 +00:00
|
|
|
|
2016-07-07 15:52:47 +00:00
|
|
|
VIR_DEBUG("Add entry %s %p", name, value);
|
2013-07-04 10:17:18 +00:00
|
|
|
if (VIR_ALLOC(ret) < 0)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2007-01-19 20:10:04 +00:00
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
ret->name = name;
|
|
|
|
ret->value = value;
|
|
|
|
ret->comment = comm;
|
|
|
|
|
|
|
|
if (conf->entries == NULL) {
|
|
|
|
conf->entries = ret;
|
|
|
|
} else {
|
|
|
|
prev = conf->entries;
|
2008-04-10 16:54:54 +00:00
|
|
|
while (prev->next != NULL)
|
|
|
|
prev = prev->next;
|
|
|
|
prev->next = ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* 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)
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
switch (val->type) {
|
|
|
|
case VIR_CONF_NONE:
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2008-04-10 16:54:54 +00:00
|
|
|
case VIR_CONF_LONG:
|
2016-07-07 15:52:47 +00:00
|
|
|
virBufferAsprintf(buf, "%lld", val->l);
|
|
|
|
break;
|
2014-12-09 15:22:09 +00:00
|
|
|
case VIR_CONF_ULONG:
|
2016-07-07 15:52:47 +00:00
|
|
|
virBufferAsprintf(buf, "%llu", val->l);
|
2008-04-10 16:54:54 +00:00
|
|
|
break;
|
|
|
|
case VIR_CONF_STRING:
|
|
|
|
if (strchr(val->str, '\n') != NULL) {
|
2011-04-30 16:34:49 +00:00
|
|
|
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
|
2008-04-10 16:54:54 +00:00
|
|
|
} else if (strchr(val->str, '"') == NULL) {
|
2011-04-30 16:34:49 +00:00
|
|
|
virBufferAsprintf(buf, "\"%s\"", val->str);
|
2008-04-10 16:54:54 +00:00
|
|
|
} else if (strchr(val->str, '\'') == NULL) {
|
2011-04-30 16:34:49 +00:00
|
|
|
virBufferAsprintf(buf, "'%s'", val->str);
|
2008-04-10 16:54:54 +00:00
|
|
|
} else {
|
2011-04-30 16:34:49 +00:00
|
|
|
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
|
|
|
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:
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
2008-04-10 16:54:54 +00:00
|
|
|
virBufferAddLit(buf, " = ");
|
|
|
|
virConfSaveValue(buf, cur->value);
|
|
|
|
if (cur->comment != NULL) {
|
|
|
|
virBufferAddLit(buf, " #");
|
|
|
|
virBufferAdd(buf, cur->comment, -1);
|
|
|
|
}
|
2006-08-29 22:27:07 +00:00
|
|
|
} else if (cur->comment != NULL) {
|
2008-04-10 16:54:54 +00:00
|
|
|
virBufferAddLit(buf, "#");
|
|
|
|
virBufferAdd(buf, cur->comment, -1);
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
Eliminate all uses of virBufferAdd with string literals.
* Makefile.maint (sc_prohibit_virBufferAdd_with_string_literal):
New rule.
* src/buf.h (virBufferAddLit): Define.
* src/conf.c (virConfSaveValue): Use virBufferAddLit, in place
of virBufferAdd everywhere possible.
(virConfSaveEntry): Likewise.
* src/qemu_conf.c (qemudGenerateXML, qemudGenerateNetworkXML): Likewise.
* src/qemu_driver.c (qemudGetFeatures, qemudGetCapabilities): Likewise.
* src/test.c (testDomainDumpXML, testNetworkDumpXML): Likewise.
* src/xen_internal.c (xenHypervisorMakeCapabilitiesXML): Likewise.
* src/xend_internal.c (xend_parse_sexp_desc_os): Likewise.
(xend_parse_sexp_desc, sexpr_to_xend_topology_xml): Likewise.
* src/xm_internal.c (xenXMDomainFormatXML, xenXMDomainPinVcpu): Likewise.
* src/xml.c (virSaveCpuSet, virParseXenCpuTopology): Likewise.
(virDomainParseXMLGraphicsDescImage): Likewise.
(virDomainParseXMLGraphicsDescVFB, virDomainParseXMLOSDescHVM): Likewise.
(virDomainParseXMLOSDescPV, virDomainParseXMLDiskDesc): Likewise.
(virDomainParseXMLIfDesc, virDomainParseXMLDesc): Likewise.
2008-02-05 14:22:28 +00:00
|
|
|
virBufferAddLit(buf, "\n");
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* 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 *val)
|
|
|
|
{
|
|
|
|
long l = 0;
|
|
|
|
int neg = 0;
|
|
|
|
|
|
|
|
if (CUR == '-') {
|
|
|
|
neg = 1;
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else if (CUR == '+') {
|
|
|
|
NEXT;
|
|
|
|
}
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
if ((ctxt->cur >= ctxt->end) || (!c_isdigit(CUR))) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated number"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
while ((ctxt->cur < ctxt->end) && (c_isdigit(CUR))) {
|
2006-08-29 22:27:07 +00:00
|
|
|
l = l * 10 + (CUR - '0');
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2007-10-19 10:01:01 +00:00
|
|
|
if (neg)
|
|
|
|
l = -l;
|
2006-08-29 22:27:07 +00:00
|
|
|
*val = l;
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
2008-04-10 16:54:54 +00:00
|
|
|
base = ctxt->cur;
|
|
|
|
while ((ctxt->cur < ctxt->end) && (CUR != '\'') && (!IS_EOL(CUR)))
|
|
|
|
NEXT;
|
|
|
|
if (CUR != '\'') {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
|
2009-11-08 21:08:54 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
2010-11-18 22:33:36 +00:00
|
|
|
} else if ((ctxt->cur + 6 < ctxt->end) &&
|
|
|
|
(STRPREFIX(ctxt->cur, "\"\"\""))) {
|
|
|
|
/* String starts with python-style triple quotes """ */
|
2008-04-10 16:54:54 +00:00
|
|
|
ctxt->cur += 3;
|
|
|
|
base = ctxt->cur;
|
2010-11-18 22:33:36 +00:00
|
|
|
|
2010-11-18 22:35:23 +00:00
|
|
|
/* Find the ending triple quotes */
|
2010-11-18 22:33:36 +00:00
|
|
|
while ((ctxt->cur + 2 < ctxt->end) &&
|
2010-11-18 22:35:23 +00:00
|
|
|
!(STRPREFIX(ctxt->cur, "\"\"\""))) {
|
2010-11-18 22:33:36 +00:00
|
|
|
if (CUR == '\n')
|
|
|
|
ctxt->line++;
|
|
|
|
NEXT;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
2010-11-18 22:33:36 +00:00
|
|
|
|
|
|
|
if (!STRPREFIX(ctxt->cur, "\"\"\"")) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
|
2009-11-08 21:08:54 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
ctxt->cur += 3;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else if (CUR == '"') {
|
|
|
|
NEXT;
|
2008-04-10 16:54:54 +00:00
|
|
|
base = ctxt->cur;
|
|
|
|
while ((ctxt->cur < ctxt->end) && (CUR != '"') && (!IS_EOL(CUR)))
|
|
|
|
NEXT;
|
|
|
|
if (CUR != '"') {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("unterminated string"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
|
2009-11-08 21:08:54 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
2014-02-05 14:09:59 +00:00
|
|
|
} 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;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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 l = 0;
|
|
|
|
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
if (ctxt->cur >= ctxt->end) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2014-02-05 14:09:59 +00:00
|
|
|
if ((CUR == '"') || (CUR == '\'') ||
|
|
|
|
(ctxt->conf->flags & VIR_CONF_FLAG_LXC_FORMAT)) {
|
2006-08-29 22:27:07 +00:00
|
|
|
type = VIR_CONF_STRING;
|
|
|
|
str = virConfParseString(ctxt);
|
2008-04-10 16:54:54 +00:00
|
|
|
if (str == NULL)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else if (CUR == '[') {
|
2009-06-22 11:54:49 +00:00
|
|
|
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
|
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
|
|
|
|
_("lists not allowed in VMX format"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2009-06-22 11:54:49 +00:00
|
|
|
}
|
2006-08-29 22:27:07 +00:00
|
|
|
type = VIR_CONF_LIST;
|
|
|
|
NEXT;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2008-04-10 16:54:54 +00:00
|
|
|
if ((ctxt->cur < ctxt->end) && (CUR != ']')) {
|
2008-06-06 11:09:57 +00:00
|
|
|
if ((lst = virConfParseValue(ctxt)) == NULL)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
|
|
|
while ((ctxt->cur < ctxt->end) && (CUR != ']')) {
|
2010-04-07 18:54:50 +00:00
|
|
|
|
|
|
|
/* 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. */
|
2012-10-17 09:23:12 +00:00
|
|
|
sa_assert(lst);
|
2010-04-07 18:54:50 +00:00
|
|
|
|
2008-04-10 16:54:54 +00:00
|
|
|
if (CUR != ',') {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
|
|
|
|
_("expecting a separator in list"));
|
2008-04-10 16:54:54 +00:00
|
|
|
virConfFreeList(lst);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
|
|
|
NEXT;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2014-11-13 14:28:18 +00:00
|
|
|
if (CUR == ']')
|
2008-04-10 16:54:54 +00:00
|
|
|
break;
|
|
|
|
tmp = virConfParseValue(ctxt);
|
|
|
|
if (tmp == NULL) {
|
|
|
|
virConfFreeList(lst);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
|
|
|
prev = lst;
|
|
|
|
while (prev->next != NULL) prev = prev->next;
|
|
|
|
prev->next = tmp;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
|
|
|
if (CUR == ']') {
|
|
|
|
NEXT;
|
|
|
|
} else {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
|
|
|
|
_("list is not closed with ]"));
|
2008-04-10 16:54:54 +00:00
|
|
|
virConfFreeList(lst);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
} else if (c_isdigit(CUR) || (CUR == '-') || (CUR == '+')) {
|
2009-06-22 11:54:49 +00:00
|
|
|
if (ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) {
|
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX,
|
|
|
|
_("numbers not allowed in VMX format"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2009-06-22 11:54:49 +00:00
|
|
|
}
|
2014-12-09 15:22:09 +00:00
|
|
|
type = (c_isdigit(CUR) || CUR == '+') ? VIR_CONF_ULONG : VIR_CONF_LONG;
|
2014-11-13 14:28:18 +00:00
|
|
|
if (virConfParseLong(ctxt, &l) < 0)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a value"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2008-06-06 11:09:57 +00:00
|
|
|
if (VIR_ALLOC(ret) < 0) {
|
|
|
|
virConfFreeList(lst);
|
|
|
|
VIR_FREE(str);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
ret->type = type;
|
|
|
|
ret->l = l;
|
|
|
|
ret->str = str;
|
|
|
|
ret->list = lst;
|
2012-03-22 11:33:35 +00:00
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
base = ctxt->cur;
|
|
|
|
/* TODO: probably need encoding support and UTF-8 parsing ! */
|
2009-07-27 12:21:17 +00:00
|
|
|
if (!c_isalpha(CUR) &&
|
|
|
|
!((ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) && (CUR == '.'))) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a name"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2009-06-19 12:34:30 +00:00
|
|
|
while ((ctxt->cur < ctxt->end) &&
|
|
|
|
(c_isalnum(CUR) || (CUR == '_') ||
|
2009-06-22 11:54:49 +00:00
|
|
|
((ctxt->conf->flags & VIR_CONF_FLAG_VMX_FORMAT) &&
|
2014-02-05 14:09:59 +00:00
|
|
|
((CUR == ':') || (CUR == '.') || (CUR == '-'))) ||
|
|
|
|
((ctxt->conf->flags & VIR_CONF_FLAG_LXC_FORMAT) &&
|
|
|
|
(CUR == '.'))))
|
2006-08-29 22:27:07 +00:00
|
|
|
NEXT;
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(ret, base, ctxt->cur - base) < 0)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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 != '#')
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
NEXT;
|
|
|
|
base = ctxt->cur;
|
|
|
|
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(comm, base, ctxt->cur - base) < 0)
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2013-09-25 10:32:07 +00:00
|
|
|
if (virConfAddEntry(ctxt->conf, NULL, NULL, comm) == NULL) {
|
|
|
|
VIR_FREE(comm);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
if (ctxt->cur >= ctxt->end)
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
if (IS_EOL(CUR)) {
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else if (CUR == ';') {
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2006-08-29 22:27:07 +00:00
|
|
|
} else {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting a separator"));
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS_AND_EOL;
|
2014-11-13 14:28:18 +00:00
|
|
|
if (CUR == '#')
|
2011-03-04 16:52:12 +00:00
|
|
|
return virConfParseComment(ctxt);
|
2006-08-29 22:27:07 +00:00
|
|
|
name = virConfParseName(ctxt);
|
|
|
|
if (name == NULL)
|
2011-03-04 16:52:12 +00:00
|
|
|
return -1;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
if (CUR != '=') {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(ctxt, VIR_ERR_CONF_SYNTAX, _("expecting an assignment"));
|
2011-03-04 16:52:12 +00:00
|
|
|
VIR_FREE(name);
|
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
NEXT;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
value = virConfParseValue(ctxt);
|
|
|
|
if (value == NULL) {
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(name);
|
2011-03-04 16:52:12 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
SKIP_BLANKS;
|
2006-08-29 22:27:07 +00:00
|
|
|
if (CUR == '#') {
|
2008-04-10 16:54:54 +00:00
|
|
|
NEXT;
|
|
|
|
base = ctxt->cur;
|
|
|
|
while ((ctxt->cur < ctxt->end) && (!IS_EOL(CUR))) NEXT;
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRNDUP(comm, base, ctxt->cur - base) < 0) {
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(name);
|
2008-04-10 16:54:54 +00:00
|
|
|
virConfFreeValue(value);
|
2011-03-04 16:52:12 +00:00
|
|
|
return -1;
|
2008-04-10 16:54:54 +00:00
|
|
|
}
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
if (virConfAddEntry(ctxt->conf, name, value, comm) == NULL) {
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(name);
|
2008-04-10 16:54:54 +00:00
|
|
|
virConfFreeValue(value);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(comm);
|
2011-03-04 16:52:12 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2011-03-04 16:52:12 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConfParse:
|
|
|
|
* @filename: the name to report errors
|
|
|
|
* @content: the configuration content in memory
|
|
|
|
* @len: the length in bytes
|
2009-06-19 12:34:30 +00:00
|
|
|
* @flags: combination of virConfFlag(s)
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
|
|
|
* Parse the subset of the Python language needed to handle simple
|
|
|
|
* Xen configuration files.
|
|
|
|
*
|
2011-12-04 00:06:07 +00:00
|
|
|
* Returns a handle to lookup settings or NULL if it failed to
|
2006-08-29 22:27:07 +00:00
|
|
|
* read or parse the file, use virConfFree() to free the data.
|
|
|
|
*/
|
|
|
|
static virConfPtr
|
2009-06-19 12:34:30 +00:00
|
|
|
virConfParse(const char *filename, const char *content, int len,
|
2014-03-18 08:14:35 +00:00
|
|
|
unsigned int flags)
|
|
|
|
{
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfParserCtxt ctxt;
|
|
|
|
|
|
|
|
ctxt.filename = filename;
|
|
|
|
ctxt.base = ctxt.cur = content;
|
|
|
|
ctxt.end = content + len - 1;
|
|
|
|
ctxt.line = 1;
|
|
|
|
|
2009-06-19 12:34:30 +00:00
|
|
|
ctxt.conf = virConfCreate(filename, flags);
|
2006-08-29 22:27:07 +00:00
|
|
|
if (ctxt.conf == NULL)
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
while (ctxt.cur < ctxt.end) {
|
|
|
|
if (virConfParseStatement(&ctxt) < 0)
|
2008-04-10 16:54:54 +00:00
|
|
|
goto error;
|
|
|
|
if (virConfParseSeparator(&ctxt) < 0)
|
|
|
|
goto error;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
2012-03-22 11:33:35 +00:00
|
|
|
return ctxt.conf;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
2014-03-25 06:53:22 +00:00
|
|
|
error:
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfFree(ctxt.conf);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* *
|
|
|
|
* The module entry points *
|
|
|
|
* *
|
|
|
|
************************************************************************/
|
|
|
|
|
2008-01-07 15:21:33 +00:00
|
|
|
/* 10 MB limit on config file size as a sanity check */
|
|
|
|
#define MAX_CONFIG_FILE_SIZE (1024*1024*10)
|
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfReadFile:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @filename: the path to the configuration file.
|
2009-06-19 12:34:30 +00:00
|
|
|
* @flags: combination of virConfFlag(s)
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
|
|
|
* Reads a configuration file.
|
|
|
|
*
|
2011-12-04 00:06:07 +00:00
|
|
|
* Returns a handle to lookup settings or NULL if it failed to
|
2006-08-29 22:27:07 +00:00
|
|
|
* read or parse the file, use virConfFree() to free the data.
|
|
|
|
*/
|
|
|
|
virConfPtr
|
2009-06-19 12:34:30 +00:00
|
|
|
virConfReadFile(const char *filename, unsigned int flags)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
2008-01-07 15:21:33 +00:00
|
|
|
char *content;
|
2006-08-29 22:27:07 +00:00
|
|
|
int len;
|
2016-04-21 00:25:31 +00:00
|
|
|
virConfPtr conf = NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
2012-10-20 19:40:41 +00:00
|
|
|
VIR_DEBUG("filename=%s", NULLSTR(filename));
|
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
if (filename == NULL) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2008-01-07 15:21:33 +00:00
|
|
|
|
2014-11-13 14:28:18 +00:00
|
|
|
if ((len = virFileReadAll(filename, MAX_CONFIG_FILE_SIZE, &content)) < 0)
|
2008-01-07 15:21:33 +00:00
|
|
|
return NULL;
|
|
|
|
|
2016-04-21 00:25:31 +00:00
|
|
|
if (len && len < MAX_CONFIG_FILE_SIZE && content[len - 1] != '\n') {
|
|
|
|
VIR_DEBUG("appending newline to busted config file %s", filename);
|
2016-07-08 13:47:20 +00:00
|
|
|
if (VIR_REALLOC_N(content, len + 2) < 0)
|
2016-04-21 00:25:31 +00:00
|
|
|
goto cleanup;
|
|
|
|
content[len++] = '\n';
|
|
|
|
content[len] = '\0';
|
|
|
|
}
|
|
|
|
|
2009-06-19 12:34:30 +00:00
|
|
|
conf = virConfParse(filename, content, len, flags);
|
2008-01-07 15:21:33 +00:00
|
|
|
|
2016-04-21 00:25:31 +00:00
|
|
|
cleanup:
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(content);
|
2008-01-07 15:21:33 +00:00
|
|
|
|
|
|
|
return conf;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfReadMem:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @memory: pointer to the content of the configuration file
|
2008-04-04 07:58:29 +00:00
|
|
|
* @len: length in byte
|
2009-06-19 12:34:30 +00:00
|
|
|
* @flags: combination of virConfFlag(s)
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
|
|
|
* Reads a configuration file loaded in memory. The string can be
|
|
|
|
* zero terminated in which case @len can be 0
|
|
|
|
*
|
2011-12-04 00:06:07 +00:00
|
|
|
* Returns a handle to lookup settings or NULL if it failed to
|
2006-08-29 22:27:07 +00:00
|
|
|
* parse the content, use virConfFree() to free the data.
|
|
|
|
*/
|
|
|
|
virConfPtr
|
2009-06-19 12:34:30 +00:00
|
|
|
virConfReadMem(const char *memory, int len, unsigned int flags)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
|
|
|
if ((memory == NULL) || (len < 0)) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
if (len == 0)
|
|
|
|
len = strlen(memory);
|
|
|
|
|
2012-03-22 11:33:35 +00:00
|
|
|
return virConfParse("memory conf", memory, len, flags);
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfFree:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @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)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
2007-01-19 20:10:04 +00:00
|
|
|
virConfEntryPtr tmp;
|
2011-10-13 10:49:45 +00:00
|
|
|
if (conf == NULL)
|
|
|
|
return 0;
|
2007-01-19 20:10:04 +00:00
|
|
|
|
|
|
|
tmp = conf->entries;
|
|
|
|
while (tmp) {
|
|
|
|
virConfEntryPtr next;
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(tmp->name);
|
2007-01-19 20:10:04 +00:00
|
|
|
virConfFreeValue(tmp->value);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(tmp->comment);
|
2007-01-19 20:10:04 +00:00
|
|
|
next = tmp->next;
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(tmp);
|
2007-01-19 20:10:04 +00:00
|
|
|
tmp = next;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2016-07-07 15:52:47 +00:00
|
|
|
VIR_FREE(conf->filename);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(conf);
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfGetValue:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @conf: a configuration file handle
|
2015-08-18 12:38:07 +00:00
|
|
|
* @setting: the name of the entry
|
2006-08-29 22:27:07 +00:00
|
|
|
*
|
|
|
|
* Lookup the value associated to this entry in the configuration file
|
|
|
|
*
|
2008-02-05 19:27:37 +00:00
|
|
|
* Returns a pointer to the value or NULL if the lookup failed, the data
|
2006-08-29 22:27:07 +00:00
|
|
|
* associated will be freed when virConfFree() is called
|
|
|
|
*/
|
|
|
|
virConfValuePtr
|
2008-11-17 11:03:25 +00:00
|
|
|
virConfGetValue(virConfPtr conf, const char *setting)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
2006-08-29 22:45:44 +00:00
|
|
|
virConfEntryPtr cur;
|
|
|
|
|
2012-03-19 10:05:30 +00:00
|
|
|
if (conf == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2006-08-29 22:45:44 +00:00
|
|
|
cur = conf->entries;
|
|
|
|
while (cur != NULL) {
|
2010-03-24 00:52:33 +00:00
|
|
|
if ((cur->name != NULL) &&
|
|
|
|
((conf->flags & VIR_CONF_FLAG_VMX_FORMAT &&
|
|
|
|
STRCASEEQ(cur->name, setting)) ||
|
|
|
|
STREQ(cur->name, setting)))
|
2012-03-22 11:33:35 +00:00
|
|
|
return cur->value;
|
2006-08-29 22:45:44 +00:00
|
|
|
cur = cur->next;
|
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return NULL;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
2016-07-07 15:52:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
virStringFreeList(*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) {
|
|
|
|
virStringFreeList(*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;
|
|
|
|
}
|
|
|
|
/* 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_ULONG) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected a bool for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cval->l < 0 || 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_LONG &&
|
|
|
|
cval->type != VIR_CONF_ULONG) {
|
|
|
|
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 = 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_ULONG) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected an unsigned integer for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cval->l > UINT_MAX || cval->l < 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: value for '%s' parameter must be in range 0:%u"),
|
|
|
|
conf->filename, setting, UINT_MAX);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*value = 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;
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
if (cval->type == VIR_CONF_LONG) {
|
|
|
|
if (cval->l < 0 || 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;
|
|
|
|
}
|
|
|
|
} else if (cval->type == VIR_CONF_ULONG) {
|
2016-07-14 10:29:17 +00:00
|
|
|
#if ULLONG_MAX > SIZE_MAX
|
2016-07-14 10:21:30 +00:00
|
|
|
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;
|
|
|
|
}
|
2016-07-14 10:29:17 +00:00
|
|
|
#endif
|
2016-07-14 10:21:30 +00:00
|
|
|
} else {
|
2016-07-07 15:52:47 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected an unsigned integer for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
*value = (size_t)cval->l;
|
2016-07-07 15:52:47 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
if (cval->type == VIR_CONF_ULONG) {
|
|
|
|
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_LONG) {
|
2016-07-14 10:29:17 +00:00
|
|
|
#if SSIZE_MAX < LLONG_MAX
|
2016-07-14 10:21:30 +00:00
|
|
|
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;
|
|
|
|
}
|
2016-07-14 10:29:17 +00:00
|
|
|
#endif
|
2016-07-14 10:21:30 +00:00
|
|
|
} else {
|
2016-07-07 15:52:47 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected a signed integer for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
*value = (ssize_t)cval->l;
|
2016-07-07 15:52:47 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
if (cval->type == VIR_CONF_ULONG) {
|
|
|
|
if (((unsigned long long)cval->l) > LLONG_MAX) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: value for '%s' parameter must be in range 0:%lld"),
|
|
|
|
conf->filename, setting, LLONG_MAX);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else if (cval->type != VIR_CONF_LONG) {
|
2016-07-07 15:52:47 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected a signed integer for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*value = cval->l;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConfGetValueULongLong:
|
|
|
|
* @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;
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
if (cval->type == VIR_CONF_LONG) {
|
|
|
|
if (cval->l < 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: value for '%s' parameter must be in range 0:%llu"),
|
|
|
|
conf->filename, setting, ULLONG_MAX);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else if (cval->type != VIR_CONF_ULONG) {
|
2016-07-07 15:52:47 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("%s: expected an unsigned integer for '%s' parameter"),
|
|
|
|
conf->filename, setting);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-07-14 10:21:30 +00:00
|
|
|
*value = (unsigned long long)cval->l;
|
2016-07-07 15:52:47 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-11-15 19:46:23 +00:00
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfSetValue:
|
2006-11-15 19:46:23 +00:00
|
|
|
* @conf: a configuration file handle
|
2015-08-18 12:38:07 +00:00
|
|
|
* @setting: the name of the entry
|
2006-11-15 19:46:23 +00:00
|
|
|
* @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
|
2012-10-17 09:23:12 +00:00
|
|
|
virConfSetValue(virConfPtr conf,
|
|
|
|
const char *setting,
|
|
|
|
virConfValuePtr value)
|
2007-03-09 20:47:12 +00:00
|
|
|
{
|
2006-11-15 19:46:23 +00:00
|
|
|
virConfEntryPtr cur, prev = NULL;
|
|
|
|
|
2015-01-09 13:42:13 +00:00
|
|
|
if (value && value->type == VIR_CONF_STRING && value->str == NULL) {
|
|
|
|
virConfFreeValue(value);
|
2009-12-14 20:37:54 +00:00
|
|
|
return -1;
|
2015-01-09 13:42:13 +00:00
|
|
|
}
|
2009-12-14 20:37:54 +00:00
|
|
|
|
2006-11-15 19:46:23 +00:00
|
|
|
cur = conf->entries;
|
|
|
|
while (cur != NULL) {
|
2014-12-09 13:48:54 +00:00
|
|
|
if (STREQ_NULLABLE(cur->name, setting))
|
2006-11-15 19:46:23 +00:00
|
|
|
break;
|
|
|
|
prev = cur;
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
2007-01-19 20:10:04 +00:00
|
|
|
|
2006-11-15 19:46:23 +00:00
|
|
|
if (!cur) {
|
2008-06-06 11:09:57 +00:00
|
|
|
if (VIR_ALLOC(cur) < 0) {
|
2006-11-15 19:46:23 +00:00
|
|
|
virConfFreeValue(value);
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-11-15 19:46:23 +00:00
|
|
|
}
|
|
|
|
cur->comment = NULL;
|
2013-05-24 07:19:51 +00:00
|
|
|
if (VIR_STRDUP(cur->name, setting) < 0) {
|
2006-11-15 19:46:23 +00:00
|
|
|
virConfFreeValue(value);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(cur);
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-11-15 19:46:23 +00:00
|
|
|
}
|
|
|
|
cur->value = value;
|
|
|
|
if (prev) {
|
2007-01-19 20:10:04 +00:00
|
|
|
cur->next = prev->next;
|
2006-11-15 19:46:23 +00:00
|
|
|
prev->next = cur;
|
|
|
|
} else {
|
2007-01-19 20:10:04 +00:00
|
|
|
cur->next = conf->entries;
|
2006-11-15 19:46:23 +00:00
|
|
|
conf->entries = cur;
|
|
|
|
}
|
|
|
|
} else {
|
2010-05-17 20:38:59 +00:00
|
|
|
virConfFreeValue(cur->value);
|
2006-11-15 19:46:23 +00:00
|
|
|
cur->value = value;
|
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return 0;
|
2006-11-15 19:46:23 +00:00
|
|
|
}
|
|
|
|
|
2014-02-05 14:09:59 +00:00
|
|
|
/**
|
|
|
|
* virConfWalk:
|
|
|
|
* @conf: a configuration file handle
|
|
|
|
* @callback: the function to call to process each entry
|
2015-08-19 02:36:28 +00:00
|
|
|
* @opaque: obscure data passed to callback
|
2014-02-05 14:09:59 +00:00
|
|
|
*
|
|
|
|
* 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,
|
2015-08-17 12:42:03 +00:00
|
|
|
virConfWalkCallback callback,
|
|
|
|
void *opaque)
|
2014-02-05 14:09:59 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2006-11-15 19:46:23 +00:00
|
|
|
|
2006-08-29 22:27:07 +00:00
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfWriteFile:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @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)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
2008-04-28 15:14:59 +00:00
|
|
|
virBuffer buf = VIR_BUFFER_INITIALIZER;
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfEntryPtr cur;
|
|
|
|
int ret;
|
|
|
|
int fd;
|
2008-04-28 15:14:59 +00:00
|
|
|
char *content;
|
|
|
|
unsigned int use;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
if (conf == NULL)
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
cur = conf->entries;
|
|
|
|
while (cur != NULL) {
|
2008-04-28 15:14:59 +00:00
|
|
|
virConfSaveEntry(&buf, cur);
|
2008-04-10 16:54:54 +00:00
|
|
|
cur = cur->next;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2008-02-05 19:27:37 +00:00
|
|
|
|
2014-06-27 08:40:15 +00:00
|
|
|
if (virBufferCheckError(&buf) < 0)
|
2008-04-28 15:14:59 +00:00
|
|
|
return -1;
|
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
|
2006-08-29 22:27:07 +00:00
|
|
|
if (fd < 0) {
|
2009-12-09 23:00:50 +00:00
|
|
|
virBufferFreeAndReset(&buf);
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to open file"));
|
2008-04-28 15:14:59 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
2008-04-28 15:14:59 +00:00
|
|
|
use = virBufferUse(&buf);
|
|
|
|
content = virBufferContentAndReset(&buf);
|
|
|
|
ret = safewrite(fd, content, use);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(content);
|
2010-11-09 20:48:48 +00:00
|
|
|
VIR_FORCE_CLOSE(fd);
|
2008-04-28 15:14:59 +00:00
|
|
|
if (ret != (int)use) {
|
2008-09-17 14:11:21 +00:00
|
|
|
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to save content"));
|
2008-04-28 15:14:59 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2008-04-28 15:14:59 +00:00
|
|
|
|
|
|
|
return ret;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-11-17 11:03:25 +00:00
|
|
|
* virConfWriteMem:
|
2006-08-29 22:27:07 +00:00
|
|
|
* @memory: pointer to the memory to store the config file
|
2007-10-19 08:29:13 +00:00
|
|
|
* @len: pointer to the length in bytes of the store, on output the size
|
2006-08-29 22:27:07 +00:00
|
|
|
* @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)
|
2006-08-29 22:27:07 +00:00
|
|
|
{
|
2008-04-28 15:14:59 +00:00
|
|
|
virBuffer buf = VIR_BUFFER_INITIALIZER;
|
2006-08-29 22:27:07 +00:00
|
|
|
virConfEntryPtr cur;
|
2008-04-28 15:14:59 +00:00
|
|
|
char *content;
|
|
|
|
unsigned int use;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
if ((memory == NULL) || (len == NULL) || (*len <= 0) || (conf == NULL))
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2006-08-29 22:27:07 +00:00
|
|
|
|
|
|
|
cur = conf->entries;
|
|
|
|
while (cur != NULL) {
|
2008-04-28 15:14:59 +00:00
|
|
|
virConfSaveEntry(&buf, cur);
|
2007-01-19 20:10:04 +00:00
|
|
|
cur = cur->next;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2008-02-05 19:27:37 +00:00
|
|
|
|
2014-06-27 08:40:15 +00:00
|
|
|
if (virBufferCheckError(&buf) < 0)
|
2008-04-28 15:14:59 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
use = virBufferUse(&buf);
|
|
|
|
content = virBufferContentAndReset(&buf);
|
|
|
|
|
|
|
|
if ((int)use >= *len) {
|
|
|
|
*len = (int)use;
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(content);
|
2008-04-28 15:14:59 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memcpy(memory, content, use);
|
2008-06-06 11:09:57 +00:00
|
|
|
VIR_FREE(content);
|
2008-04-28 15:14:59 +00:00
|
|
|
*len = use;
|
|
|
|
return use;
|
2006-08-29 22:27:07 +00:00
|
|
|
}
|
2015-10-12 14:09:53 +00:00
|
|
|
|
|
|
|
static char *
|
|
|
|
virConfLoadConfigPath(const char *name)
|
|
|
|
{
|
|
|
|
char *path;
|
|
|
|
if (geteuid() == 0) {
|
|
|
|
if (virAsprintf(&path, "%s/libvirt/libvirt%s%s.conf",
|
|
|
|
SYSCONFDIR,
|
|
|
|
name ? "-" : "",
|
|
|
|
name ? name : "") < 0)
|
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
char *userdir = virGetUserConfigDirectory();
|
|
|
|
if (!userdir)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (virAsprintf(&path, "%s/libvirt%s%s.conf",
|
|
|
|
userdir,
|
|
|
|
name ? "-" : "",
|
|
|
|
name ? 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;
|
|
|
|
}
|