NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2026-08-04 10:23:02 -05:00
Code Issues Packages Projects Releases Wiki Activity

Rename qemud/ directory to daemon/

Browse Source 
* qemud/: Rename to daemon/
* Makefile.am, configure.in, src/Makefile.am, src/remote_internal.c,
  tests/Makefile.am, tests/eventtest.c: s/qemud/daemon/ where needed
This commit is contained in:
Daniel P. Berrange
2009-09-21 14:41:42 +01:00
parent fd5c9bb9ab
commit 5c2a1ae876
41 changed files with 11 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files
daemon/.gitignore
+12
View File
@@ -0,0 +1,12 @@
*.gcda
*.gcno
*.la
*.lo
.deps
.libs
Makefile
Makefile.in
libvirt_qemud
libvirtd
libvirtd.init
libvirtd.logrotate
daemon/Makefile.am
+294
View File
@@ -0,0 +1,294 @@
## Process this file with automake to produce Makefile.in
DAEMON_SOURCES = \
event.c event.h \
qemud.c qemud.h \
remote.c remote.h \
dispatch.c dispatch.h \
remote_dispatch_prototypes.h \
remote_dispatch_table.h \
remote_dispatch_args.h \
remote_dispatch_ret.h \
remote_protocol.h remote_protocol.c
AVAHI_SOURCES = \
mdns.c mdns.h
DISTCLEANFILES =
EXTRA_DIST = \
default-network.xml \
remote_generate_stubs.pl rpcgen_fix.pl \
remote_protocol.x \
libvirtd.conf \
libvirtd.init.in \
libvirtd.policy-0 \
libvirtd.policy-1 \
libvirtd.sasl \
libvirtd.sysconf \
libvirtd.aug \
libvirtd_qemu.aug \
libvirtd.logrotate.in \
test_libvirtd.aug \
test_libvirtd_qemu.aug \
$(AVAHI_SOURCES) \
$(DAEMON_SOURCES)
BUILT_SOURCES =
if HAVE_RPCGEN
#
# Maintainer-only target for re-generating the derived .c/.h source
# files, which are actually derived from the .x file.
#
# For committing protocol changes to CVS, the GLIBC rpcgen *must*
# be used.
#
# Support for non-GLIB rpcgen is here as a convenience for
# non-Linux people needing to test changes during dev.
#
rpcgen:
rm -f rp.c-t rp.h-t rp.c-t1 rp.c-t2 rp.h-t1
$(RPCGEN) -h -o rp.h-t $(srcdir)/remote_protocol.x
$(RPCGEN) -c -o rp.c-t $(srcdir)/remote_protocol.x
if HAVE_GLIBC_RPCGEN
perl -w $(srcdir)/rpcgen_fix.pl rp.h-t > rp.h-t1
perl -w $(srcdir)/rpcgen_fix.pl rp.c-t > rp.c-t1
(echo '#include <config.h>'; cat rp.c-t1) > rp.c-t2
chmod 0444 rp.c-t2 rp.h-t1
mv -f rp.h-t1 $(srcdir)/remote_protocol.h
mv -f rp.c-t2 $(srcdir)/remote_protocol.c
rm -f rp.c-t rp.h-t rp.c-t1
else
chmod 0444 rp.c-t rp.h-t
mv -f rp.h-t $(srcdir)/remote_protocol.h
mv -f rp.c-t $(srcdir)/remote_protocol.c
endif
endif
remote_protocol.c: remote_protocol.h
if WITH_LIBVIRTD
UUID=$(shell uuidgen 2>/dev/null)
sbin_PROGRAMS = libvirtd
confdir = $(sysconfdir)/libvirt/
conf_DATA = libvirtd.conf
augeasdir = $(datadir)/augeas/lenses
augeas_DATA = libvirtd.aug libvirtd_qemu.aug
augeastestsdir = $(datadir)/augeas/lenses/tests
augeastests_DATA = test_libvirtd.aug test_libvirtd_qemu.aug
libvirtd_SOURCES = $(DAEMON_SOURCES)
#-D_XOPEN_SOURCE=600 -D_XOPEN_SOURCE_EXTENDED=1 -D_POSIX_C_SOURCE=199506L
libvirtd_CFLAGS = \
-I$(top_srcdir)/gnulib/lib -I../gnulib/lib \
-I$(top_srcdir)/include -I$(top_builddir)/include \
-I$(top_srcdir)/src \
$(LIBXML_CFLAGS) $(GNUTLS_CFLAGS) $(SASL_CFLAGS) \
$(POLKIT_CFLAGS) \
$(WARN_CFLAGS) -DLOCAL_STATE_DIR="\"$(localstatedir)\"" \
$(COVERAGE_CFLAGS) \
-DSYSCONF_DIR="\"$(sysconfdir)\"" \
-DQEMUD_PID_FILE="\"$(QEMUD_PID_FILE)\"" \
-DREMOTE_PID_FILE="\"$(REMOTE_PID_FILE)\"" \
-DGETTEXT_PACKAGE=\"$(PACKAGE)\"
libvirtd_LDFLAGS = \
$(WARN_CFLAGS) \
$(COVERAGE_LDFLAGS)
libvirtd_LDADD = \
$(LIBXML_LIBS) \
$(GNUTLS_LIBS) \
$(SASL_LIBS) \
$(POLKIT_LIBS)
if WITH_DRIVER_MODULES
libvirtd_LDADD += ../src/libvirt_driver.la
libvirtd_LDADD += ../src/libvirt_util.la
else
if WITH_QEMU
libvirtd_LDADD += ../src/libvirt_driver_qemu.la
endif
if WITH_LXC
libvirtd_LDADD += ../src/libvirt_driver_lxc.la
endif
if WITH_UML
libvirtd_LDADD += ../src/libvirt_driver_uml.la
endif
if WITH_ONE
libvirtd_LDADD += ../src/libvirt_driver_one.la
endif
if WITH_STORAGE_DIR
libvirtd_LDADD += ../src/libvirt_driver_storage.la
endif
if WITH_NETWORK
libvirtd_LDADD += ../src/libvirt_driver_network.la
endif
if WITH_NETCF
libvirtd_LDADD += ../src/libvirt_driver_interface.la
endif
if WITH_NODE_DEVICES
libvirtd_LDADD += ../src/libvirt_driver_nodedev.la
endif
endif
libvirtd_LDADD += ../src/libvirt.la
if HAVE_POLKIT
if HAVE_POLKIT0
policydir = $(datadir)/PolicyKit/policy
policyfile = libvirtd.policy-0
else
policydir = $(datadir)/polkit-1/actions
policyfile = libvirtd.policy-1
endif
endif
if HAVE_AVAHI
libvirtd_SOURCES += $(AVAHI_SOURCES)
libvirtd_CFLAGS += $(AVAHI_CFLAGS)
libvirtd_LDADD += $(AVAHI_LIBS)
endif
default_xml_dest = libvirt/qemu/networks/default.xml
install-data-local: install-init install-data-sasl install-data-polkit \
install-logrotate
mkdir -p $(DESTDIR)$(sysconfdir)/libvirt/qemu/networks/autostart
$(INSTALL_DATA) $(srcdir)/default-network.xml \
$(DESTDIR)$(sysconfdir)/$(default_xml_dest)
test -z "$(UUID)" || \
sed -i -e "s,</name>,</name>\n <uuid>$(UUID)</uuid>," \
$(DESTDIR)$(sysconfdir)/$(default_xml_dest)
test -e $(DESTDIR)$(sysconfdir)/libvirt/qemu/networks/autostart/default.xml || \
ln -s ../default.xml \
$(DESTDIR)$(sysconfdir)/libvirt/qemu/networks/autostart/default.xml
mkdir -p $(DESTDIR)$(localstatedir)/log/libvirt/qemu
mkdir -p $(DESTDIR)$(localstatedir)/run/libvirt
mkdir -p $(DESTDIR)$(localstatedir)/lib/libvirt
uninstall-local:: uninstall-init install-data-sasl install-data-polkit
rm -f $(DESTDIR)$(sysconfdir)/libvirt/qemu/networks/autostart/default.xml
rm -f $(DESTDIR)$(sysconfdir)/$(default_xml_dest)
rmdir $(DESTDIR)$(sysconfdir)/libvirt/qemu/networks/autostart || :
rmdir $(DESTDIR)$(localstatedir)/log/libvirt/qemu || :
rmdir $(DESTDIR)$(localstatedir)/run/libvirt || :
rmdir $(DESTDIR)$(localstatedir)/lib/libvirt || :
if HAVE_POLKIT
install-data-polkit:: install-init
mkdir -p $(DESTDIR)$(policydir)
$(INSTALL_DATA) $(srcdir)/$(policyfile) $(DESTDIR)$(policydir)/org.libvirt.unix.policy
uninstall-data-polkit:: install-init
rm -f $(DESTDIR)$(policydir)/org.libvirt.unix.policy
else
install-data-polkit::
uninstall-data-polkit::
endif
remote.c: remote_dispatch_prototypes.h \
remote_dispatch_table.h \
remote_dispatch_args.h \
remote_dispatch_ret.h
remote_dispatch_prototypes.h: $(srcdir)/remote_generate_stubs.pl remote_protocol.x
perl -w $(srcdir)/remote_generate_stubs.pl -p $(srcdir)/remote_protocol.x > $@
remote_dispatch_table.h: $(srcdir)/remote_generate_stubs.pl remote_protocol.x
perl -w $(srcdir)/remote_generate_stubs.pl -t $(srcdir)/remote_protocol.x > $@
remote_dispatch_args.h: $(srcdir)/remote_generate_stubs.pl remote_protocol.x
perl -w $(srcdir)/remote_generate_stubs.pl -a $(srcdir)/remote_protocol.x > $@
remote_dispatch_ret.h: $(srcdir)/remote_generate_stubs.pl remote_protocol.x
perl -w $(srcdir)/remote_generate_stubs.pl -r $(srcdir)/remote_protocol.x > $@
BUILT_SOURCES += libvirtd.logrotate
libvirtd.logrotate: libvirtd.logrotate.in
sed \
-e s!\@localstatedir\@!@localstatedir@!g \
< $< > $@-t
mv $@-t $@
install-logrotate: libvirtd.logrotate
mkdir -p $(DESTDIR)$(localstatedir)/log/libvirt/qemu/
mkdir -p $(DESTDIR)$(sysconfdir)/logrotate.d/
$(INSTALL_DATA) $< $(DESTDIR)$(sysconfdir)/logrotate.d/libvirtd
if LIBVIRT_INIT_SCRIPTS_RED_HAT
install-init: libvirtd.init
mkdir -p $(DESTDIR)$(sysconfdir)/rc.d/init.d
$(INSTALL_SCRIPT) libvirtd.init \
$(DESTDIR)$(sysconfdir)/rc.d/init.d/libvirtd
mkdir -p $(DESTDIR)$(sysconfdir)/sysconfig
$(INSTALL_SCRIPT) $(srcdir)/libvirtd.sysconf \
$(DESTDIR)$(sysconfdir)/sysconfig/libvirtd
uninstall-init:
rm -f $(DESTDIR)$(sysconfdir)/rc.d/init.d/libvirtd \
$(DESTDIR)$(sysconfdir)/sysconfig/libvirtd
BUILT_SOURCES += libvirtd.init
libvirtd.init: libvirtd.init.in
sed \
-e s!\@localstatedir\@!@localstatedir@!g \
-e s!\@sbindir\@!@sbindir@!g \
-e s!\@sysconfdir\@!@sysconfdir@!g \
< $< > $@-t
chmod a+x $@-t
mv $@-t $@
check-local:
test -x '$(AUGPARSE)' \
&& '$(AUGPARSE)' -I $(srcdir) $(srcdir)/test_libvirtd.aug || :
test -x '$(AUGPARSE)' \
&& '$(AUGPARSE)' -I $(srcdir) $(srcdir)/test_libvirtd_qemu.aug || :
else
install-init:
uninstall-init:
libvirtd.init:
endif # DBUS_INIT_SCRIPTS_RED_HAT
# This must be added last, since functions it provides/replaces
# are used by nearly every other library.
libvirtd_LDADD += ../gnulib/lib/libgnu.la $(LIBSOCKET)
else # WITH_LIBVIRTD
install-data-local: install-data-sasl
uninstall-local:: uninstall-data-sasl
endif # WITH_LIBVIRTD
# This is needed for clients too, so can't wrap in
# the WITH_LIBVIRTD conditional
if HAVE_SASL
install-data-sasl:
mkdir -p $(DESTDIR)$(sysconfdir)/sasl2/
$(INSTALL_DATA) $(srcdir)/libvirtd.sasl $(DESTDIR)$(sysconfdir)/sasl2/libvirt.conf
uninstall-data-sasl:
rm -f $(DESTDIR)$(sysconfdir)/sasl2/libvirt.conf
rmdir $(DESTDIR)$(sysconfdir)/sasl2/
endif
CLEANFILES = $(BUILT_SOURCES)
CLEANFILES += *.cov *.gcov .libs/*.gcda .libs/*.gcno *.gcno *.gcda
daemon/THREADING.txt
+62
View File
@@ -0,0 +1,62 @@
Threading: the RULES.
====================
If you don't understand this, don't touch the code. Ask for
further advice / explanation on the mailing list first.
- the top level lock is on 'struct qemud_server'. This must be
held before acquiring any other lock
- Each 'struct qemud_client' object has a lock. The server lock
must be held before acquiring it. Once the client lock is acquired
the server lock can (optionally) be dropped.
- The event loop has its own self-contained lock. You can ignore
this as a caller of virEvent APIs.
The server lock is only needed / used once the daemon has entered
its main loop, which is the qemudRunLoop() . The initial thread
acquires the lock upon entering this method.
It immediatelty spawns 'n' worker threads, whose main loop is
the qemudWorker() method. The workers will immediately try to
acquire the server lock, and thus block since its held by the
initial thread.
When the initial thread enters the poll() call, it drops the
server lock. The worker locks now each wakeup, acquire the
server lock and go into a condition wait on the 'job' condition
variable. The workers are now all 'primed' for incoming RPC
calls.
A file descriptor event now occurrs, causing the initial thread
to exit poll(). It invokes the registered callback associated
with the file descriptors on which the event occurrs. The callbacks
are required to immediately acquire the server lock.
If the callback is dealing with a client event, it will then
acquire the client lock, and drop the server lock.
The callback will now handle the I/O event, reading or writing
a RPC message. Once a complete RPC message has been read the
client is marked as being in state QEMUD_MODE_WAIT_DISPATCH,
and the 'job' condition variable is signaled. The callback
now drops the client lock and goes back into the poll() loop
waiting for more I/O events.
Meanwhile one of the worker threads wakes up from its condition
variable sleep, holding the server lock. It now searches for a
client in state QEMUD_MODE_WAIT_DISPATCH. If it doesn't find
one, it goes back to sleep. If it does find one, then it calls
into the remoteDispatchClientRequest() method de-serialize the
incoming message into an XDR object and invoke the helper method
for the associated RPC call.
While the helper method is executing, no locks are held on either
the client or server, but the ref count on the 'struct qemud_client'
object is incremented to ensure its not deleted. The helper can
now safely invoke the neccessary libvirt API call.
daemon/default-network.xml
+10
View File
@@ -0,0 +1,10 @@
<network>
<name>default</name>
<bridge name="virbr0" />
<forward/>
<ip address="192.168.122.1" netmask="255.255.255.0">
<dhcp>
<range start="192.168.122.2" end="192.168.122.254" />
</dhcp>
</ip>
</network>
daemon/dispatch.c
+534
View File
@@ -0,0 +1,534 @@
/*
* dispatch.h: RPC message dispatching infrastructure
*
* Copyright (C) 2007, 2008, 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Richard W.M. Jones <rjones@redhat.com>
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#include <config.h>
#include "dispatch.h"
#include "remote.h"
#include "memory.h"
/* Convert a libvirt virError object into wire format */
static void
remoteDispatchCopyError (remote_error *rerr,
virErrorPtr verr)
{
rerr->code = verr->code;
rerr->domain = verr->domain;
rerr->message = verr->message ? malloc(sizeof(char*)) : NULL;
if (rerr->message) *rerr->message = strdup(verr->message);
rerr->level = verr->level;
rerr->str1 = verr->str1 ? malloc(sizeof(char*)) : NULL;
if (rerr->str1) *rerr->str1 = strdup(verr->str1);
rerr->str2 = verr->str2 ? malloc(sizeof(char*)) : NULL;
if (rerr->str2) *rerr->str2 = strdup(verr->str2);
rerr->str3 = verr->str3 ? malloc(sizeof(char*)) : NULL;
if (rerr->str3) *rerr->str3 = strdup(verr->str3);
rerr->int1 = verr->int1;
rerr->int2 = verr->int2;
}
/* A set of helpers for sending back errors to client
in various ways .... */
static void
remoteDispatchStringError (remote_error *rerr,
int code, const char *msg)
{
virError verr;
memset(&verr, 0, sizeof verr);
/* Construct the dummy libvirt virError. */
verr.code = code;
verr.domain = VIR_FROM_REMOTE;
verr.message = (char *)msg;
verr.level = VIR_ERR_ERROR;
verr.str1 = (char *)msg;
remoteDispatchCopyError(rerr, &verr);
}
void remoteDispatchAuthError (remote_error *rerr)
{
remoteDispatchStringError (rerr, VIR_ERR_AUTH_FAILED, "authentication failed");
}
void remoteDispatchFormatError (remote_error *rerr,
const char *fmt, ...)
{
va_list args;
char msgbuf[1024];
char *msg = msgbuf;
va_start (args, fmt);
vsnprintf (msgbuf, sizeof msgbuf, fmt, args);
va_end (args);
remoteDispatchStringError (rerr, VIR_ERR_RPC, msg);
}
void remoteDispatchGenericError (remote_error *rerr)
{
remoteDispatchStringError(rerr,
VIR_ERR_INTERNAL_ERROR,
"library function returned error but did not set virterror");
}
void remoteDispatchOOMError (remote_error *rerr)
{
remoteDispatchStringError(rerr,
VIR_ERR_NO_MEMORY,
NULL);
}
void remoteDispatchConnError (remote_error *rerr,
virConnectPtr conn)
{
virErrorPtr verr;
if (conn)
verr = virConnGetLastError(conn);
else
verr = virGetLastError();
if (verr)
remoteDispatchCopyError(rerr, verr);
else
remoteDispatchGenericError(rerr);
}
static int
remoteSerializeError(struct qemud_client *client,
remote_error *rerr,
int program,
int version,
int procedure,
int type,
int serial)
{
XDR xdr;
unsigned int len;
struct qemud_client_message *msg = NULL;
if (VIR_ALLOC(msg) < 0)
goto fatal_error;
/* Return header. */
msg->hdr.prog = program;
msg->hdr.vers = version;
msg->hdr.proc = procedure;
msg->hdr.type = type;
msg->hdr.serial = serial;
msg->hdr.status = REMOTE_ERROR;
msg->bufferLength = sizeof(msg->buffer);
/* Serialise the return header. */
xdrmem_create (&xdr,
msg->buffer,
msg->bufferLength,
XDR_ENCODE);
len = 0; /* We'll come back and write this later. */
if (!xdr_u_int (&xdr, &len))
goto xdr_error;
if (!xdr_remote_message_header (&xdr, &msg->hdr))
goto xdr_error;
/* Error was not set, so synthesize a generic error message. */
if (rerr->code == 0)
remoteDispatchGenericError(rerr);
if (!xdr_remote_error (&xdr, rerr))
goto xdr_error;
/* Write the length word. */
len = xdr_getpos (&xdr);
if (xdr_setpos (&xdr, 0) == 0)
goto xdr_error;
if (!xdr_u_int (&xdr, &len))
goto xdr_error;
xdr_destroy (&xdr);
msg->bufferLength = len;
msg->bufferOffset = 0;
/* Put reply on end of tx queue to send out */
qemudClientMessageQueuePush(&client->tx, msg);
qemudUpdateClientEvent(client);
xdr_free((xdrproc_t)xdr_remote_error, (char *)rerr);
return 0;
xdr_error:
xdr_destroy(&xdr);
fatal_error:
xdr_free((xdrproc_t)xdr_remote_error, (char *)rerr);
return -1;
}
/*
* @client: the client to send the error to
* @rerr: the error object to send
* @req: the message this error is in reply to
*
* Send an error message to the client
*
* Returns 0 if the error was sent, -1 upon fatal error
*/
static int
remoteSerializeReplyError(struct qemud_client *client,
remote_error *rerr,
remote_message_header *req) {
return remoteSerializeError(client,
rerr,
req->prog,
req->vers,
req->proc,
REMOTE_REPLY,
req->serial);
}
/*
* @msg: the complete incoming message, whose header to decode
*
* Decodes the header part of the client message, but does not
* validate the decoded fields in the header. It expects
* bufferLength to refer to length of the data packet. Upon
* return bufferOffset will refer to the amount of the packet
* consumed by decoding of the header.
*
* returns 0 if successfully decoded, -1 upon fatal error
*/
int
remoteDecodeClientMessageHeader (struct qemud_client_message *msg)
{
XDR xdr;
int ret = -1;
msg->bufferOffset = REMOTE_MESSAGE_HEADER_XDR_LEN;
/* Parse the header. */
xdrmem_create (&xdr,
msg->buffer + msg->bufferOffset,
msg->bufferLength - msg->bufferOffset,
XDR_DECODE);
if (!xdr_remote_message_header (&xdr, &msg->hdr))
goto cleanup;
msg->bufferOffset += xdr_getpos(&xdr);
ret = 0;
cleanup:
xdr_destroy(&xdr);
return ret;
}
/*
* @msg: the outgoing message, whose header to encode
*
* Encodes the header part of the client message, setting the
* message offset ready to encode the payload. Leaves space
* for the length field later. Upon return bufferLength will
* refer to the total available space for message, while
* bufferOffset will refer to current space used by header
*
* returns 0 if successfully encoded, -1 upon fatal error
*/
int
remoteEncodeClientMessageHeader (struct qemud_client_message *msg)
{
XDR xdr;
int ret = -1;
unsigned int len = 0;
msg->bufferLength = sizeof(msg->buffer);
msg->bufferOffset = 0;
/* Format the header. */
xdrmem_create (&xdr,
msg->buffer,
msg->bufferLength,
XDR_ENCODE);
/* The real value is filled in shortly */
if (!xdr_u_int (&xdr, &len)) {
goto cleanup;
}
if (!xdr_remote_message_header (&xdr, &msg->hdr))
goto cleanup;
len = xdr_getpos(&xdr);
xdr_setpos(&xdr, 0);
/* Fill in current length - may be re-written later
* if a payload is added
*/
if (!xdr_u_int (&xdr, &len)) {
goto cleanup;
}
msg->bufferOffset += len;
ret = 0;
cleanup:
xdr_destroy(&xdr);
return ret;
}
int
remoteDispatchClientCall (struct qemud_server *server,
struct qemud_client *client,
struct qemud_client_message *msg);
/*
* @server: the unlocked server object
* @client: the locked client object
* @msg: the complete incoming message packet, with header already decoded
*
* This function gets called from qemud when it pulls a incoming
* remote protocol messsage off the dispatch queue for processing.
*
* The @msg parameter must have had its header decoded already by
* calling remoteDecodeClientMessageHeader
*
* Returns 0 if the message was dispatched, -1 upon fatal error
*/
int
remoteDispatchClientRequest (struct qemud_server *server,
struct qemud_client *client,
struct qemud_client_message *msg)
{
remote_error rerr;
memset(&rerr, 0, sizeof rerr);
/* Check version, etc. */
if (msg->hdr.prog != REMOTE_PROGRAM) {
remoteDispatchFormatError (&rerr,
_("program mismatch (actual %x, expected %x)"),
msg->hdr.prog, REMOTE_PROGRAM);
goto error;
}
if (msg->hdr.vers != REMOTE_PROTOCOL_VERSION) {
remoteDispatchFormatError (&rerr,
_("version mismatch (actual %x, expected %x)"),
msg->hdr.vers, REMOTE_PROTOCOL_VERSION);
goto error;
}
switch (msg->hdr.type) {
case REMOTE_CALL:
return remoteDispatchClientCall(server, client, msg);
default:
remoteDispatchFormatError (&rerr, _("type (%d) != REMOTE_CALL"),
(int) msg->hdr.type);
}
error:
return remoteSerializeReplyError(client, &rerr, &msg->hdr);
}
/*
* @server: the unlocked server object
* @client: the locked client object
* @msg: the complete incoming method call, with header already decoded
*
* This method is used to dispatch an message representing an
* incoming method call from a client. It decodes the payload
* to obtain method call arguments, invokves the method and
* then sends a reply packet with the return values
*
* Returns 0 if the reply was sent, or -1 upon fatal error
*/
int
remoteDispatchClientCall (struct qemud_server *server,
struct qemud_client *client,
struct qemud_client_message *msg)
{
XDR xdr;
remote_error rerr;
dispatch_args args;
dispatch_ret ret;
const dispatch_data *data = NULL;
int rv = -1;
unsigned int len;
virConnectPtr conn = NULL;
memset(&args, 0, sizeof args);
memset(&ret, 0, sizeof ret);
memset(&rerr, 0, sizeof rerr);
if (msg->hdr.status != REMOTE_OK) {
remoteDispatchFormatError (&rerr, _("status (%d) != REMOTE_OK"),
(int) msg->hdr.status);
goto rpc_error;
}
/* If client is marked as needing auth, don't allow any RPC ops,
* except for authentication ones
*/
if (client->auth) {
if (msg->hdr.proc != REMOTE_PROC_AUTH_LIST &&
msg->hdr.proc != REMOTE_PROC_AUTH_SASL_INIT &&
msg->hdr.proc != REMOTE_PROC_AUTH_SASL_START &&
msg->hdr.proc != REMOTE_PROC_AUTH_SASL_STEP &&
msg->hdr.proc != REMOTE_PROC_AUTH_POLKIT
) {
/* Explicitly *NOT* calling remoteDispatchAuthError() because
we want back-compatability with libvirt clients which don't
support the VIR_ERR_AUTH_FAILED error code */
remoteDispatchFormatError (&rerr, "%s", _("authentication required"));
goto rpc_error;
}
}
data = remoteGetDispatchData(msg->hdr.proc);
if (!data) {
remoteDispatchFormatError (&rerr, _("unknown procedure: %d"),
msg->hdr.proc);
goto rpc_error;
}
/* De-serialize payload with args from the wire message */
xdrmem_create (&xdr,
msg->buffer + msg->bufferOffset,
msg->bufferLength - msg->bufferOffset,
XDR_DECODE);
if (!((data->args_filter)(&xdr, &args))) {
xdr_destroy (&xdr);
remoteDispatchFormatError (&rerr, "%s", _("parse args failed"));
goto rpc_error;
}
xdr_destroy (&xdr);
/* Call function. */
conn = client->conn;
virMutexUnlock(&client->lock);
/*
* When the RPC handler is called:
*
* - Server object is unlocked
* - Client object is unlocked
*
* Without locking, it is safe to use:
*
* 'conn', 'rerr', 'args and 'ret'
*/
rv = (data->fn)(server, client, conn, &rerr, &args, &ret);
virMutexLock(&server->lock);
virMutexLock(&client->lock);
virMutexUnlock(&server->lock);
xdr_free (data->args_filter, (char*)&args);
if (rv < 0)
goto rpc_error;
/* Return header. We're re-using same message object, so
* only need to tweak type/status fields */
/*msg->hdr.prog = msg->hdr.prog;*/
/*msg->hdr.vers = msg->hdr.vers;*/
/*msg->hdr.proc = msg->hdr.proc;*/
msg->hdr.type = REMOTE_REPLY;
/*msg->hdr.serial = msg->hdr.serial;*/
msg->hdr.status = REMOTE_OK;
if (remoteEncodeClientMessageHeader(msg) < 0) {
xdr_free (data->ret_filter, (char*)&ret);
goto fatal_error;
}
/* Now for the payload */
xdrmem_create (&xdr,
msg->buffer,
msg->bufferLength,
XDR_ENCODE);
if (xdr_setpos(&xdr, msg->bufferOffset) == 0)
goto xdr_error;
/* If OK, serialise return structure, if error serialise error. */
/* Serialise reply data */
if (!((data->ret_filter) (&xdr, &ret)))
goto xdr_error;
/* Update the length word. */
msg->bufferOffset += xdr_getpos (&xdr);
len = msg->bufferOffset;
if (xdr_setpos (&xdr, 0) == 0)
goto xdr_error;
if (!xdr_u_int (&xdr, &len))
goto xdr_error;
xdr_destroy (&xdr);
xdr_free (data->ret_filter, (char*)&ret);
/* Reset ready for I/O */
msg->bufferLength = len;
msg->bufferOffset = 0;
/* Put reply on end of tx queue to send out */
qemudClientMessageQueuePush(&client->tx, msg);
qemudUpdateClientEvent(client);
return 0;
rpc_error:
/* Semi-bad stuff happened, we can still try to send back
* an RPC error message to client */
return remoteSerializeReplyError(client, &rerr, &msg->hdr);
xdr_error:
/* Seriously bad stuff happened, so we'll kill off this client
and not send back any RPC error */
xdr_free (data->ret_filter, (char*)&ret);
xdr_destroy (&xdr);
fatal_error:
return -1;
}
daemon/dispatch.h
+63
View File
@@ -0,0 +1,63 @@
/*
* dispatch.h: RPC message dispatching infrastructure
*
* Copyright (C) 2007, 2008, 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Richard W.M. Jones <rjones@redhat.com>
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef __LIBVIRTD_DISPATCH_H__
#define __LIBVIRTD_DISPATCH_H__
#include "qemud.h"
int
remoteDecodeClientMessageHeader (struct qemud_client_message *req);
int
remoteEncodeClientMessageHeader (struct qemud_client_message *req);
int
remoteDispatchClientRequest (struct qemud_server *server,
struct qemud_client *client,
struct qemud_client_message *req);
void remoteDispatchFormatError (remote_error *rerr,
const char *fmt, ...)
ATTRIBUTE_FMT_PRINTF(2, 3);
void remoteDispatchAuthError (remote_error *rerr);
void remoteDispatchGenericError (remote_error *rerr);
void remoteDispatchOOMError (remote_error *rerr);
void remoteDispatchConnError (remote_error *rerr,
virConnectPtr conn);
/* Having this here is dubious. It should be in remote.h
* but qemud.c shouldn't depend on that header directly.
* Refactor this later to deal with this properly.
*/
int remoteRelayDomainEvent (virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainPtr dom,
int event,
int detail,
void *opaque);
#endif /* __LIBVIRTD_DISPATCH_H__ */
daemon/event.c
+707
View File
@@ -0,0 +1,707 @@
/*
* event.c: event loop for monitoring file handles
*
* Copyright (C) 2007 Daniel P. Berrange
* Copyright (C) 2007 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#include <config.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
#include "threads.h"
#include "logging.h"
#include "event.h"
#include "memory.h"
#include "util.h"
#define EVENT_DEBUG(fmt, ...) DEBUG(fmt, __VA_ARGS__)
static int virEventInterruptLocked(void);
/* State for a single file handle being monitored */
struct virEventHandle {
int watch;
int fd;
int events;
virEventHandleCallback cb;
virFreeCallback ff;
void *opaque;
int deleted;
};
/* State for a single timer being generated */
struct virEventTimeout {
int timer;
int frequency;
unsigned long long expiresAt;
virEventTimeoutCallback cb;
virFreeCallback ff;
void *opaque;
int deleted;
};
/* Allocate extra slots for virEventHandle/virEventTimeout
records in this multiple */
#define EVENT_ALLOC_EXTENT 10
/* State for the main event loop */
struct virEventLoop {
pthread_mutex_t lock;
int running;
pthread_t leader;
int wakeupfd[2];
int handlesCount;
int handlesAlloc;
struct virEventHandle *handles;
int timeoutsCount;
int timeoutsAlloc;
struct virEventTimeout *timeouts;
};
/* Only have one event loop */
static struct virEventLoop eventLoop;
/* Unique ID for the next FD watch to be registered */
static int nextWatch = 1;
/* Unique ID for the next timer to be registered */
static int nextTimer = 1;
static void virEventLock(void)
{
pthread_mutex_lock(&eventLoop.lock);
}
static void virEventUnlock(void)
{
pthread_mutex_unlock(&eventLoop.lock);
}
/*
* Register a callback for monitoring file handle events.
* NB, it *must* be safe to call this from within a callback
* For this reason we only ever append to existing list.
*/
int virEventAddHandleImpl(int fd, int events,
virEventHandleCallback cb,
void *opaque,
virFreeCallback ff) {
int watch;
EVENT_DEBUG("Add handle fd=%d events=%d cb=%p opaque=%p", fd, events, cb, opaque);
virEventLock();
if (eventLoop.handlesCount == eventLoop.handlesAlloc) {
EVENT_DEBUG("Used %d handle slots, adding %d more",
eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT);
if (VIR_REALLOC_N(eventLoop.handles,
(eventLoop.handlesAlloc + EVENT_ALLOC_EXTENT)) < 0) {
virEventUnlock();
return -1;
}
eventLoop.handlesAlloc += EVENT_ALLOC_EXTENT;
}
watch = nextWatch++;
eventLoop.handles[eventLoop.handlesCount].watch = watch;
eventLoop.handles[eventLoop.handlesCount].fd = fd;
eventLoop.handles[eventLoop.handlesCount].events =
virEventHandleTypeToPollEvent(events);
eventLoop.handles[eventLoop.handlesCount].cb = cb;
eventLoop.handles[eventLoop.handlesCount].ff = ff;
eventLoop.handles[eventLoop.handlesCount].opaque = opaque;
eventLoop.handles[eventLoop.handlesCount].deleted = 0;
eventLoop.handlesCount++;
virEventInterruptLocked();
virEventUnlock();
return watch;
}
void virEventUpdateHandleImpl(int watch, int events) {
int i;
EVENT_DEBUG("Update handle w=%d e=%d", watch, events);
if (watch <= 0) {
VIR_WARN("Ignoring invalid update watch %d", watch);
return;
}
virEventLock();
for (i = 0 ; i < eventLoop.handlesCount ; i++) {
if (eventLoop.handles[i].watch == watch) {
eventLoop.handles[i].events =
virEventHandleTypeToPollEvent(events);
virEventInterruptLocked();
break;
}
}
virEventUnlock();
}
/*
* Unregister a callback from a file handle
* NB, it *must* be safe to call this from within a callback
* For this reason we only ever set a flag in the existing list.
* Actual deletion will be done out-of-band
*/
int virEventRemoveHandleImpl(int watch) {
int i;
EVENT_DEBUG("Remove handle w=%d", watch);
if (watch <= 0) {
VIR_WARN("Ignoring invalid remove watch %d", watch);
return -1;
}
virEventLock();
for (i = 0 ; i < eventLoop.handlesCount ; i++) {
if (eventLoop.handles[i].deleted)
continue;
if (eventLoop.handles[i].watch == watch) {
EVENT_DEBUG("mark delete %d %d", i, eventLoop.handles[i].fd);
eventLoop.handles[i].deleted = 1;
virEventInterruptLocked();
virEventUnlock();
return 0;
}
}
virEventUnlock();
return -1;
}
/*
* Register a callback for a timer event
* NB, it *must* be safe to call this from within a callback
* For this reason we only ever append to existing list.
*/
int virEventAddTimeoutImpl(int frequency,
virEventTimeoutCallback cb,
void *opaque,
virFreeCallback ff) {
struct timeval now;
int ret;
EVENT_DEBUG("Adding timer %d with %d ms freq", nextTimer, frequency);
if (gettimeofday(&now, NULL) < 0) {
return -1;
}
virEventLock();
if (eventLoop.timeoutsCount == eventLoop.timeoutsAlloc) {
EVENT_DEBUG("Used %d timeout slots, adding %d more",
eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT);
if (VIR_REALLOC_N(eventLoop.timeouts,
(eventLoop.timeoutsAlloc + EVENT_ALLOC_EXTENT)) < 0) {
virEventUnlock();
return -1;
}
eventLoop.timeoutsAlloc += EVENT_ALLOC_EXTENT;
}
eventLoop.timeouts[eventLoop.timeoutsCount].timer = nextTimer++;
eventLoop.timeouts[eventLoop.timeoutsCount].frequency = frequency;
eventLoop.timeouts[eventLoop.timeoutsCount].cb = cb;
eventLoop.timeouts[eventLoop.timeoutsCount].ff = ff;
eventLoop.timeouts[eventLoop.timeoutsCount].opaque = opaque;
eventLoop.timeouts[eventLoop.timeoutsCount].deleted = 0;
eventLoop.timeouts[eventLoop.timeoutsCount].expiresAt =
frequency >= 0 ? frequency +
(((unsigned long long)now.tv_sec)*1000) +
(((unsigned long long)now.tv_usec)/1000) : 0;
eventLoop.timeoutsCount++;
ret = nextTimer-1;
virEventInterruptLocked();
virEventUnlock();
return ret;
}
void virEventUpdateTimeoutImpl(int timer, int frequency) {
struct timeval tv;
int i;
EVENT_DEBUG("Updating timer %d timeout with %d ms freq", timer, frequency);
if (timer <= 0) {
VIR_WARN("Ignoring invalid update timer %d", timer);
return;
}
if (gettimeofday(&tv, NULL) < 0) {
return;
}
virEventLock();
for (i = 0 ; i < eventLoop.timeoutsCount ; i++) {
if (eventLoop.timeouts[i].timer == timer) {
eventLoop.timeouts[i].frequency = frequency;
eventLoop.timeouts[i].expiresAt =
frequency >= 0 ? frequency +
(((unsigned long long)tv.tv_sec)*1000) +
(((unsigned long long)tv.tv_usec)/1000) : 0;
virEventInterruptLocked();
break;
}
}
virEventUnlock();
}
/*
* Unregister a callback for a timer
* NB, it *must* be safe to call this from within a callback
* For this reason we only ever set a flag in the existing list.
* Actual deletion will be done out-of-band
*/
int virEventRemoveTimeoutImpl(int timer) {
int i;
EVENT_DEBUG("Remove timer %d", timer);
if (timer <= 0) {
VIR_WARN("Ignoring invalid remove timer %d", timer);
return -1;
}
virEventLock();
for (i = 0 ; i < eventLoop.timeoutsCount ; i++) {
if (eventLoop.timeouts[i].deleted)
continue;
if (eventLoop.timeouts[i].timer == timer) {
eventLoop.timeouts[i].deleted = 1;
virEventInterruptLocked();
virEventUnlock();
return 0;
}
}
virEventUnlock();
return -1;
}
/* Iterates over all registered timeouts and determine which
* will be the first to expire.
* @timeout: filled with expiry time of soonest timer, or -1 if
* no timeout is pending
* returns: 0 on success, -1 on error
*/
static int virEventCalculateTimeout(int *timeout) {
unsigned long long then = 0;
int i;
EVENT_DEBUG("Calculate expiry of %d timers", eventLoop.timeoutsCount);
/* Figure out if we need a timeout */
for (i = 0 ; i < eventLoop.timeoutsCount ; i++) {
if (eventLoop.timeouts[i].frequency < 0)
continue;
EVENT_DEBUG("Got a timeout scheduled for %llu", eventLoop.timeouts[i].expiresAt);
if (then == 0 ||
eventLoop.timeouts[i].expiresAt < then)
then = eventLoop.timeouts[i].expiresAt;
}
/* Calculate how long we should wait for a timeout if needed */
if (then > 0) {
struct timeval tv;
if (gettimeofday(&tv, NULL) < 0) {
return -1;
}
*timeout = then -
((((unsigned long long)tv.tv_sec)*1000) +
(((unsigned long long)tv.tv_usec)/1000));
if (*timeout < 0)
*timeout = 0;
} else {
*timeout = -1;
}
EVENT_DEBUG("Timeout at %llu due in %d ms", then, *timeout);
return 0;
}
/*
* Allocate a pollfd array containing data for all registered
* file handles. The caller must free the returned data struct
* returns: the pollfd array, or NULL on error
*/
static struct pollfd *virEventMakePollFDs(int *nfds) {
struct pollfd *fds;
int i;
*nfds = 0;
for (i = 0 ; i < eventLoop.handlesCount ; i++) {
if (eventLoop.handles[i].events)
(*nfds)++;
}
/* Setup the poll file handle data structs */
if (VIR_ALLOC_N(fds, *nfds) < 0)
return NULL;
*nfds = 0;
for (i = 0 ; i < eventLoop.handlesCount ; i++) {
EVENT_DEBUG("Prepare n=%d w=%d, f=%d e=%d", i,
eventLoop.handles[i].watch,
eventLoop.handles[i].fd,
eventLoop.handles[i].events);
if (!eventLoop.handles[i].events)
continue;
fds[*nfds].fd = eventLoop.handles[i].fd;
fds[*nfds].events = eventLoop.handles[i].events;
fds[*nfds].revents = 0;
(*nfds)++;
//EVENT_DEBUG("Wait for %d %d", eventLoop.handles[i].fd, eventLoop.handles[i].events);
}
return fds;
}
/*
* Iterate over all timers and determine if any have expired.
* Invoke the user supplied callback for each timer whose
* expiry time is met, and schedule the next timeout. Does
* not try to 'catch up' on time if the actual expiry time
* was later than the requested time.
*
* This method must cope with new timers being registered
* by a callback, and must skip any timers marked as deleted.
*
* Returns 0 upon success, -1 if an error occurred
*/
static int virEventDispatchTimeouts(void) {
struct timeval tv;
unsigned long long now;
int i;
/* Save this now - it may be changed during dispatch */
int ntimeouts = eventLoop.timeoutsCount;
DEBUG("Dispatch %d", ntimeouts);
if (gettimeofday(&tv, NULL) < 0) {
return -1;
}
now = (((unsigned long long)tv.tv_sec)*1000) +
(((unsigned long long)tv.tv_usec)/1000);
for (i = 0 ; i < ntimeouts ; i++) {
if (eventLoop.timeouts[i].deleted || eventLoop.timeouts[i].frequency < 0)
continue;
if (eventLoop.timeouts[i].expiresAt <= now) {
virEventTimeoutCallback cb = eventLoop.timeouts[i].cb;
int timer = eventLoop.timeouts[i].timer;
void *opaque = eventLoop.timeouts[i].opaque;
eventLoop.timeouts[i].expiresAt =
now + eventLoop.timeouts[i].frequency;
virEventUnlock();
(cb)(timer, opaque);
virEventLock();
}
}
return 0;
}
/* Iterate over all file handles and dispatch any which
* have pending events listed in the poll() data. Invoke
* the user supplied callback for each handle which has
* pending events
*
* This method must cope with new handles being registered
* by a callback, and must skip any handles marked as deleted.
*
* Returns 0 upon success, -1 if an error occurred
*/
static int virEventDispatchHandles(int nfds, struct pollfd *fds) {
int i, n;
DEBUG("Dispatch %d", nfds);
/* NB, use nfds not eventLoop.handlesCount, because new
* fds might be added on end of list, and they're not
* in the fds array we've got */
for (i = 0, n = 0 ; n < nfds && i < eventLoop.handlesCount ; n++) {
while ((eventLoop.handles[i].fd != fds[n].fd ||
eventLoop.handles[i].events == 0) &&
i < eventLoop.handlesCount) {
i++;
}
if (i == eventLoop.handlesCount)
break;
DEBUG("i=%d w=%d", i, eventLoop.handles[i].watch);
if (eventLoop.handles[i].deleted) {
EVENT_DEBUG("Skip deleted n=%d w=%d f=%d", i,
eventLoop.handles[i].watch, eventLoop.handles[i].fd);
continue;
}
if (fds[n].revents) {
virEventHandleCallback cb = eventLoop.handles[i].cb;
void *opaque = eventLoop.handles[i].opaque;
int hEvents = virPollEventToEventHandleType(fds[n].revents);
EVENT_DEBUG("Dispatch n=%d f=%d w=%d e=%d %p", i,
fds[n].fd, eventLoop.handles[i].watch,
fds[n].revents, eventLoop.handles[i].opaque);
virEventUnlock();
(cb)(eventLoop.handles[i].watch,
fds[n].fd, hEvents, opaque);
virEventLock();
}
}
return 0;
}
/* Used post dispatch to actually remove any timers that
* were previously marked as deleted. This asynchronous
* cleanup is needed to make dispatch re-entrant safe.
*/
static int virEventCleanupTimeouts(void) {
int i;
DEBUG("Cleanup %d", eventLoop.timeoutsCount);
/* Remove deleted entries, shuffling down remaining
* entries as needed to form contiguous series
*/
for (i = 0 ; i < eventLoop.timeoutsCount ; ) {
if (!eventLoop.timeouts[i].deleted) {
i++;
continue;
}
EVENT_DEBUG("Purging timeout %d with id %d", i, eventLoop.timeouts[i].timer);
if (eventLoop.timeouts[i].ff)
(eventLoop.timeouts[i].ff)(eventLoop.timeouts[i].opaque);
if ((i+1) < eventLoop.timeoutsCount) {
memmove(eventLoop.timeouts+i,
eventLoop.timeouts+i+1,
sizeof(struct virEventTimeout)*(eventLoop.timeoutsCount-(i+1)));
}
eventLoop.timeoutsCount--;
}
/* Release some memory if we've got a big chunk free */
if ((eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT) > eventLoop.timeoutsCount) {
EVENT_DEBUG("Releasing %d out of %d timeout slots used, releasing %d",
eventLoop.timeoutsCount, eventLoop.timeoutsAlloc, EVENT_ALLOC_EXTENT);
if (VIR_REALLOC_N(eventLoop.timeouts,
(eventLoop.timeoutsAlloc - EVENT_ALLOC_EXTENT)) < 0)
return -1;
eventLoop.timeoutsAlloc -= EVENT_ALLOC_EXTENT;
}
return 0;
}
/* Used post dispatch to actually remove any handles that
* were previously marked as deleted. This asynchronous
* cleanup is needed to make dispatch re-entrant safe.
*/
static int virEventCleanupHandles(void) {
int i;
DEBUG("Cleanupo %d", eventLoop.handlesCount);
/* Remove deleted entries, shuffling down remaining
* entries as needed to form contiguous series
*/
for (i = 0 ; i < eventLoop.handlesCount ; ) {
if (!eventLoop.handles[i].deleted) {
i++;
continue;
}
if (eventLoop.handles[i].ff)
(eventLoop.handles[i].ff)(eventLoop.handles[i].opaque);
if ((i+1) < eventLoop.handlesCount) {
memmove(eventLoop.handles+i,
eventLoop.handles+i+1,
sizeof(struct virEventHandle)*(eventLoop.handlesCount-(i+1)));
}
eventLoop.handlesCount--;
}
/* Release some memory if we've got a big chunk free */
if ((eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT) > eventLoop.handlesCount) {
EVENT_DEBUG("Releasing %d out of %d handles slots used, releasing %d",
eventLoop.handlesCount, eventLoop.handlesAlloc, EVENT_ALLOC_EXTENT);
if (VIR_REALLOC_N(eventLoop.handles,
(eventLoop.handlesAlloc - EVENT_ALLOC_EXTENT)) < 0)
return -1;
eventLoop.handlesAlloc -= EVENT_ALLOC_EXTENT;
}
return 0;
}
/*
* Run a single iteration of the event loop, blocking until
* at least one file handle has an event, or a timer expires
*/
int virEventRunOnce(void) {
struct pollfd *fds = NULL;
int ret, timeout, nfds;
virEventLock();
eventLoop.running = 1;
eventLoop.leader = pthread_self();
if (virEventCleanupTimeouts() < 0 ||
virEventCleanupHandles() < 0)
goto error;
if (!(fds = virEventMakePollFDs(&nfds)) ||
virEventCalculateTimeout(&timeout) < 0)
goto error;
virEventUnlock();
retry:
EVENT_DEBUG("Poll on %d handles %p timeout %d", nfds, fds, timeout);
ret = poll(fds, nfds, timeout);
EVENT_DEBUG("Poll got %d event", ret);
if (ret < 0) {
if (errno == EINTR) {
goto retry;
}
goto error_unlocked;
}
virEventLock();
if (virEventDispatchTimeouts() < 0)
goto error;
if (ret > 0 &&
virEventDispatchHandles(nfds, fds) < 0)
goto error;
if (virEventCleanupTimeouts() < 0 ||
virEventCleanupHandles() < 0)
goto error;
eventLoop.running = 0;
virEventUnlock();
VIR_FREE(fds);
return 0;
error:
virEventUnlock();
error_unlocked:
VIR_FREE(fds);
return -1;
}
static void virEventHandleWakeup(int watch ATTRIBUTE_UNUSED,
int fd,
int events ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
{
char c;
virEventLock();
saferead(fd, &c, sizeof(c));
virEventUnlock();
}
int virEventInit(void)
{
if (pthread_mutex_init(&eventLoop.lock, NULL) != 0)
return -1;
if (pipe(eventLoop.wakeupfd) < 0 ||
virSetNonBlock(eventLoop.wakeupfd[0]) < 0 ||
virSetNonBlock(eventLoop.wakeupfd[1]) < 0 ||
virSetCloseExec(eventLoop.wakeupfd[0]) < 0 ||
virSetCloseExec(eventLoop.wakeupfd[1]) < 0)
return -1;
if (virEventAddHandleImpl(eventLoop.wakeupfd[0],
VIR_EVENT_HANDLE_READABLE,
virEventHandleWakeup, NULL, NULL) < 0)
return -1;
return 0;
}
static int virEventInterruptLocked(void)
{
char c = '\0';
if (!eventLoop.running ||
pthread_self() == eventLoop.leader) {
VIR_DEBUG("Skip interrupt, %d %d", eventLoop.running, (int)eventLoop.leader);
return 0;
}
VIR_DEBUG0("Interrupting");
if (safewrite(eventLoop.wakeupfd[1], &c, sizeof(c)) != sizeof(c))
return -1;
return 0;
}
int virEventInterrupt(void)
{
int ret;
virEventLock();
ret = virEventInterruptLocked();
virEventUnlock();
return ret;
}
int
virEventHandleTypeToPollEvent(int events)
{
int ret = 0;
if(events & VIR_EVENT_HANDLE_READABLE)
ret |= POLLIN;
if(events & VIR_EVENT_HANDLE_WRITABLE)
ret |= POLLOUT;
if(events & VIR_EVENT_HANDLE_ERROR)
ret |= POLLERR;
if(events & VIR_EVENT_HANDLE_HANGUP)
ret |= POLLHUP;
return ret;
}
int
virPollEventToEventHandleType(int events)
{
int ret = 0;
if(events & POLLIN)
ret |= VIR_EVENT_HANDLE_READABLE;
if(events & POLLOUT)
ret |= VIR_EVENT_HANDLE_WRITABLE;
if(events & POLLERR)
ret |= VIR_EVENT_HANDLE_ERROR;
if(events & POLLNVAL) /* Treat NVAL as error, since libvirt doesn't distinguish */
ret |= VIR_EVENT_HANDLE_ERROR;
if(events & POLLHUP)
ret |= VIR_EVENT_HANDLE_HANGUP;
return ret;
}
daemon/event.h
+134
View File
@@ -0,0 +1,134 @@
/*
* event.h: event loop for monitoring file handles
*
* Copyright (C) 2007 Daniel P. Berrange
* Copyright (C) 2007 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef __VIRTD_EVENT_H__
#define __VIRTD_EVENT_H__
#include "internal.h"
/**
* virEventAddHandleImpl: register a callback for monitoring file handle events
*
* @fd: file handle to monitor for events
* @events: bitset of events to watch from POLLnnn constants
* @cb: callback to invoke when an event occurs
* @opaque: user data to pass to callback
*
* returns -1 if the file handle cannot be registered, 0 upon success
*/
int virEventAddHandleImpl(int fd, int events,
virEventHandleCallback cb,
void *opaque,
virFreeCallback ff);
/**
* virEventUpdateHandleImpl: change event set for a monitored file handle
*
* @watch: watch whose handle to update
* @events: bitset of events to watch from POLLnnn constants
*
* Will not fail if fd exists
*/
void virEventUpdateHandleImpl(int watch, int events);
/**
* virEventRemoveHandleImpl: unregister a callback from a file handle
*
* @watch: watch whose handle to remove
*
* returns -1 if the file handle was not registered, 0 upon success
*/
int virEventRemoveHandleImpl(int watch);
/**
* virEventAddTimeoutImpl: register a callback for a timer event
*
* @frequency: time between events in milliseconds
* @cb: callback to invoke when an event occurs
* @opaque: user data to pass to callback
*
* Setting frequency to -1 will disable the timer. Setting the frequency
* to zero will cause it to fire on every event loop iteration.
*
* returns -1 if the file handle cannot be registered, a positive
* integer timer id upon success
*/
int virEventAddTimeoutImpl(int frequency,
virEventTimeoutCallback cb,
void *opaque,
virFreeCallback ff);
/**
* virEventUpdateTimeoutImpl: change frequency for a timer
*
* @timer: timer id to change
* @frequency: time between events in milliseconds
*
* Setting frequency to -1 will disable the timer. Setting the frequency
* to zero will cause it to fire on every event loop iteration.
*
* Will not fail if timer exists
*/
void virEventUpdateTimeoutImpl(int timer, int frequency);
/**
* virEventRemoveTimeoutImpl: unregister a callback for a timer
*
* @timer: the timer id to remove
*
* returns -1 if the timer was not registered, 0 upon success
*/
int virEventRemoveTimeoutImpl(int timer);
/**
* virEventInit: Initialize the event loop
*
* returns -1 if initialization failed
*/
int virEventInit(void);
/**
* virEventRunOnce: run a single iteration of the event loop.
*
* Blocks the caller until at least one file handle has an
* event or the first timer expires.
*
* returns -1 if the event monitoring failed
*/
int virEventRunOnce(void);
int
virEventHandleTypeToPollEvent(int events);
int
virPollEventToEventHandleType(int events);
/**
* virEventInterrupt: wakeup any thread waiting in poll()
*
* return -1 if wakup failed
*/
int virEventInterrupt(void);
#endif /* __VIRTD_EVENT_H__ */
daemon/libvirtd.aug
+82
View File
@@ -0,0 +1,82 @@
(* /etc/libvirt/libvirtd.conf *)
module Libvirtd =
autoload xfm
let eol = del /[ \t]*\n/ "\n"
let value_sep = del /[ \t]*=[ \t]*/ " = "
let indent = del /[ \t]*/ ""
let array_sep = del /,[ \t\n]*/ ", "
let array_start = del /\[[ \t\n]*/ "[ "
let array_end = del /\]/ "]"
let str_val = del /\"/ "\"" . store /[^\"]*/ . del /\"/ "\""
let bool_val = store /0|1/
let int_val = store /[0-9]+/
let str_array_element = [ seq "el" . str_val ] . del /[ \t\n]*/ ""
let str_array_val = counter "el" . array_start . ( str_array_element . ( array_sep . str_array_element ) * ) ? . array_end
let str_entry (kw:string) = [ key kw . value_sep . str_val ]
let bool_entry (kw:string) = [ key kw . value_sep . bool_val ]
let int_entry (kw:string) = [ key kw . value_sep . int_val ]
let str_array_entry (kw:string) = [ key kw . value_sep . str_array_val ]
(* Config entry grouped by function - same order as example config *)
let network_entry = bool_entry "listen_tls"
| bool_entry "listen_tcp"
| str_entry "tls_port"
| str_entry "tcp_port"
| str_entry "listen_addr"
| bool_entry "mdns_adv"
| str_entry "mdns_name"
let sock_acl_entry = str_entry "unix_sock_group"
| str_entry "unix_sock_ro_perms"
| str_entry "unix_sock_rw_perms"
| str_entry "unix_sock_dir"
let authentication_entry = str_entry "auth_unix_ro"
| str_entry "auth_unix_rw"
| str_entry "auth_tcp"
| str_entry "auth_tls"
let certificate_entry = str_entry "key_file"
| str_entry "cert_file"
| str_entry "ca_file"
| str_entry "crl_file"
let authorization_entry = bool_entry "tls_no_verify_certificate"
| str_array_entry "tls_allowed_dn_list"
| str_array_entry "sasl_allowed_username_list"
let processing_entry = int_entry "min_workers"
| int_entry "max_workers"
| int_entry "max_clients"
| int_entry "max_requests"
| int_entry "max_client_requests"
let logging_entry = int_entry "log_level"
| str_entry "log_filters"
| str_entry "log_outputs"
(* Each enty in the config is one of the following three ... *)
let entry = network_entry
| sock_acl_entry
| authentication_entry
| certificate_entry
| authorization_entry
| processing_entry
| logging_entry
let comment = [ label "#comment" . del /#[ \t]*/ "# " . store /([^ \t\n][^\n]*)?/ . del /\n/ "\n" ]
let empty = [ label "#empty" . eol ]
let record = indent . entry . eol
let lns = ( record | comment | empty ) *
let filter = incl "/etc/libvirt/libvirtd.conf"
. Util.stdexcl
let xfm = transform lns filter
daemon/libvirtd.conf
+314
View File
@@ -0,0 +1,314 @@
# Master libvirt daemon configuration file
#
# For further information consult http://libvirt.org/format.html
#
# NOTE: the tests/daemon-conf regression test script requires
# that each "PARAMETER = VALUE" line in this file have the parameter
# name just after a leading "#".
#################################################################
#
# Network connectivity controls
#
# Flag listening for secure TLS connections on the public TCP/IP port.
# NB, must pass the --listen flag to the libvirtd process for this to
# have any effect.
#
# It is necessary to setup a CA and issue server certificates before
# using this capability.
#
# This is enabled by default, uncomment this to disable it
#listen_tls = 0
# Listen for unencrypted TCP connections on the public TCP/IP port.
# NB, must pass the --listen flag to the libvirtd process for this to
# have any effect.
#
# Using the TCP socket requires SASL authentication by default. Only
# SASL mechanisms which support data encryption are allowed. This is
# DIGEST_MD5 and GSSAPI (Kerberos5)
#
# This is disabled by default, uncomment this to enable it.
#listen_tcp = 1
# Override the port for accepting secure TLS connections
# This can be a port number, or service name
#
#tls_port = "16514"
# Override the port for accepting insecure TCP connections
# This can be a port number, or service name
#
#tcp_port = "16509"
# Override the default configuration which binds to all network
# interfaces. This can be a numeric IPv4/6 address, or hostname
#
#listen_addr = "192.168.0.1"
# Flag toggling mDNS advertizement of the libvirt service.
#
# Alternatively can disable for all services on a host by
# stopping the Avahi daemon
#
# This is enabled by default, uncomment this to disable it
#mdns_adv = 0
# Override the default mDNS advertizement name. This must be
# unique on the immediate broadcast network.
#
# The default is "Virtualization Host HOSTNAME", where HOSTNAME
# is subsituted for the short hostname of the machine (without domain)
#
#mdns_name = "Virtualization Host Joe Demo"
#################################################################
#
# UNIX socket access controls
#
# Set the UNIX domain socket group ownership. This can be used to
# allow a 'trusted' set of users access to management capabilities
# without becoming root.
#
# This is restricted to 'root' by default.
#unix_sock_group = "libvirt"
# Set the UNIX socket permissions for the R/O socket. This is used
# for monitoring VM status only
#
# Default allows any user. If setting group ownership may want to
# restrict this to:
#unix_sock_ro_perms = "0777"
# Set the UNIX socket permissions for the R/W socket. This is used
# for full management of VMs
#
# Default allows only root. If PolicyKit is enabled on the socket,
# the default will change to allow everyone (eg, 0777)
#
# If not using PolicyKit and setting group ownership for access
# control then you may want to relax this to:
#unix_sock_rw_perms = "0770"
# Set the name of the directory in which sockets will be found/created.
#unix_sock_dir = "/var/run/libvirt"
#################################################################
#
# Authentication.
#
# - none: do not perform auth checks. If you can connect to the
# socket you are allowed. This is suitable if there are
# restrictions on connecting to the socket (eg, UNIX
# socket permissions), or if there is a lower layer in
# the network providing auth (eg, TLS/x509 certificates)
#
# - sasl: use SASL infrastructure. The actual auth scheme is then
# controlled from /etc/sasl2/libvirt.conf. For the TCP
# socket only GSSAPI & DIGEST-MD5 mechanisms will be used.
# For non-TCP or TLS sockets, any scheme is allowed.
#
# - polkit: use PolicyKit to authenticate. This is only suitable
# for use on the UNIX sockets. The default policy will
# require a user to supply their own password to gain
# full read/write access (aka sudo like), while anyone
# is allowed read/only access.
#
# Set an authentication scheme for UNIX read-only sockets
# By default socket permissions allow anyone to connect
#
# To restrict monitoring of domains you may wish to enable
# an authentication mechanism here
#auth_unix_ro = "none"
# Set an authentication scheme for UNIX read-write sockets
# By default socket permissions only allow root. If PolicyKit
# support was compiled into libvirt, the default will be to
# use 'polkit' auth.
#
# If the unix_sock_rw_perms are changed you may wish to enable
# an authentication mechanism here
#auth_unix_rw = "none"
# Change the authentication scheme for TCP sockets.
#
# If you don't enable SASL, then all TCP traffic is cleartext.
# Don't do this outside of a dev/test scenario. For real world
# use, always enable SASL and use the GSSAPI or DIGEST-MD5
# mechanism in /etc/sasl2/libvirt.conf
#auth_tcp = "sasl"
# Change the authentication scheme for TLS sockets.
#
# TLS sockets already have encryption provided by the TLS
# layer, and limited authentication is done by certificates
#
# It is possible to make use of any SASL authentication
# mechanism as well, by using 'sasl' for this option
#auth_tls = "none"
#################################################################
#
# TLS x509 certificate configuration
#
# Override the default server key file path
#
#key_file = "/etc/pki/libvirt/private/serverkey.pem"
# Override the default server certificate file path
#
#cert_file = "/etc/pki/libvirt/servercert.pem"
# Override the default CA certificate path
#
#ca_file = "/etc/pki/CA/cacert.pem"
# Specify a certificate revocation list.
#
# Defaults to not using a CRL, uncomment to enable it
#crl_file = "/etc/pki/CA/crl.pem"
#################################################################
#
# Authorization controls
#
# Flag to disable verification of client certificates
#
# Client certificate verification is the primary authentication mechanism.
# Any client which does not present a certificate signed by the CA
# will be rejected.
#
# Default is to always verify. Uncommenting this will disable
# verification - make sure an IP whitelist is set
#tls_no_verify_certificate = 1
# A whitelist of allowed x509 Distinguished Names
# This list may contain wildcards such as
#
# "C=GB,ST=London,L=London,O=Red Hat,CN=*"
#
# See the POSIX fnmatch function for the format of the wildcards.
#
# NB If this is an empty list, no client can connect, so comment out
# entirely rather than using empty list to disable these checks
#
# By default, no DN's are checked
#tls_allowed_dn_list = ["DN1", "DN2"]
# A whitelist of allowed SASL usernames. The format for usernames
# depends on the SASL authentication mechanism. Kerberos usernames
# look like username@REALM
#
# This list may contain wildcards such as
#
# "*@EXAMPLE.COM"
#
# See the POSIX fnmatch function for the format of the wildcards.
#
# NB If this is an empty list, no client can connect, so comment out
# entirely rather than using empty list to disable these checks
#
# By default, no Username's are checked
#sasl_allowed_username_list = ["joe@EXAMPLE.COM", "fred@EXAMPLE.COM" ]
#################################################################
#
# Processing controls
#
# The maximum number of concurrent client connections to allow
# over all sockets combined.
#max_clients = 20
# The minimum limit sets the number of workers to start up
# initially. If the number of active clients exceeds this,
# then more threads are spawned, upto max_workers limit.
# Typically you'd want max_workers to equal maximum number
# of clients allowed
#min_workers = 5
#max_workers = 20
# Total global limit on concurrent RPC calls. Should be
# at least as large as max_workers. Beyond this, RPC requests
# will be read into memory and queued. This directly impact
# memory usage, currently each request requires 256 KB of
# memory. So by default upto 5 MB of memory is used
#
# XXX this isn't actually enforced yet, only the per-client
# limit is used so far
#max_requests = 20
# Limit on concurrent requests from a single client
# connection. To avoid one client monopolizing the server
# this should be a small fraction of the global max_requests
# and max_workers parameter
#max_client_requests = 5
#################################################################
#
# Logging controls
#
# Logging level: 4 errors, 3 warnings, 2 informations, 1 debug
# basically 1 will log everything possible
#log_level = 3
# Logging filters:
# A filter allows to select a different logging level for a given category
# of logs
# The format for a filter is:
# x:name
# where name is a match string e.g. remote or qemu
# the x prefix is the minimal level where matching messages should be logged
# 1: DEBUG
# 2: INFO
# 3: WARNING
# 4: ERROR
#
# Multiple filter can be defined in a single @filters, they just need to be
# separated by spaces.
#
# e.g:
# log_filters="3:remote 4:event"
# to only get warning or errors from the remote layer and only errors from
# the event layer.
# Logging outputs:
# An output is one of the places to save logging informations
# The format for an output can be:
# x:stderr
# output goes to stderr
# x:syslog:name
# use syslog for the output and use the given name as the ident
# x:file:file_path
# output to a file, with the given filepath
# In all case the x prefix is the minimal level, acting as a filter
# 1: DEBUG
# 2: INFO
# 3: WARNING
# 4: ERROR
#
# Multiple output can be defined, they just need to be separated by spaces.
# e.g.:
# log_outputs="3:syslog:libvirtd"
# to log all warnings and errors to syslog under the libvirtd ident
daemon/libvirtd.init.in
+115
View File
@@ -0,0 +1,115 @@
#!/bin/sh
# the following is the LSB init header see
# http://www.linux-foundation.org/spec//booksets/LSB-Core-generic/LSB-Core-generic.html#INITSCRCOMCONV
#
### BEGIN INIT INFO
# Provides: libvirtd
# Required-Start: $network messagebus
# Should-Start: $named
# Should-Start: xend
# Should-Start: hal
# Should-Start: avahi
# Required-Stop: $network messagebus
# Should-Stop: $named
# Default-Start: 3 4 5
# Short-Description: daemon for libvirt virtualization API
# Description: This is a daemon for managing guest instances
# and libvirt virtual networks
# See http://libvirt.org
### END INIT INFO
# the following is chkconfig init header
#
# libvirtd: guest and virtual network management daemon
#
# chkconfig: 345 97 03
# description: This is a daemon for managing guest instances
# and libvirt virtual networks
# See http://libvirt.org
#
# processname: libvirtd
# pidfile: @localstatedir@/run/libvirtd.pid
#
# Sanity checks.
[ -x @sbindir@/libvirtd ] || exit 0
# Source function library.
. @sysconfdir@/rc.d/init.d/functions
SERVICE=libvirtd
PROCESS=libvirtd
LIBVIRTD_CONFIG=
LIBVIRTD_ARGS=
KRB5_KTNAME=/etc/libvirt/krb5.tab
test -f @sysconfdir@/sysconfig/libvirtd && . @sysconfdir@/sysconfig/libvirtd
LIBVIRTD_CONFIG_ARGS=
if [ -n "$LIBVIRTD_CONFIG" ]
then
LIBVIRTD_CONFIG_ARGS="--config $LIBVIRTD_CONFIG"
fi
RETVAL=0
start() {
echo -n $"Starting $SERVICE daemon: "
mkdir -p @localstatedir@/cache/libvirt
rm -rf @localstatedir@/cache/libvirt/*
KRB5_KTNAME=$KRB5_KTNAME daemon --check $SERVICE $PROCESS --daemon $LIBVIRTD_CONFIG_ARGS $LIBVIRTD_ARGS
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch @localstatedir@/lock/subsys/$SERVICE
}
stop() {
echo -n $"Stopping $SERVICE daemon: "
killproc $PROCESS
RETVAL=$?
echo
if [ $RETVAL -eq 0 ]; then
rm -f @localstatedir@/lock/subsys/$SERVICE
rm -f @localstatedir@/run/$SERVICE.pid
rm -rf @localstatedir@/cache/libvirt/*
fi
}
restart() {
stop
start
}
reload() {
echo -n $"Reloading $SERVICE configuration: "
killproc $PROCESS -HUP
RETVAL=$?
echo
return $RETVAL
}
# See how we were called.
case "$1" in
start|stop|restart|reload)
$1
;;
status)
status $PROCESS
RETVAL=$?
;;
force-reload)
reload
;;
condrestart|try-restart)
[ -f @localstatedir@/lock/subsys/$SERVICE ] && restart || :
;;
*)
echo $"Usage: $0 {start|stop|status|restart|condrestart|reload}"
exit 1
;;
esac
exit $RETVAL
daemon/libvirtd.logrotate.in
+8
View File
@@ -0,0 +1,8 @@
@localstatedir@/log/libvirt/qemu/*.log {
daily
missingok
rotate 7
compress
delaycompress
copytruncate
}
daemon/libvirtd.policy-0
+42
View File
@@ -0,0 +1,42 @@
<!DOCTYPE policyconfig PUBLIC
"-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
"http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
<!--
Policy definitions for libvirt daemon
Copyright (c) 2007 Daniel P. Berrange <berrange redhat com>
libvirt is licensed to you under the GNU Lesser General Public License
version 2. See COPYING for details.
NOTE: If you make changes to this file, make sure to validate the file
using the polkit-policy-file-validate(1) tool. Changes made to this
file are instantly applied.
-->
<policyconfig>
<action id="org.libvirt.unix.monitor">
<description>Monitor local virtualized systems</description>
<message>System policy prevents monitoring of local virtualized systems</message>
<defaults>
<!-- Any program can use libvirt in read-only mode for monitoring,
even if not part of a session -->
<allow_any>yes</allow_any>
<allow_inactive>yes</allow_inactive>
<allow_active>yes</allow_active>
</defaults>
</action>
<action id="org.libvirt.unix.manage">
<description>Manage local virtualized systems</description>
<message>System policy prevents management of local virtualized systems</message>
<defaults>
<!-- Only a program in the active host session can use libvirt in
read-write mode for management, and we require user password -->
<allow_any>no</allow_any>
<allow_inactive>no</allow_inactive>
<allow_active>auth_admin_keep_session</allow_active>
</defaults>
</action>
</policyconfig>
daemon/libvirtd.policy-1
+42
View File
@@ -0,0 +1,42 @@
<!DOCTYPE policyconfig PUBLIC
"-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
"http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
<!--
Policy definitions for libvirt daemon
Copyright (c) 2007 Daniel P. Berrange <berrange redhat com>
libvirt is licensed to you under the GNU Lesser General Public License
version 2. See COPYING for details.
NOTE: If you make changes to this file, make sure to validate the file
using the polkit-policy-file-validate(1) tool. Changes made to this
file are instantly applied.
-->
<policyconfig>
<action id="org.libvirt.unix.monitor">
<description>Monitor local virtualized systems</description>
<message>System policy prevents monitoring of local virtualized systems</message>
<defaults>
<!-- Any program can use libvirt in read-only mode for monitoring,
even if not part of a session -->
<allow_any>yes</allow_any>
<allow_inactive>yes</allow_inactive>
<allow_active>yes</allow_active>
</defaults>
</action>
<action id="org.libvirt.unix.manage">
<description>Manage local virtualized systems</description>
<message>System policy prevents management of local virtualized systems</message>
<defaults>
<!-- Only a program in the active host session can use libvirt in
read-write mode for management, and we require user password -->
<allow_any>no</allow_any>
<allow_inactive>no</allow_inactive>
<allow_active>auth_admin_keep</allow_active>
</defaults>
</action>
</policyconfig>
daemon/libvirtd.sasl
+28
View File
@@ -0,0 +1,28 @@
# If you want to use the non-TLS socket, then you *must* include
# the GSSAPI or DIGEST-MD5 mechanisms, because they are the only
# ones that can offer session encryption as well as authentication.
#
# If you're only using TLS, then you can turn on any mechanisms
# you like for authentication, because TLS provides the encryption
#
# Default to a simple username+password mechanism
mech_list: digest-md5
# Before you can use GSSAPI, you need a service principle on the
# KDC server for libvirt, and that to be exported to the keytab
# file listed below
#mech_list: gssapi
#
# You can also list many mechanisms at once, then the user can choose
# by adding '?auth=sasl.gssapi' to their libvirt URI, eg
# qemu+tcp://hostname/system?auth=sasl.gssapi
#mech_list: digest-md5 gssapi
# MIT kerberos ignores this option & needs KRB5_KTNAME env var.
# May be useful for other non-Linux OS though....
keytab: /etc/libvirt/krb5.tab
# If using digest-md5 for username/passwds, then this is the file
# containing the passwds. Use 'saslpasswd2 -a libvirt [username]'
# to add entries, and 'sasldblistusers2 -a libvirt' to browse it
sasldb_path: /etc/libvirt/passwd.db
daemon/libvirtd.sysconf
+9
View File
@@ -0,0 +1,9 @@
# Override the default config file
#LIBVIRTD_CONFIG=/etc/libvirt/libvirtd.conf
# Listen for TCP/IP connections
# NB. must setup TLS/SSL keys prior to using this
#LIBVIRTD_ARGS="--listen"
# Override Kerberos service keytab for SASL/GSSAPI
#KRB5_KTNAME=/etc/libvirt/krb5.tab
daemon/libvirtd_qemu.aug
+52
View File
@@ -0,0 +1,52 @@
(* /etc/libvirt/qemu.conf *)
module Libvirtd_qemu =
autoload xfm
let eol = del /[ \t]*\n/ "\n"
let value_sep = del /[ \t]*=[ \t]*/ " = "
let indent = del /[ \t]*/ ""
let array_sep = del /,[ \t\n]*/ ", "
let array_start = del /\[[ \t\n]*/ "[ "
let array_end = del /\]/ "]"
let str_val = del /\"/ "\"" . store /[^\"]*/ . del /\"/ "\""
let bool_val = store /0|1/
let str_array_element = [ seq "el" . str_val ] . del /[ \t\n]*/ ""
let str_array_val = counter "el" . array_start . ( str_array_element . ( array_sep . str_array_element ) * ) ? . array_end
let str_entry (kw:string) = [ key kw . value_sep . str_val ]
let bool_entry (kw:string) = [ key kw . value_sep . bool_val ]
let str_array_entry (kw:string) = [ key kw . value_sep . str_array_val ]
(* Config entry grouped by function - same order as example config *)
let vnc_entry = str_entry "vnc_listen"
| bool_entry "vnc_tls"
| str_entry "vnc_tls_x509_cert_dir"
| bool_entry "vnc_tls_x509_verify"
| str_entry "vnc_password"
| bool_entry "vnc_sasl"
| str_entry "vnc_sasl_dir"
| str_entry "security_driver"
| str_entry "user"
| str_entry "group"
| str_array_entry "cgroup_controllers"
| str_array_entry "cgroup_device_acl"
| str_entry "save_image_format"
| str_entry "hugetlbfs_mount"
(* Each enty in the config is one of the following three ... *)
let entry = vnc_entry
let comment = [ label "#comment" . del /#[ \t]*/ "# " . store /([^ \t\n][^\n]*)?/ . del /\n/ "\n" ]
let empty = [ label "#empty" . eol ]
let record = indent . entry . eol
let lns = ( record | comment | empty ) *
let filter = incl "/etc/libvirt/qemu.conf"
. Util.stdexcl
let xfm = transform lns filter
daemon/mdns.c
+510
View File
@@ -0,0 +1,510 @@
/*
* mdns.c: advertise libvirt hypervisor connections
*
* Copyright (C) 2007 Daniel P. Berrange
*
* Derived from Avahi example service provider code.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#include <config.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <avahi-client/client.h>
#include <avahi-client/publish.h>
#include <avahi-common/alternative.h>
#include <avahi-common/simple-watch.h>
#include <avahi-common/malloc.h>
#include <avahi-common/error.h>
#include <avahi-common/timeval.h>
#include "internal.h"
#include "qemud.h"
#include "mdns.h"
#include "event.h"
#include "remote_internal.h"
#include "memory.h"
#define AVAHI_DEBUG(fmt, ...) DEBUG(fmt, __VA_ARGS__)
struct libvirtd_mdns_entry {
char *type;
int port;
struct libvirtd_mdns_entry *next;
};
struct libvirtd_mdns_group {
struct libvirtd_mdns *mdns;
AvahiEntryGroup *handle;
char *name;
struct libvirtd_mdns_entry *entry;
struct libvirtd_mdns_group *next;
};
struct libvirtd_mdns {
AvahiClient *client;
AvahiPoll *poller;
struct libvirtd_mdns_group *group;
};
/* Avahi API requires this struct names in the app :-( */
struct AvahiWatch {
int watch;
int fd;
int revents;
AvahiWatchCallback callback;
void *userdata;
};
/* Avahi API requires this struct names in the app :-( */
struct AvahiTimeout {
int timer;
AvahiTimeoutCallback callback;
void *userdata;
};
static void libvirtd_mdns_create_services(struct libvirtd_mdns_group *group);
/* Called whenever the entry group state changes */
static void libvirtd_mdns_group_callback(AvahiEntryGroup *g ATTRIBUTE_UNUSED, AvahiEntryGroupState state, void *userdata) {
struct libvirtd_mdns_group *group = (struct libvirtd_mdns_group *)userdata;
switch (state) {
case AVAHI_ENTRY_GROUP_ESTABLISHED:
/* The entry group has been established successfully */
AVAHI_DEBUG("Group '%s' established", group->name);
break;
case AVAHI_ENTRY_GROUP_COLLISION:
{
char *n;
/* A service name collision happened. Let's pick a new name */
n = avahi_alternative_service_name(group->name);
VIR_FREE(group->name);
group->name = n;
AVAHI_DEBUG("Group name collision, renaming service to '%s'", group->name);
/* And recreate the services */
libvirtd_mdns_create_services(group);
}
break;
case AVAHI_ENTRY_GROUP_FAILURE :
AVAHI_DEBUG("Group failure: %s", avahi_strerror(avahi_client_errno(group->mdns->client)));
/* Some kind of failure happened while we were registering our services */
//avahi_simple_poll_quit(simple_poll);
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
;
}
}
static void libvirtd_mdns_create_services(struct libvirtd_mdns_group *group) {
struct libvirtd_mdns *mdns = group->mdns;
struct libvirtd_mdns_entry *entry;
int ret;
AVAHI_DEBUG("Adding services to '%s'", group->name);
/* If we've no services to advertise, just reset the group to make
* sure it is emptied of any previously advertised services */
if (!group->entry) {
if (group->handle)
avahi_entry_group_reset(group->handle);
return;
}
/* If this is the first time we're called, let's create a new entry group */
if (!group->handle) {
AVAHI_DEBUG("Creating initial group %s", group->name);
if (!(group->handle = avahi_entry_group_new(mdns->client, libvirtd_mdns_group_callback, group))) {
AVAHI_DEBUG("avahi_entry_group_new() failed: %s", avahi_strerror(avahi_client_errno(mdns->client)));
return;
}
}
entry = group->entry;
while (entry) {
if ((ret = avahi_entry_group_add_service(group->handle,
AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
0,
group->name,
entry->type,
NULL,
NULL,
entry->port,
NULL)) < 0) {
AVAHI_DEBUG("Failed to add %s service on port %d: %s",
entry->type, entry->port, avahi_strerror(ret));
avahi_entry_group_reset(group->handle);
return;
}
entry = entry->next;
}
/* Tell the server to register the service */
if ((ret = avahi_entry_group_commit(group->handle)) < 0) {
avahi_entry_group_reset(group->handle);
AVAHI_DEBUG("Failed to commit entry_group: %s", avahi_strerror(ret));
return;
}
}
static void libvirtd_mdns_client_callback(AvahiClient *c, AvahiClientState state, void *userdata) {
struct libvirtd_mdns *mdns = (struct libvirtd_mdns *)userdata;
struct libvirtd_mdns_group *group;
if (!mdns->client)
mdns->client = c;
/* Called whenever the client or server state changes */
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* The server has startup successfully and registered its host
* name on the network, so it's time to create our services */
AVAHI_DEBUG("Client running %p", mdns->client);
group = mdns->group;
while (group) {
libvirtd_mdns_create_services(group);
group = group->next;
}
break;
case AVAHI_CLIENT_FAILURE:
AVAHI_DEBUG("Client failure: %s", avahi_strerror(avahi_client_errno(c)));
libvirtd_mdns_stop(mdns);
libvirtd_mdns_start(mdns);
break;
case AVAHI_CLIENT_S_COLLISION:
/* Let's drop our registered services. When the server is back
* in AVAHI_SERVER_RUNNING state we will register them
* again with the new host name. */
/* Fallthrough */
case AVAHI_CLIENT_S_REGISTERING:
/* The server records are now being established. This
* might be caused by a host name change. We need to wait
* for our own records to register until the host name is
* properly established. */
AVAHI_DEBUG("Client collision/connecting %p", mdns->client);
group = mdns->group;
while (group) {
if (group->handle)
avahi_entry_group_reset(group->handle);
group = group->next;
}
break;
case AVAHI_CLIENT_CONNECTING:
AVAHI_DEBUG("Client connecting.... %p", mdns->client);
;
}
}
static void libvirtd_mdns_watch_dispatch(int watch, int fd, int events, void *opaque)
{
AvahiWatch *w = (AvahiWatch*)opaque;
int fd_events = virEventHandleTypeToPollEvent(events);
AVAHI_DEBUG("Dispatch watch %d FD %d Event %d", watch, fd, fd_events);
w->revents = fd_events;
w->callback(w, fd, fd_events, w->userdata);
}
static void libvirtd_mdns_watch_dofree(void *w)
{
VIR_FREE(w);
}
static AvahiWatch *libvirtd_mdns_watch_new(const AvahiPoll *api ATTRIBUTE_UNUSED,
int fd, AvahiWatchEvent event,
AvahiWatchCallback cb, void *userdata) {
AvahiWatch *w;
virEventHandleType hEvents;
if (VIR_ALLOC(w) < 0)
return NULL;
w->fd = fd;
w->revents = 0;
w->callback = cb;
w->userdata = userdata;
AVAHI_DEBUG("New handle %p FD %d Event %d", w, w->fd, event);
hEvents = virPollEventToEventHandleType(event);
if ((w->watch = virEventAddHandleImpl(fd, hEvents,
libvirtd_mdns_watch_dispatch,
w,
libvirtd_mdns_watch_dofree)) < 0) {
VIR_FREE(w);
return NULL;
}
return w;
}
static void libvirtd_mdns_watch_update(AvahiWatch *w, AvahiWatchEvent event)
{
AVAHI_DEBUG("Update handle %p FD %d Event %d", w, w->fd, event);
virEventUpdateHandleImpl(w->watch, event);
}
static AvahiWatchEvent libvirtd_mdns_watch_get_events(AvahiWatch *w)
{
AVAHI_DEBUG("Get handle events %p %d", w, w->fd);
return w->revents;
}
static void libvirtd_mdns_watch_free(AvahiWatch *w)
{
AVAHI_DEBUG("Free handle %p %d", w, w->fd);
virEventRemoveHandleImpl(w->watch);
}
static void libvirtd_mdns_timeout_dispatch(int timer ATTRIBUTE_UNUSED, void *opaque)
{
AvahiTimeout *t = (AvahiTimeout*)opaque;
AVAHI_DEBUG("Dispatch timeout %p %d", t, timer);
virEventUpdateTimeoutImpl(t->timer, -1);
t->callback(t, t->userdata);
}
static void libvirtd_mdns_timeout_dofree(void *t)
{
VIR_FREE(t);
}
static AvahiTimeout *libvirtd_mdns_timeout_new(const AvahiPoll *api ATTRIBUTE_UNUSED,
const struct timeval *tv,
AvahiTimeoutCallback cb,
void *userdata)
{
AvahiTimeout *t;
struct timeval now;
long long nowms, thenms, timeout;
AVAHI_DEBUG("Add timeout TV %p", tv);
if (VIR_ALLOC(t) < 0)
return NULL;
if (gettimeofday(&now, NULL) < 0) {
VIR_FREE(t);
return NULL;
}
AVAHI_DEBUG("Trigger timed for %d %d %d %d",
(int)now.tv_sec, (int)now.tv_usec,
(int)(tv ? tv->tv_sec : 0), (int)(tv ? tv->tv_usec : 0));
nowms = (now.tv_sec * 1000ll) + (now.tv_usec / 1000ll);
if (tv) {
thenms = (tv->tv_sec * 1000ll) + (tv->tv_usec/1000ll);
timeout = thenms > nowms ? nowms - thenms : 0;
if (timeout < 0)
timeout = 0;
} else {
timeout = -1;
}
t->timer = virEventAddTimeoutImpl(timeout,
libvirtd_mdns_timeout_dispatch,
t,
libvirtd_mdns_timeout_dofree);
t->callback = cb;
t->userdata = userdata;
if (t->timer < 0) {
VIR_FREE(t);
return NULL;
}
return t;
}
static void libvirtd_mdns_timeout_update(AvahiTimeout *t, const struct timeval *tv)
{
struct timeval now;
long long nowms, thenms, timeout;
AVAHI_DEBUG("Update timeout %p TV %p", t, tv);
if (gettimeofday(&now, NULL) < 0) {
VIR_FREE(t);
return;
}
nowms = (now.tv_sec * 1000ll) + (now.tv_usec / 1000ll);
if (tv) {
thenms = ((tv->tv_sec * 1000ll) + (tv->tv_usec/1000ll));
timeout = thenms > nowms ? nowms - thenms : 0;
if (timeout < 0)
timeout = 0;
} else {
timeout = -1;
}
virEventUpdateTimeoutImpl(t->timer, timeout);
}
static void libvirtd_mdns_timeout_free(AvahiTimeout *t)
{
AVAHI_DEBUG("Free timeout %p", t);
virEventRemoveTimeoutImpl(t->timer);
}
static AvahiPoll *libvirtd_create_poll(void)
{
AvahiPoll *p;
if (VIR_ALLOC(p) < 0)
return NULL;
p->userdata = NULL;
p->watch_new = libvirtd_mdns_watch_new;
p->watch_update = libvirtd_mdns_watch_update;
p->watch_get_events = libvirtd_mdns_watch_get_events;
p->watch_free = libvirtd_mdns_watch_free;
p->timeout_new = libvirtd_mdns_timeout_new;
p->timeout_update = libvirtd_mdns_timeout_update;
p->timeout_free = libvirtd_mdns_timeout_free;
return p;
}
struct libvirtd_mdns *libvirtd_mdns_new(void)
{
struct libvirtd_mdns *mdns;
if (VIR_ALLOC(mdns) < 0)
return NULL;
/* Allocate main loop object */
if (!(mdns->poller = libvirtd_create_poll())) {
VIR_FREE(mdns);
return NULL;
}
return mdns;
}
int libvirtd_mdns_start(struct libvirtd_mdns *mdns)
{
int error;
AVAHI_DEBUG("Starting client %p", mdns);
mdns->client = avahi_client_new(mdns->poller, AVAHI_CLIENT_NO_FAIL, libvirtd_mdns_client_callback, mdns, &error);
if (!mdns->client) {
AVAHI_DEBUG("Failed to create mDNS client: %s", avahi_strerror(error));
return -1;
}
return 0;
}
struct libvirtd_mdns_group *libvirtd_mdns_add_group(struct libvirtd_mdns *mdns, const char *name) {
struct libvirtd_mdns_group *group;
AVAHI_DEBUG("Adding group '%s'", name);
if (VIR_ALLOC(group) < 0)
return NULL;
if (!(group->name = strdup(name))) {
VIR_FREE(group);
return NULL;
}
group->mdns = mdns;
group->next = mdns->group;
mdns->group = group;
return group;
}
void libvirtd_mdns_remove_group(struct libvirtd_mdns *mdns, struct libvirtd_mdns_group *group) {
struct libvirtd_mdns_group *tmp = mdns->group, *prev = NULL;
while (tmp) {
if (tmp == group) {
VIR_FREE(group->name);
if (prev)
prev->next = group->next;
else
group->mdns->group = group->next;
VIR_FREE(group);
return;
}
prev = tmp;
tmp = tmp->next;
}
}
struct libvirtd_mdns_entry *libvirtd_mdns_add_entry(struct libvirtd_mdns_group *group, const char *type, int port) {
struct libvirtd_mdns_entry *entry;
AVAHI_DEBUG("Adding entry %s %d to group %s", type, port, group->name);
if (VIR_ALLOC(entry) < 0)
return NULL;
entry->port = port;
if (!(entry->type = strdup(type))) {
VIR_FREE(entry);
return NULL;
}
entry->next = group->entry;
group->entry = entry;
return entry;
}
void libvirtd_mdns_remove_entry(struct libvirtd_mdns_group *group, struct libvirtd_mdns_entry *entry) {
struct libvirtd_mdns_entry *tmp = group->entry, *prev = NULL;
while (tmp) {
if (tmp == entry) {
VIR_FREE(entry->type);
if (prev)
prev->next = entry->next;
else
group->entry = entry->next;
return;
}
prev = tmp;
tmp = tmp->next;
}
}
void libvirtd_mdns_stop(struct libvirtd_mdns *mdns)
{
struct libvirtd_mdns_group *group = mdns->group;
while (group) {
if (group->handle) {
avahi_entry_group_free(group->handle);
group->handle = NULL;
}
group = group->next;
}
if (mdns->client)
avahi_client_free(mdns->client);
mdns->client = NULL;
}
daemon/mdns.h
+96
View File
@@ -0,0 +1,96 @@
/*
* mdns.c: advertise libvirt hypervisor connections
*
* Copyright (C) 2007 Daniel P. Berrange
*
* Derived from Avahi example service provider code.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#include "internal.h"
#ifndef __VIRTD_MDNS_H__
#define __VIRTD_MDNS_H__
struct libvirtd_mdns;
struct libvirtd_mdns_group;
struct libvirtd_mdns_entry;
/**
* Prepares a new mdns manager object for use
*/
struct libvirtd_mdns *libvirtd_mdns_new(void);
/**
* Starts the mdns client, advertising any groups/entries currently registered
*
* @mdns: manager to start advertising
*
* Starts the mdns client. Services may not be immediately visible, since
* it may asynchronously wait for the mdns service to startup
*
* returns -1 upon failure, 0 upon success.
*/
int libvirtd_mdns_start(struct libvirtd_mdns *mdns);
/**
* Stops the mdns client, removing any advertisements
*
* @mdns: manager to start advertising
*
*/
void libvirtd_mdns_stop(struct libvirtd_mdns *mdns);
/**
* Adds a group container for advertisement
*
* @mdns manager to attach the group to
* @name unique human readable service name
*
* returns the group record, or NULL upon failure
*/
struct libvirtd_mdns_group *libvirtd_mdns_add_group(struct libvirtd_mdns *mdns, const char *name);
/**
* Removes a group container from advertisement
*
* @mdns amanger to detach group from
* @group group to remove
*/
void libvirtd_mdns_remove_group(struct libvirtd_mdns *mdns, struct libvirtd_mdns_group *group);
/**
* Adds a service entry in a group
*
* @group group to attach the entry to
* @type service type string
* @port tcp port number
*
* returns the service record, or NULL upon failure
*/
struct libvirtd_mdns_entry *libvirtd_mdns_add_entry(struct libvirtd_mdns_group *group, const char *type, int port);
/**
* Removes a service entry from a group
*
* @group group to detach service entry from
* @entry service entry to remove
*/
void libvirtd_mdns_remove_entry(struct libvirtd_mdns_group *group, struct libvirtd_mdns_entry *entry);
#endif /* __VIRTD_MDNS_H__ */
daemon/qemud.c
+3015
View File
File diff suppressed because it is too large Load Diff
daemon/qemud.h
+284
View File
@@ -0,0 +1,284 @@
/*
* qemud.h: daemon data structure definitions
*
* Copyright (C) 2006-2009 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef QEMUD_INTERNAL_H__
#define QEMUD_INTERNAL_H__
#include <config.h>
#include <gnutls/gnutls.h>
#include <gnutls/x509.h>
#include "gnutls_1_0_compat.h"
#if HAVE_SASL
#include <sasl/sasl.h>
#endif
#if HAVE_POLKIT0
#include <dbus/dbus.h>
#endif
#ifdef HAVE_SYS_SYSLIMITS_H
#include <sys/syslimits.h>
#endif
#include <rpc/types.h>
#include <rpc/xdr.h>
#include "remote_protocol.h"
#include "logging.h"
#include "threads.h"
#ifdef __GNUC__
#ifdef HAVE_ANSIDECL_H
#include <ansidecl.h>
#endif
#ifndef __GNUC_PREREQ
#if defined __GNUC__ && defined __GNUC_MINOR__
# define __GNUC_PREREQ(maj, min) \
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
#else
#define __GNUC_PREREQ(maj,min) 0
#endif
#endif
/**
* ATTRIBUTE_UNUSED:
*
* Macro to flag conciously unused parameters to functions
*/
#ifndef ATTRIBUTE_UNUSED
#define ATTRIBUTE_UNUSED __attribute__((__unused__))
#endif
/**
* ATTRIBUTE_FMT_PRINTF
*
* Macro used to check printf like functions, if compiling
* with gcc.
*
* We use gnulib which guarentees we always have GNU style
* printf format specifiers even on broken Win32 platforms
* hence we have to force 'gnu_printf' for new GCC
*/
#ifndef ATTRIBUTE_FMT_PRINTF
#if __GNUC_PREREQ (4, 4)
#define ATTRIBUTE_FMT_PRINTF(fmtpos,argpos) __attribute__((__format__ (gnu_printf, fmtpos,argpos)))
#else
#define ATTRIBUTE_FMT_PRINTF(fmtpos,argpos) __attribute__((__format__ (printf, fmtpos,argpos)))
#endif
#endif
#ifndef ATTRIBUTE_RETURN_CHECK
#if __GNUC_PREREQ (3, 4)
#define ATTRIBUTE_RETURN_CHECK __attribute__((__warn_unused_result__))
#else
#define ATTRIBUTE_RETURN_CHECK
#endif
#endif
#else
#ifndef ATTRIBUTE_UNUSED
#define ATTRIBUTE_UNUSED
#endif
#ifndef ATTRIBUTE_FMT_PRINTF
#define ATTRIBUTE_FMT_PRINTF(...)
#endif
#ifndef ATTRIBUTE_RETURN_CHECK
#define ATTRIBUTE_RETURN_CHECK
#endif
#endif
#define qemudDebug DEBUG
/* Whether we're passing reads & writes through a sasl SSF */
enum qemud_sasl_ssf {
QEMUD_SASL_SSF_NONE = 0,
QEMUD_SASL_SSF_READ = 1,
QEMUD_SASL_SSF_WRITE = 2,
};
enum qemud_sock_type {
QEMUD_SOCK_TYPE_UNIX = 0,
QEMUD_SOCK_TYPE_TCP = 1,
QEMUD_SOCK_TYPE_TLS = 2,
};
struct qemud_client_message {
char buffer [REMOTE_MESSAGE_MAX + REMOTE_MESSAGE_HEADER_XDR_LEN];
unsigned int bufferLength;
unsigned int bufferOffset;
int async : 1;
remote_message_header hdr;
struct qemud_client_message *next;
};
/* Allow for filtering of incoming messages to a custom
* dispatch processing queue, instead of client->dx.
*/
typedef int (*qemud_client_filter_func)(struct qemud_client_message *msg, void *opaque);
struct qemud_client_filter {
qemud_client_filter_func query;
void *opaque;
struct qemud_client_message *dx;
struct qemud_client_filter *next;
};
/* Stores the per-client connection state */
struct qemud_client {
virMutex lock;
int magic;
int fd;
int watch;
int readonly:1;
int closing:1;
struct sockaddr_storage addr;
socklen_t addrlen;
int type; /* qemud_sock_type */
gnutls_session_t tlssession;
int auth;
int handshake : 1; /* If we're in progress for TLS handshake */
#if HAVE_SASL
sasl_conn_t *saslconn;
int saslSSF;
const char *saslDecoded;
unsigned int saslDecodedLength;
unsigned int saslDecodedOffset;
const char *saslEncoded;
unsigned int saslEncodedLength;
unsigned int saslEncodedOffset;
char *saslUsername;
#endif
/* Count of meages in 'dx' or 'tx' queue
* ie RPC calls in progress. Does not count
* async events which are not used for
* throttling calculations */
int nrequests;
/* Zero or one messages being received. Zero if
* nrequests >= max_clients and throttling */
struct qemud_client_message *rx;
/* Zero or many messages waiting for a worker
* to process them */
struct qemud_client_message *dx;
/* Zero or many messages waiting for transmit
* back to client, including async events */
struct qemud_client_message *tx;
/* Filters to capture messages that would otherwise
* end up on the 'dx' queue */
struct qemud_client_filter *filters;
/* This is only valid if a remote open call has been made on this
* connection, otherwise it will be NULL. Also if remote close is
* called, it will be set back to NULL if that succeeds.
*/
virConnectPtr conn;
int refs;
};
#define QEMUD_CLIENT_MAGIC 0x7788aaee
struct qemud_socket {
int fd;
int watch;
int readonly;
int type; /* qemud_sock_type */
int auth;
int port;
struct qemud_socket *next;
};
struct qemud_worker {
pthread_t thread;
int hasThread :1;
int processingCall :1;
int quitRequest : 1;
/* back-pointer to our server */
struct qemud_server *server;
};
/* Main server state */
struct qemud_server {
virMutex lock;
virCond job;
int privileged;
int nworkers;
int nactiveworkers;
struct qemud_worker *workers;
int nsockets;
struct qemud_socket *sockets;
int nclients;
struct qemud_client **clients;
int sigread;
char *logDir;
unsigned int shutdown : 1;
#ifdef HAVE_AVAHI
struct libvirtd_mdns *mdns;
#endif
#if HAVE_SASL
char **saslUsernameWhitelist;
#endif
#if HAVE_POLKIT0
DBusConnection *sysbus;
#endif
};
void qemudLog(int priority, const char *fmt, ...)
ATTRIBUTE_FMT_PRINTF(2,3);
int qemudRegisterClientEvent(struct qemud_server *server,
struct qemud_client *client);
void qemudUpdateClientEvent(struct qemud_client *client);
void qemudDispatchClientFailure(struct qemud_client *client);
void
qemudClientMessageQueuePush(struct qemud_client_message **queue,
struct qemud_client_message *msg);
struct qemud_client_message *
qemudClientMessageQueueServe(struct qemud_client_message **queue);
#if HAVE_POLKIT
int qemudGetSocketIdentity(int fd, uid_t *uid, pid_t *pid);
#endif
#endif
daemon/remote.c
+4905
View File
File diff suppressed because it is too large Load Diff
daemon/remote.h
+72
View File
@@ -0,0 +1,72 @@
/*
* remote.h: handlers for RPC method calls
*
* Copyright (C) 2007, 2008, 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Richard W.M. Jones <rjones@redhat.com>
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef __LIBVIRTD_REMOTE_H__
#define __LIBVIRTD_REMOTE_H__
#include "qemud.h"
typedef union {
#include "remote_dispatch_args.h"
} dispatch_args;
typedef union {
#include "remote_dispatch_ret.h"
} dispatch_ret;
/**
* When the RPC handler is called:
*
* - Server object is unlocked
* - Client object is unlocked
*
* Both must be locked before use. Server lock must
* be held before attempting to lock client.
*
* Without any locking, it is safe to use:
*
* 'conn', 'rerr', 'args and 'ret'
*/
typedef int (*dispatch_fn) (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
remote_error *err,
dispatch_args *args,
dispatch_ret *ret);
typedef struct {
dispatch_fn fn;
xdrproc_t args_filter;
xdrproc_t ret_filter;
} dispatch_data;
const dispatch_data const *remoteGetDispatchData(int proc);
#endif /* __LIBVIRTD_REMOTE_H__ */
daemon/remote_dispatch_args.h
+127
View File
@@ -0,0 +1,127 @@
/* Automatically generated by remote_generate_stubs.pl.
* Do not edit this file. Any changes you make will be lost.
*/
remote_open_args val_remote_open_args;
remote_get_max_vcpus_args val_remote_get_max_vcpus_args;
remote_domain_attach_device_args val_remote_domain_attach_device_args;
remote_domain_create_args val_remote_domain_create_args;
remote_domain_create_xml_args val_remote_domain_create_xml_args;
remote_domain_define_xml_args val_remote_domain_define_xml_args;
remote_domain_destroy_args val_remote_domain_destroy_args;
remote_domain_detach_device_args val_remote_domain_detach_device_args;
remote_domain_dump_xml_args val_remote_domain_dump_xml_args;
remote_domain_get_autostart_args val_remote_domain_get_autostart_args;
remote_domain_get_info_args val_remote_domain_get_info_args;
remote_domain_get_max_memory_args val_remote_domain_get_max_memory_args;
remote_domain_get_max_vcpus_args val_remote_domain_get_max_vcpus_args;
remote_domain_get_os_type_args val_remote_domain_get_os_type_args;
remote_domain_get_vcpus_args val_remote_domain_get_vcpus_args;
remote_list_defined_domains_args val_remote_list_defined_domains_args;
remote_domain_lookup_by_id_args val_remote_domain_lookup_by_id_args;
remote_domain_lookup_by_name_args val_remote_domain_lookup_by_name_args;
remote_domain_lookup_by_uuid_args val_remote_domain_lookup_by_uuid_args;
remote_domain_pin_vcpu_args val_remote_domain_pin_vcpu_args;
remote_domain_reboot_args val_remote_domain_reboot_args;
remote_domain_resume_args val_remote_domain_resume_args;
remote_domain_set_autostart_args val_remote_domain_set_autostart_args;
remote_domain_set_max_memory_args val_remote_domain_set_max_memory_args;
remote_domain_set_memory_args val_remote_domain_set_memory_args;
remote_domain_set_vcpus_args val_remote_domain_set_vcpus_args;
remote_domain_shutdown_args val_remote_domain_shutdown_args;
remote_domain_suspend_args val_remote_domain_suspend_args;
remote_domain_undefine_args val_remote_domain_undefine_args;
remote_list_defined_networks_args val_remote_list_defined_networks_args;
remote_list_domains_args val_remote_list_domains_args;
remote_list_networks_args val_remote_list_networks_args;
remote_network_create_args val_remote_network_create_args;
remote_network_create_xml_args val_remote_network_create_xml_args;
remote_network_define_xml_args val_remote_network_define_xml_args;
remote_network_destroy_args val_remote_network_destroy_args;
remote_network_dump_xml_args val_remote_network_dump_xml_args;
remote_network_get_autostart_args val_remote_network_get_autostart_args;
remote_network_get_bridge_name_args val_remote_network_get_bridge_name_args;
remote_network_lookup_by_name_args val_remote_network_lookup_by_name_args;
remote_network_lookup_by_uuid_args val_remote_network_lookup_by_uuid_args;
remote_network_set_autostart_args val_remote_network_set_autostart_args;
remote_network_undefine_args val_remote_network_undefine_args;
remote_domain_core_dump_args val_remote_domain_core_dump_args;
remote_domain_restore_args val_remote_domain_restore_args;
remote_domain_save_args val_remote_domain_save_args;
remote_domain_get_scheduler_type_args val_remote_domain_get_scheduler_type_args;
remote_domain_get_scheduler_parameters_args val_remote_domain_get_scheduler_parameters_args;
remote_domain_set_scheduler_parameters_args val_remote_domain_set_scheduler_parameters_args;
remote_supports_feature_args val_remote_supports_feature_args;
remote_domain_migrate_prepare_args val_remote_domain_migrate_prepare_args;
remote_domain_migrate_perform_args val_remote_domain_migrate_perform_args;
remote_domain_migrate_finish_args val_remote_domain_migrate_finish_args;
remote_domain_block_stats_args val_remote_domain_block_stats_args;
remote_domain_interface_stats_args val_remote_domain_interface_stats_args;
remote_auth_sasl_start_args val_remote_auth_sasl_start_args;
remote_auth_sasl_step_args val_remote_auth_sasl_step_args;
remote_list_storage_pools_args val_remote_list_storage_pools_args;
remote_list_defined_storage_pools_args val_remote_list_defined_storage_pools_args;
remote_find_storage_pool_sources_args val_remote_find_storage_pool_sources_args;
remote_storage_pool_create_xml_args val_remote_storage_pool_create_xml_args;
remote_storage_pool_define_xml_args val_remote_storage_pool_define_xml_args;
remote_storage_pool_create_args val_remote_storage_pool_create_args;
remote_storage_pool_build_args val_remote_storage_pool_build_args;
remote_storage_pool_destroy_args val_remote_storage_pool_destroy_args;
remote_storage_pool_delete_args val_remote_storage_pool_delete_args;
remote_storage_pool_undefine_args val_remote_storage_pool_undefine_args;
remote_storage_pool_refresh_args val_remote_storage_pool_refresh_args;
remote_storage_pool_lookup_by_name_args val_remote_storage_pool_lookup_by_name_args;
remote_storage_pool_lookup_by_uuid_args val_remote_storage_pool_lookup_by_uuid_args;
remote_storage_pool_lookup_by_volume_args val_remote_storage_pool_lookup_by_volume_args;
remote_storage_pool_get_info_args val_remote_storage_pool_get_info_args;
remote_storage_pool_dump_xml_args val_remote_storage_pool_dump_xml_args;
remote_storage_pool_get_autostart_args val_remote_storage_pool_get_autostart_args;
remote_storage_pool_set_autostart_args val_remote_storage_pool_set_autostart_args;
remote_storage_pool_num_of_volumes_args val_remote_storage_pool_num_of_volumes_args;
remote_storage_pool_list_volumes_args val_remote_storage_pool_list_volumes_args;
remote_storage_vol_create_xml_args val_remote_storage_vol_create_xml_args;
remote_storage_vol_delete_args val_remote_storage_vol_delete_args;
remote_storage_vol_lookup_by_name_args val_remote_storage_vol_lookup_by_name_args;
remote_storage_vol_lookup_by_key_args val_remote_storage_vol_lookup_by_key_args;
remote_storage_vol_lookup_by_path_args val_remote_storage_vol_lookup_by_path_args;
remote_storage_vol_get_info_args val_remote_storage_vol_get_info_args;
remote_storage_vol_dump_xml_args val_remote_storage_vol_dump_xml_args;
remote_storage_vol_get_path_args val_remote_storage_vol_get_path_args;
remote_node_get_cells_free_memory_args val_remote_node_get_cells_free_memory_args;
remote_domain_block_peek_args val_remote_domain_block_peek_args;
remote_domain_memory_peek_args val_remote_domain_memory_peek_args;
remote_domain_migrate_prepare2_args val_remote_domain_migrate_prepare2_args;
remote_domain_migrate_finish2_args val_remote_domain_migrate_finish2_args;
remote_node_num_of_devices_args val_remote_node_num_of_devices_args;
remote_node_list_devices_args val_remote_node_list_devices_args;
remote_node_device_lookup_by_name_args val_remote_node_device_lookup_by_name_args;
remote_node_device_dump_xml_args val_remote_node_device_dump_xml_args;
remote_node_device_get_parent_args val_remote_node_device_get_parent_args;
remote_node_device_num_of_caps_args val_remote_node_device_num_of_caps_args;
remote_node_device_list_caps_args val_remote_node_device_list_caps_args;
remote_node_device_dettach_args val_remote_node_device_dettach_args;
remote_node_device_re_attach_args val_remote_node_device_re_attach_args;
remote_node_device_reset_args val_remote_node_device_reset_args;
remote_domain_get_security_label_args val_remote_domain_get_security_label_args;
remote_node_device_create_xml_args val_remote_node_device_create_xml_args;
remote_node_device_destroy_args val_remote_node_device_destroy_args;
remote_storage_vol_create_xml_from_args val_remote_storage_vol_create_xml_from_args;
remote_list_interfaces_args val_remote_list_interfaces_args;
remote_interface_lookup_by_name_args val_remote_interface_lookup_by_name_args;
remote_interface_lookup_by_mac_string_args val_remote_interface_lookup_by_mac_string_args;
remote_interface_get_xml_desc_args val_remote_interface_get_xml_desc_args;
remote_interface_define_xml_args val_remote_interface_define_xml_args;
remote_interface_undefine_args val_remote_interface_undefine_args;
remote_interface_create_args val_remote_interface_create_args;
remote_interface_destroy_args val_remote_interface_destroy_args;
remote_domain_xml_from_native_args val_remote_domain_xml_from_native_args;
remote_domain_xml_to_native_args val_remote_domain_xml_to_native_args;
remote_list_defined_interfaces_args val_remote_list_defined_interfaces_args;
remote_list_secrets_args val_remote_list_secrets_args;
remote_secret_lookup_by_uuid_args val_remote_secret_lookup_by_uuid_args;
remote_secret_define_xml_args val_remote_secret_define_xml_args;
remote_secret_get_xml_desc_args val_remote_secret_get_xml_desc_args;
remote_secret_set_value_args val_remote_secret_set_value_args;
remote_secret_get_value_args val_remote_secret_get_value_args;
remote_secret_undefine_args val_remote_secret_undefine_args;
remote_secret_lookup_by_usage_args val_remote_secret_lookup_by_usage_args;
daemon/remote_dispatch_prototypes.h
+1026
View File
File diff suppressed because it is too large Load Diff
daemon/remote_dispatch_ret.h
+108
View File
@@ -0,0 +1,108 @@
/* Automatically generated by remote_generate_stubs.pl.
* Do not edit this file. Any changes you make will be lost.
*/
remote_get_type_ret val_remote_get_type_ret;
remote_get_version_ret val_remote_get_version_ret;
remote_get_max_vcpus_ret val_remote_get_max_vcpus_ret;
remote_node_get_info_ret val_remote_node_get_info_ret;
remote_get_capabilities_ret val_remote_get_capabilities_ret;
remote_domain_create_xml_ret val_remote_domain_create_xml_ret;
remote_domain_define_xml_ret val_remote_domain_define_xml_ret;
remote_domain_dump_xml_ret val_remote_domain_dump_xml_ret;
remote_domain_get_autostart_ret val_remote_domain_get_autostart_ret;
remote_domain_get_info_ret val_remote_domain_get_info_ret;
remote_domain_get_max_memory_ret val_remote_domain_get_max_memory_ret;
remote_domain_get_max_vcpus_ret val_remote_domain_get_max_vcpus_ret;
remote_domain_get_os_type_ret val_remote_domain_get_os_type_ret;
remote_domain_get_vcpus_ret val_remote_domain_get_vcpus_ret;
remote_list_defined_domains_ret val_remote_list_defined_domains_ret;
remote_domain_lookup_by_id_ret val_remote_domain_lookup_by_id_ret;
remote_domain_lookup_by_name_ret val_remote_domain_lookup_by_name_ret;
remote_domain_lookup_by_uuid_ret val_remote_domain_lookup_by_uuid_ret;
remote_num_of_defined_domains_ret val_remote_num_of_defined_domains_ret;
remote_list_defined_networks_ret val_remote_list_defined_networks_ret;
remote_list_domains_ret val_remote_list_domains_ret;
remote_list_networks_ret val_remote_list_networks_ret;
remote_network_create_xml_ret val_remote_network_create_xml_ret;
remote_network_define_xml_ret val_remote_network_define_xml_ret;
remote_network_dump_xml_ret val_remote_network_dump_xml_ret;
remote_network_get_autostart_ret val_remote_network_get_autostart_ret;
remote_network_get_bridge_name_ret val_remote_network_get_bridge_name_ret;
remote_network_lookup_by_name_ret val_remote_network_lookup_by_name_ret;
remote_network_lookup_by_uuid_ret val_remote_network_lookup_by_uuid_ret;
remote_num_of_defined_networks_ret val_remote_num_of_defined_networks_ret;
remote_num_of_domains_ret val_remote_num_of_domains_ret;
remote_num_of_networks_ret val_remote_num_of_networks_ret;
remote_domain_get_scheduler_type_ret val_remote_domain_get_scheduler_type_ret;
remote_domain_get_scheduler_parameters_ret val_remote_domain_get_scheduler_parameters_ret;
remote_get_hostname_ret val_remote_get_hostname_ret;
remote_supports_feature_ret val_remote_supports_feature_ret;
remote_domain_migrate_prepare_ret val_remote_domain_migrate_prepare_ret;
remote_domain_migrate_finish_ret val_remote_domain_migrate_finish_ret;
remote_domain_block_stats_ret val_remote_domain_block_stats_ret;
remote_domain_interface_stats_ret val_remote_domain_interface_stats_ret;
remote_auth_list_ret val_remote_auth_list_ret;
remote_auth_sasl_init_ret val_remote_auth_sasl_init_ret;
remote_auth_sasl_start_ret val_remote_auth_sasl_start_ret;
remote_auth_sasl_step_ret val_remote_auth_sasl_step_ret;
remote_auth_polkit_ret val_remote_auth_polkit_ret;
remote_num_of_storage_pools_ret val_remote_num_of_storage_pools_ret;
remote_list_storage_pools_ret val_remote_list_storage_pools_ret;
remote_num_of_defined_storage_pools_ret val_remote_num_of_defined_storage_pools_ret;
remote_list_defined_storage_pools_ret val_remote_list_defined_storage_pools_ret;
remote_find_storage_pool_sources_ret val_remote_find_storage_pool_sources_ret;
remote_storage_pool_create_xml_ret val_remote_storage_pool_create_xml_ret;
remote_storage_pool_define_xml_ret val_remote_storage_pool_define_xml_ret;
remote_storage_pool_lookup_by_name_ret val_remote_storage_pool_lookup_by_name_ret;
remote_storage_pool_lookup_by_uuid_ret val_remote_storage_pool_lookup_by_uuid_ret;
remote_storage_pool_lookup_by_volume_ret val_remote_storage_pool_lookup_by_volume_ret;
remote_storage_pool_get_info_ret val_remote_storage_pool_get_info_ret;
remote_storage_pool_dump_xml_ret val_remote_storage_pool_dump_xml_ret;
remote_storage_pool_get_autostart_ret val_remote_storage_pool_get_autostart_ret;
remote_storage_pool_num_of_volumes_ret val_remote_storage_pool_num_of_volumes_ret;
remote_storage_pool_list_volumes_ret val_remote_storage_pool_list_volumes_ret;
remote_storage_vol_create_xml_ret val_remote_storage_vol_create_xml_ret;
remote_storage_vol_lookup_by_name_ret val_remote_storage_vol_lookup_by_name_ret;
remote_storage_vol_lookup_by_key_ret val_remote_storage_vol_lookup_by_key_ret;
remote_storage_vol_lookup_by_path_ret val_remote_storage_vol_lookup_by_path_ret;
remote_storage_vol_get_info_ret val_remote_storage_vol_get_info_ret;
remote_storage_vol_dump_xml_ret val_remote_storage_vol_dump_xml_ret;
remote_storage_vol_get_path_ret val_remote_storage_vol_get_path_ret;
remote_node_get_cells_free_memory_ret val_remote_node_get_cells_free_memory_ret;
remote_node_get_free_memory_ret val_remote_node_get_free_memory_ret;
remote_domain_block_peek_ret val_remote_domain_block_peek_ret;
remote_domain_memory_peek_ret val_remote_domain_memory_peek_ret;
remote_domain_events_register_ret val_remote_domain_events_register_ret;
remote_domain_events_deregister_ret val_remote_domain_events_deregister_ret;
remote_domain_migrate_prepare2_ret val_remote_domain_migrate_prepare2_ret;
remote_domain_migrate_finish2_ret val_remote_domain_migrate_finish2_ret;
remote_get_uri_ret val_remote_get_uri_ret;
remote_node_num_of_devices_ret val_remote_node_num_of_devices_ret;
remote_node_list_devices_ret val_remote_node_list_devices_ret;
remote_node_device_lookup_by_name_ret val_remote_node_device_lookup_by_name_ret;
remote_node_device_dump_xml_ret val_remote_node_device_dump_xml_ret;
remote_node_device_get_parent_ret val_remote_node_device_get_parent_ret;
remote_node_device_num_of_caps_ret val_remote_node_device_num_of_caps_ret;
remote_node_device_list_caps_ret val_remote_node_device_list_caps_ret;
remote_domain_get_security_label_ret val_remote_domain_get_security_label_ret;
remote_node_get_security_model_ret val_remote_node_get_security_model_ret;
remote_node_device_create_xml_ret val_remote_node_device_create_xml_ret;
remote_storage_vol_create_xml_from_ret val_remote_storage_vol_create_xml_from_ret;
remote_num_of_interfaces_ret val_remote_num_of_interfaces_ret;
remote_list_interfaces_ret val_remote_list_interfaces_ret;
remote_interface_lookup_by_name_ret val_remote_interface_lookup_by_name_ret;
remote_interface_lookup_by_mac_string_ret val_remote_interface_lookup_by_mac_string_ret;
remote_interface_get_xml_desc_ret val_remote_interface_get_xml_desc_ret;
remote_interface_define_xml_ret val_remote_interface_define_xml_ret;
remote_domain_xml_from_native_ret val_remote_domain_xml_from_native_ret;
remote_domain_xml_to_native_ret val_remote_domain_xml_to_native_ret;
remote_num_of_defined_interfaces_ret val_remote_num_of_defined_interfaces_ret;
remote_list_defined_interfaces_ret val_remote_list_defined_interfaces_ret;
remote_num_of_secrets_ret val_remote_num_of_secrets_ret;
remote_list_secrets_ret val_remote_list_secrets_ret;
remote_secret_lookup_by_uuid_ret val_remote_secret_lookup_by_uuid_ret;
remote_secret_define_xml_ret val_remote_secret_define_xml_ret;
remote_secret_get_xml_desc_ret val_remote_secret_get_xml_desc_ret;
remote_secret_get_value_ret val_remote_secret_get_value_ret;
remote_secret_lookup_by_usage_ret val_remote_secret_lookup_by_usage_ret;
daemon/remote_dispatch_table.h
+744
View File
@@ -0,0 +1,744 @@
/* Automatically generated by remote_generate_stubs.pl.
* Do not edit this file. Any changes you make will be lost.
*/
{ /* (unused) => 0 */
.fn = NULL,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* Open => 1 */
.fn = (dispatch_fn) remoteDispatchOpen,
.args_filter = (xdrproc_t) xdr_remote_open_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* Close => 2 */
.fn = (dispatch_fn) remoteDispatchClose,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* GetType => 3 */
.fn = (dispatch_fn) remoteDispatchGetType,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_get_type_ret,
},
{ /* GetVersion => 4 */
.fn = (dispatch_fn) remoteDispatchGetVersion,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_get_version_ret,
},
{ /* GetMaxVcpus => 5 */
.fn = (dispatch_fn) remoteDispatchGetMaxVcpus,
.args_filter = (xdrproc_t) xdr_remote_get_max_vcpus_args,
.ret_filter = (xdrproc_t) xdr_remote_get_max_vcpus_ret,
},
{ /* NodeGetInfo => 6 */
.fn = (dispatch_fn) remoteDispatchNodeGetInfo,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_node_get_info_ret,
},
{ /* GetCapabilities => 7 */
.fn = (dispatch_fn) remoteDispatchGetCapabilities,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_get_capabilities_ret,
},
{ /* DomainAttachDevice => 8 */
.fn = (dispatch_fn) remoteDispatchDomainAttachDevice,
.args_filter = (xdrproc_t) xdr_remote_domain_attach_device_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainCreate => 9 */
.fn = (dispatch_fn) remoteDispatchDomainCreate,
.args_filter = (xdrproc_t) xdr_remote_domain_create_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainCreateXml => 10 */
.fn = (dispatch_fn) remoteDispatchDomainCreateXml,
.args_filter = (xdrproc_t) xdr_remote_domain_create_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_create_xml_ret,
},
{ /* DomainDefineXml => 11 */
.fn = (dispatch_fn) remoteDispatchDomainDefineXml,
.args_filter = (xdrproc_t) xdr_remote_domain_define_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_define_xml_ret,
},
{ /* DomainDestroy => 12 */
.fn = (dispatch_fn) remoteDispatchDomainDestroy,
.args_filter = (xdrproc_t) xdr_remote_domain_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainDetachDevice => 13 */
.fn = (dispatch_fn) remoteDispatchDomainDetachDevice,
.args_filter = (xdrproc_t) xdr_remote_domain_detach_device_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainDumpXml => 14 */
.fn = (dispatch_fn) remoteDispatchDomainDumpXml,
.args_filter = (xdrproc_t) xdr_remote_domain_dump_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_dump_xml_ret,
},
{ /* DomainGetAutostart => 15 */
.fn = (dispatch_fn) remoteDispatchDomainGetAutostart,
.args_filter = (xdrproc_t) xdr_remote_domain_get_autostart_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_autostart_ret,
},
{ /* DomainGetInfo => 16 */
.fn = (dispatch_fn) remoteDispatchDomainGetInfo,
.args_filter = (xdrproc_t) xdr_remote_domain_get_info_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_info_ret,
},
{ /* DomainGetMaxMemory => 17 */
.fn = (dispatch_fn) remoteDispatchDomainGetMaxMemory,
.args_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_ret,
},
{ /* DomainGetMaxVcpus => 18 */
.fn = (dispatch_fn) remoteDispatchDomainGetMaxVcpus,
.args_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret,
},
{ /* DomainGetOsType => 19 */
.fn = (dispatch_fn) remoteDispatchDomainGetOsType,
.args_filter = (xdrproc_t) xdr_remote_domain_get_os_type_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_os_type_ret,
},
{ /* DomainGetVcpus => 20 */
.fn = (dispatch_fn) remoteDispatchDomainGetVcpus,
.args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_ret,
},
{ /* ListDefinedDomains => 21 */
.fn = (dispatch_fn) remoteDispatchListDefinedDomains,
.args_filter = (xdrproc_t) xdr_remote_list_defined_domains_args,
.ret_filter = (xdrproc_t) xdr_remote_list_defined_domains_ret,
},
{ /* DomainLookupById => 22 */
.fn = (dispatch_fn) remoteDispatchDomainLookupById,
.args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_ret,
},
{ /* DomainLookupByName => 23 */
.fn = (dispatch_fn) remoteDispatchDomainLookupByName,
.args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_ret,
},
{ /* DomainLookupByUuid => 24 */
.fn = (dispatch_fn) remoteDispatchDomainLookupByUuid,
.args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret,
},
{ /* NumOfDefinedDomains => 25 */
.fn = (dispatch_fn) remoteDispatchNumOfDefinedDomains,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_defined_domains_ret,
},
{ /* DomainPinVcpu => 26 */
.fn = (dispatch_fn) remoteDispatchDomainPinVcpu,
.args_filter = (xdrproc_t) xdr_remote_domain_pin_vcpu_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainReboot => 27 */
.fn = (dispatch_fn) remoteDispatchDomainReboot,
.args_filter = (xdrproc_t) xdr_remote_domain_reboot_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainResume => 28 */
.fn = (dispatch_fn) remoteDispatchDomainResume,
.args_filter = (xdrproc_t) xdr_remote_domain_resume_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSetAutostart => 29 */
.fn = (dispatch_fn) remoteDispatchDomainSetAutostart,
.args_filter = (xdrproc_t) xdr_remote_domain_set_autostart_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSetMaxMemory => 30 */
.fn = (dispatch_fn) remoteDispatchDomainSetMaxMemory,
.args_filter = (xdrproc_t) xdr_remote_domain_set_max_memory_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSetMemory => 31 */
.fn = (dispatch_fn) remoteDispatchDomainSetMemory,
.args_filter = (xdrproc_t) xdr_remote_domain_set_memory_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSetVcpus => 32 */
.fn = (dispatch_fn) remoteDispatchDomainSetVcpus,
.args_filter = (xdrproc_t) xdr_remote_domain_set_vcpus_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainShutdown => 33 */
.fn = (dispatch_fn) remoteDispatchDomainShutdown,
.args_filter = (xdrproc_t) xdr_remote_domain_shutdown_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSuspend => 34 */
.fn = (dispatch_fn) remoteDispatchDomainSuspend,
.args_filter = (xdrproc_t) xdr_remote_domain_suspend_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainUndefine => 35 */
.fn = (dispatch_fn) remoteDispatchDomainUndefine,
.args_filter = (xdrproc_t) xdr_remote_domain_undefine_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* ListDefinedNetworks => 36 */
.fn = (dispatch_fn) remoteDispatchListDefinedNetworks,
.args_filter = (xdrproc_t) xdr_remote_list_defined_networks_args,
.ret_filter = (xdrproc_t) xdr_remote_list_defined_networks_ret,
},
{ /* ListDomains => 37 */
.fn = (dispatch_fn) remoteDispatchListDomains,
.args_filter = (xdrproc_t) xdr_remote_list_domains_args,
.ret_filter = (xdrproc_t) xdr_remote_list_domains_ret,
},
{ /* ListNetworks => 38 */
.fn = (dispatch_fn) remoteDispatchListNetworks,
.args_filter = (xdrproc_t) xdr_remote_list_networks_args,
.ret_filter = (xdrproc_t) xdr_remote_list_networks_ret,
},
{ /* NetworkCreate => 39 */
.fn = (dispatch_fn) remoteDispatchNetworkCreate,
.args_filter = (xdrproc_t) xdr_remote_network_create_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NetworkCreateXml => 40 */
.fn = (dispatch_fn) remoteDispatchNetworkCreateXml,
.args_filter = (xdrproc_t) xdr_remote_network_create_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_network_create_xml_ret,
},
{ /* NetworkDefineXml => 41 */
.fn = (dispatch_fn) remoteDispatchNetworkDefineXml,
.args_filter = (xdrproc_t) xdr_remote_network_define_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_network_define_xml_ret,
},
{ /* NetworkDestroy => 42 */
.fn = (dispatch_fn) remoteDispatchNetworkDestroy,
.args_filter = (xdrproc_t) xdr_remote_network_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NetworkDumpXml => 43 */
.fn = (dispatch_fn) remoteDispatchNetworkDumpXml,
.args_filter = (xdrproc_t) xdr_remote_network_dump_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_network_dump_xml_ret,
},
{ /* NetworkGetAutostart => 44 */
.fn = (dispatch_fn) remoteDispatchNetworkGetAutostart,
.args_filter = (xdrproc_t) xdr_remote_network_get_autostart_args,
.ret_filter = (xdrproc_t) xdr_remote_network_get_autostart_ret,
},
{ /* NetworkGetBridgeName => 45 */
.fn = (dispatch_fn) remoteDispatchNetworkGetBridgeName,
.args_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_args,
.ret_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_ret,
},
{ /* NetworkLookupByName => 46 */
.fn = (dispatch_fn) remoteDispatchNetworkLookupByName,
.args_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_ret,
},
{ /* NetworkLookupByUuid => 47 */
.fn = (dispatch_fn) remoteDispatchNetworkLookupByUuid,
.args_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_args,
.ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret,
},
{ /* NetworkSetAutostart => 48 */
.fn = (dispatch_fn) remoteDispatchNetworkSetAutostart,
.args_filter = (xdrproc_t) xdr_remote_network_set_autostart_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NetworkUndefine => 49 */
.fn = (dispatch_fn) remoteDispatchNetworkUndefine,
.args_filter = (xdrproc_t) xdr_remote_network_undefine_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NumOfDefinedNetworks => 50 */
.fn = (dispatch_fn) remoteDispatchNumOfDefinedNetworks,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_defined_networks_ret,
},
{ /* NumOfDomains => 51 */
.fn = (dispatch_fn) remoteDispatchNumOfDomains,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret,
},
{ /* NumOfNetworks => 52 */
.fn = (dispatch_fn) remoteDispatchNumOfNetworks,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_networks_ret,
},
{ /* DomainCoreDump => 53 */
.fn = (dispatch_fn) remoteDispatchDomainCoreDump,
.args_filter = (xdrproc_t) xdr_remote_domain_core_dump_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainRestore => 54 */
.fn = (dispatch_fn) remoteDispatchDomainRestore,
.args_filter = (xdrproc_t) xdr_remote_domain_restore_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainSave => 55 */
.fn = (dispatch_fn) remoteDispatchDomainSave,
.args_filter = (xdrproc_t) xdr_remote_domain_save_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainGetSchedulerType => 56 */
.fn = (dispatch_fn) remoteDispatchDomainGetSchedulerType,
.args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_ret,
},
{ /* DomainGetSchedulerParameters => 57 */
.fn = (dispatch_fn) remoteDispatchDomainGetSchedulerParameters,
.args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret,
},
{ /* DomainSetSchedulerParameters => 58 */
.fn = (dispatch_fn) remoteDispatchDomainSetSchedulerParameters,
.args_filter = (xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* GetHostname => 59 */
.fn = (dispatch_fn) remoteDispatchGetHostname,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_get_hostname_ret,
},
{ /* SupportsFeature => 60 */
.fn = (dispatch_fn) remoteDispatchSupportsFeature,
.args_filter = (xdrproc_t) xdr_remote_supports_feature_args,
.ret_filter = (xdrproc_t) xdr_remote_supports_feature_ret,
},
{ /* DomainMigratePrepare => 61 */
.fn = (dispatch_fn) remoteDispatchDomainMigratePrepare,
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_ret,
},
{ /* DomainMigratePerform => 62 */
.fn = (dispatch_fn) remoteDispatchDomainMigratePerform,
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_perform_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainMigrateFinish => 63 */
.fn = (dispatch_fn) remoteDispatchDomainMigrateFinish,
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_ret,
},
{ /* DomainBlockStats => 64 */
.fn = (dispatch_fn) remoteDispatchDomainBlockStats,
.args_filter = (xdrproc_t) xdr_remote_domain_block_stats_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_block_stats_ret,
},
{ /* DomainInterfaceStats => 65 */
.fn = (dispatch_fn) remoteDispatchDomainInterfaceStats,
.args_filter = (xdrproc_t) xdr_remote_domain_interface_stats_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_interface_stats_ret,
},
{ /* AuthList => 66 */
.fn = (dispatch_fn) remoteDispatchAuthList,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_auth_list_ret,
},
{ /* AuthSaslInit => 67 */
.fn = (dispatch_fn) remoteDispatchAuthSaslInit,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_auth_sasl_init_ret,
},
{ /* AuthSaslStart => 68 */
.fn = (dispatch_fn) remoteDispatchAuthSaslStart,
.args_filter = (xdrproc_t) xdr_remote_auth_sasl_start_args,
.ret_filter = (xdrproc_t) xdr_remote_auth_sasl_start_ret,
},
{ /* AuthSaslStep => 69 */
.fn = (dispatch_fn) remoteDispatchAuthSaslStep,
.args_filter = (xdrproc_t) xdr_remote_auth_sasl_step_args,
.ret_filter = (xdrproc_t) xdr_remote_auth_sasl_step_ret,
},
{ /* AuthPolkit => 70 */
.fn = (dispatch_fn) remoteDispatchAuthPolkit,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_auth_polkit_ret,
},
{ /* NumOfStoragePools => 71 */
.fn = (dispatch_fn) remoteDispatchNumOfStoragePools,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_storage_pools_ret,
},
{ /* ListStoragePools => 72 */
.fn = (dispatch_fn) remoteDispatchListStoragePools,
.args_filter = (xdrproc_t) xdr_remote_list_storage_pools_args,
.ret_filter = (xdrproc_t) xdr_remote_list_storage_pools_ret,
},
{ /* NumOfDefinedStoragePools => 73 */
.fn = (dispatch_fn) remoteDispatchNumOfDefinedStoragePools,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret,
},
{ /* ListDefinedStoragePools => 74 */
.fn = (dispatch_fn) remoteDispatchListDefinedStoragePools,
.args_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_args,
.ret_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_ret,
},
{ /* FindStoragePoolSources => 75 */
.fn = (dispatch_fn) remoteDispatchFindStoragePoolSources,
.args_filter = (xdrproc_t) xdr_remote_find_storage_pool_sources_args,
.ret_filter = (xdrproc_t) xdr_remote_find_storage_pool_sources_ret,
},
{ /* StoragePoolCreateXml => 76 */
.fn = (dispatch_fn) remoteDispatchStoragePoolCreateXml,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_ret,
},
{ /* StoragePoolDefineXml => 77 */
.fn = (dispatch_fn) remoteDispatchStoragePoolDefineXml,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_ret,
},
{ /* StoragePoolCreate => 78 */
.fn = (dispatch_fn) remoteDispatchStoragePoolCreate,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_create_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolBuild => 79 */
.fn = (dispatch_fn) remoteDispatchStoragePoolBuild,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_build_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolDestroy => 80 */
.fn = (dispatch_fn) remoteDispatchStoragePoolDestroy,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolDelete => 81 */
.fn = (dispatch_fn) remoteDispatchStoragePoolDelete,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_delete_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolUndefine => 82 */
.fn = (dispatch_fn) remoteDispatchStoragePoolUndefine,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_undefine_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolRefresh => 83 */
.fn = (dispatch_fn) remoteDispatchStoragePoolRefresh,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_refresh_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolLookupByName => 84 */
.fn = (dispatch_fn) remoteDispatchStoragePoolLookupByName,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret,
},
{ /* StoragePoolLookupByUuid => 85 */
.fn = (dispatch_fn) remoteDispatchStoragePoolLookupByUuid,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret,
},
{ /* StoragePoolLookupByVolume => 86 */
.fn = (dispatch_fn) remoteDispatchStoragePoolLookupByVolume,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret,
},
{ /* StoragePoolGetInfo => 87 */
.fn = (dispatch_fn) remoteDispatchStoragePoolGetInfo,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_ret,
},
{ /* StoragePoolDumpXml => 88 */
.fn = (dispatch_fn) remoteDispatchStoragePoolDumpXml,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret,
},
{ /* StoragePoolGetAutostart => 89 */
.fn = (dispatch_fn) remoteDispatchStoragePoolGetAutostart,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret,
},
{ /* StoragePoolSetAutostart => 90 */
.fn = (dispatch_fn) remoteDispatchStoragePoolSetAutostart,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_set_autostart_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StoragePoolNumOfVolumes => 91 */
.fn = (dispatch_fn) remoteDispatchStoragePoolNumOfVolumes,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret,
},
{ /* StoragePoolListVolumes => 92 */
.fn = (dispatch_fn) remoteDispatchStoragePoolListVolumes,
.args_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret,
},
{ /* StorageVolCreateXml => 93 */
.fn = (dispatch_fn) remoteDispatchStorageVolCreateXml,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_ret,
},
{ /* StorageVolDelete => 94 */
.fn = (dispatch_fn) remoteDispatchStorageVolDelete,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_delete_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StorageVolLookupByName => 95 */
.fn = (dispatch_fn) remoteDispatchStorageVolLookupByName,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret,
},
{ /* StorageVolLookupByKey => 96 */
.fn = (dispatch_fn) remoteDispatchStorageVolLookupByKey,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret,
},
{ /* StorageVolLookupByPath => 97 */
.fn = (dispatch_fn) remoteDispatchStorageVolLookupByPath,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret,
},
{ /* StorageVolGetInfo => 98 */
.fn = (dispatch_fn) remoteDispatchStorageVolGetInfo,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_ret,
},
{ /* StorageVolDumpXml => 99 */
.fn = (dispatch_fn) remoteDispatchStorageVolDumpXml,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret,
},
{ /* StorageVolGetPath => 100 */
.fn = (dispatch_fn) remoteDispatchStorageVolGetPath,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_ret,
},
{ /* NodeGetCellsFreeMemory => 101 */
.fn = (dispatch_fn) remoteDispatchNodeGetCellsFreeMemory,
.args_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_args,
.ret_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_ret,
},
{ /* NodeGetFreeMemory => 102 */
.fn = (dispatch_fn) remoteDispatchNodeGetFreeMemory,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_node_get_free_memory_ret,
},
{ /* DomainBlockPeek => 103 */
.fn = (dispatch_fn) remoteDispatchDomainBlockPeek,
.args_filter = (xdrproc_t) xdr_remote_domain_block_peek_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_block_peek_ret,
},
{ /* DomainMemoryPeek => 104 */
.fn = (dispatch_fn) remoteDispatchDomainMemoryPeek,
.args_filter = (xdrproc_t) xdr_remote_domain_memory_peek_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_memory_peek_ret,
},
{ /* DomainEventsRegister => 105 */
.fn = (dispatch_fn) remoteDispatchDomainEventsRegister,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_domain_events_register_ret,
},
{ /* DomainEventsDeregister => 106 */
.fn = (dispatch_fn) remoteDispatchDomainEventsDeregister,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_domain_events_deregister_ret,
},
{ /* Async event DomainEvent => 107 */
.fn = NULL,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainMigratePrepare2 => 108 */
.fn = (dispatch_fn) remoteDispatchDomainMigratePrepare2,
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare2_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare2_ret,
},
{ /* DomainMigrateFinish2 => 109 */
.fn = (dispatch_fn) remoteDispatchDomainMigrateFinish2,
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish2_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish2_ret,
},
{ /* GetUri => 110 */
.fn = (dispatch_fn) remoteDispatchGetUri,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_get_uri_ret,
},
{ /* NodeNumOfDevices => 111 */
.fn = (dispatch_fn) remoteDispatchNodeNumOfDevices,
.args_filter = (xdrproc_t) xdr_remote_node_num_of_devices_args,
.ret_filter = (xdrproc_t) xdr_remote_node_num_of_devices_ret,
},
{ /* NodeListDevices => 112 */
.fn = (dispatch_fn) remoteDispatchNodeListDevices,
.args_filter = (xdrproc_t) xdr_remote_node_list_devices_args,
.ret_filter = (xdrproc_t) xdr_remote_node_list_devices_ret,
},
{ /* NodeDeviceLookupByName => 113 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceLookupByName,
.args_filter = (xdrproc_t) xdr_remote_node_device_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_lookup_by_name_ret,
},
{ /* NodeDeviceDumpXml => 114 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceDumpXml,
.args_filter = (xdrproc_t) xdr_remote_node_device_dump_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_dump_xml_ret,
},
{ /* NodeDeviceGetParent => 115 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceGetParent,
.args_filter = (xdrproc_t) xdr_remote_node_device_get_parent_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_get_parent_ret,
},
{ /* NodeDeviceNumOfCaps => 116 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceNumOfCaps,
.args_filter = (xdrproc_t) xdr_remote_node_device_num_of_caps_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_num_of_caps_ret,
},
{ /* NodeDeviceListCaps => 117 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceListCaps,
.args_filter = (xdrproc_t) xdr_remote_node_device_list_caps_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_list_caps_ret,
},
{ /* NodeDeviceDettach => 118 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceDettach,
.args_filter = (xdrproc_t) xdr_remote_node_device_dettach_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NodeDeviceReAttach => 119 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceReAttach,
.args_filter = (xdrproc_t) xdr_remote_node_device_re_attach_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* NodeDeviceReset => 120 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceReset,
.args_filter = (xdrproc_t) xdr_remote_node_device_reset_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainGetSecurityLabel => 121 */
.fn = (dispatch_fn) remoteDispatchDomainGetSecurityLabel,
.args_filter = (xdrproc_t) xdr_remote_domain_get_security_label_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_get_security_label_ret,
},
{ /* NodeGetSecurityModel => 122 */
.fn = (dispatch_fn) remoteDispatchNodeGetSecurityModel,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_node_get_security_model_ret,
},
{ /* NodeDeviceCreateXml => 123 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceCreateXml,
.args_filter = (xdrproc_t) xdr_remote_node_device_create_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_node_device_create_xml_ret,
},
{ /* NodeDeviceDestroy => 124 */
.fn = (dispatch_fn) remoteDispatchNodeDeviceDestroy,
.args_filter = (xdrproc_t) xdr_remote_node_device_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* StorageVolCreateXmlFrom => 125 */
.fn = (dispatch_fn) remoteDispatchStorageVolCreateXmlFrom,
.args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_from_args,
.ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_from_ret,
},
{ /* NumOfInterfaces => 126 */
.fn = (dispatch_fn) remoteDispatchNumOfInterfaces,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_interfaces_ret,
},
{ /* ListInterfaces => 127 */
.fn = (dispatch_fn) remoteDispatchListInterfaces,
.args_filter = (xdrproc_t) xdr_remote_list_interfaces_args,
.ret_filter = (xdrproc_t) xdr_remote_list_interfaces_ret,
},
{ /* InterfaceLookupByName => 128 */
.fn = (dispatch_fn) remoteDispatchInterfaceLookupByName,
.args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_args,
.ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_ret,
},
{ /* InterfaceLookupByMacString => 129 */
.fn = (dispatch_fn) remoteDispatchInterfaceLookupByMacString,
.args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_args,
.ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_ret,
},
{ /* InterfaceGetXmlDesc => 130 */
.fn = (dispatch_fn) remoteDispatchInterfaceGetXmlDesc,
.args_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_args,
.ret_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_ret,
},
{ /* InterfaceDefineXml => 131 */
.fn = (dispatch_fn) remoteDispatchInterfaceDefineXml,
.args_filter = (xdrproc_t) xdr_remote_interface_define_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_interface_define_xml_ret,
},
{ /* InterfaceUndefine => 132 */
.fn = (dispatch_fn) remoteDispatchInterfaceUndefine,
.args_filter = (xdrproc_t) xdr_remote_interface_undefine_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* InterfaceCreate => 133 */
.fn = (dispatch_fn) remoteDispatchInterfaceCreate,
.args_filter = (xdrproc_t) xdr_remote_interface_create_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* InterfaceDestroy => 134 */
.fn = (dispatch_fn) remoteDispatchInterfaceDestroy,
.args_filter = (xdrproc_t) xdr_remote_interface_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* DomainXmlFromNative => 135 */
.fn = (dispatch_fn) remoteDispatchDomainXmlFromNative,
.args_filter = (xdrproc_t) xdr_remote_domain_xml_from_native_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_xml_from_native_ret,
},
{ /* DomainXmlToNative => 136 */
.fn = (dispatch_fn) remoteDispatchDomainXmlToNative,
.args_filter = (xdrproc_t) xdr_remote_domain_xml_to_native_args,
.ret_filter = (xdrproc_t) xdr_remote_domain_xml_to_native_ret,
},
{ /* NumOfDefinedInterfaces => 137 */
.fn = (dispatch_fn) remoteDispatchNumOfDefinedInterfaces,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_defined_interfaces_ret,
},
{ /* ListDefinedInterfaces => 138 */
.fn = (dispatch_fn) remoteDispatchListDefinedInterfaces,
.args_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_args,
.ret_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_ret,
},
{ /* NumOfSecrets => 139 */
.fn = (dispatch_fn) remoteDispatchNumOfSecrets,
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_remote_num_of_secrets_ret,
},
{ /* ListSecrets => 140 */
.fn = (dispatch_fn) remoteDispatchListSecrets,
.args_filter = (xdrproc_t) xdr_remote_list_secrets_args,
.ret_filter = (xdrproc_t) xdr_remote_list_secrets_ret,
},
{ /* SecretLookupByUuid => 141 */
.fn = (dispatch_fn) remoteDispatchSecretLookupByUuid,
.args_filter = (xdrproc_t) xdr_remote_secret_lookup_by_uuid_args,
.ret_filter = (xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret,
},
{ /* SecretDefineXml => 142 */
.fn = (dispatch_fn) remoteDispatchSecretDefineXml,
.args_filter = (xdrproc_t) xdr_remote_secret_define_xml_args,
.ret_filter = (xdrproc_t) xdr_remote_secret_define_xml_ret,
},
{ /* SecretGetXmlDesc => 143 */
.fn = (dispatch_fn) remoteDispatchSecretGetXmlDesc,
.args_filter = (xdrproc_t) xdr_remote_secret_get_xml_desc_args,
.ret_filter = (xdrproc_t) xdr_remote_secret_get_xml_desc_ret,
},
{ /* SecretSetValue => 144 */
.fn = (dispatch_fn) remoteDispatchSecretSetValue,
.args_filter = (xdrproc_t) xdr_remote_secret_set_value_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* SecretGetValue => 145 */
.fn = (dispatch_fn) remoteDispatchSecretGetValue,
.args_filter = (xdrproc_t) xdr_remote_secret_get_value_args,
.ret_filter = (xdrproc_t) xdr_remote_secret_get_value_ret,
},
{ /* SecretUndefine => 146 */
.fn = (dispatch_fn) remoteDispatchSecretUndefine,
.args_filter = (xdrproc_t) xdr_remote_secret_undefine_args,
.ret_filter = (xdrproc_t) xdr_void,
},
{ /* SecretLookupByUsage => 147 */
.fn = (dispatch_fn) remoteDispatchSecretLookupByUsage,
.args_filter = (xdrproc_t) xdr_remote_secret_lookup_by_usage_args,
.ret_filter = (xdrproc_t) xdr_remote_secret_lookup_by_usage_ret,
},
daemon/remote_generate_stubs.pl
Executable
+178
View File
@@ -0,0 +1,178 @@
#!/usr/bin/perl -w
#
# This script parses remote_protocol.x and produces lots of boilerplate
# code for both ends of the remote connection.
#
# By Richard Jones <rjones@redhat.com>
use strict;
use Getopt::Std;
# Command line options.
our ($opt_p, $opt_t, $opt_a, $opt_r, $opt_d);
getopts ('ptard');
# Convert name_of_call to NameOfCall.
sub name_to_ProcName {
my $name = shift;
my @elems = split /_/, $name;
@elems = map ucfirst, @elems;
join "", @elems
}
# Read the input file (usually remote_protocol.x) and form an
# opinion about the name, args and return type of each RPC.
my ($name, $ProcName, $id, %calls, @calls);
# REMOTE_PROC_CLOSE has no args or ret.
$calls{close} = {
name => "close",
ProcName => "Close",
UC_NAME => "CLOSE",
args => "void",
ret => "void",
};
while (<>) {
if (/^struct remote_(.*)_args/) {
$name = $1;
$ProcName = name_to_ProcName ($name);
die "duplicate definition of remote_${name}_args"
if exists $calls{$name};
$calls{$name} = {
name => $name,
ProcName => $ProcName,
UC_NAME => uc $name,
args => "remote_${name}_args",
ret => "void",
};
} elsif (/^struct remote_(.*)_ret/) {
$name = $1;
$ProcName = name_to_ProcName ($name);
if (exists $calls{$name}) {
$calls{$name}->{ret} = "remote_${name}_ret";
} else {
$calls{$name} = {
name => $name,
ProcName => $ProcName,
UC_NAME => uc $name,
args => "void",
ret => "remote_${name}_ret"
}
}
} elsif (/^struct remote_(.*)_msg/) {
$name = $1;
$ProcName = name_to_ProcName ($name);
$calls{$name} = {
name => $name,
ProcName => $ProcName,
UC_NAME => uc $name,
msg => "remote_${name}_msg"
}
} elsif (/^\s*REMOTE_PROC_(.*?)\s+=\s+(\d+),?$/) {
$name = lc $1;
$id = $2;
$ProcName = name_to_ProcName ($name);
$calls[$id] = $calls{$name};
}
}
#----------------------------------------------------------------------
# Output
print <<__EOF__;
/* Automatically generated by remote_generate_stubs.pl.
* Do not edit this file. Any changes you make will be lost.
*/
__EOF__
# Debugging.
if ($opt_d) {
my @keys = sort (keys %calls);
foreach (@keys) {
print "$_:\n";
print " name $calls{$_}->{name} ($calls{$_}->{ProcName})\n";
print " $calls{$_}->{args} -> $calls{$_}->{ret}\n";
}
}
# Prototypes for dispatch functions ("remote_dispatch_prototypes.h").
elsif ($opt_p) {
my @keys = sort (keys %calls);
foreach (@keys) {
# Skip things which are REMOTE_MESSAGE
next if $calls{$_}->{msg};
print "static int remoteDispatch$calls{$_}->{ProcName}(\n";
print " struct qemud_server *server,\n";
print " struct qemud_client *client,\n";
print " virConnectPtr conn,\n";
print " remote_error *err,\n";
print " $calls{$_}->{args} *args,\n";
print " $calls{$_}->{ret} *ret);\n";
}
}
# Union of all arg types
# ("remote_dispatch_args.h").
elsif ($opt_a) {
for ($id = 0 ; $id <= $#calls ; $id++) {
if (defined $calls[$id] &&
!$calls[$id]->{msg} &&
$calls[$id]->{args} ne "void") {
print " $calls[$id]->{args} val_$calls[$id]->{args};\n";
}
}
}
# Union of all arg types
# ("remote_dispatch_ret.h").
elsif ($opt_r) {
for ($id = 0 ; $id <= $#calls ; $id++) {
if (defined $calls[$id] &&
!$calls[$id]->{msg} &&
$calls[$id]->{ret} ne "void") {
print " $calls[$id]->{ret} val_$calls[$id]->{ret};\n";
}
}
}
# Inside the switch statement, prepare the 'fn', 'args_filter', etc
# ("remote_dispatch_table.h").
elsif ($opt_t) {
for ($id = 0 ; $id <= $#calls ; $id++) {
if (defined $calls[$id] && !$calls[$id]->{msg}) {
print "{ /* $calls[$id]->{ProcName} => $id */\n";
print " .fn = (dispatch_fn) remoteDispatch$calls[$id]->{ProcName},\n";
if ($calls[$id]->{args} ne "void") {
print " .args_filter = (xdrproc_t) xdr_$calls[$id]->{args},\n";
} else {
print " .args_filter = (xdrproc_t) xdr_void,\n";
}
if ($calls[$id]->{ret} ne "void") {
print " .ret_filter = (xdrproc_t) xdr_$calls[$id]->{ret},\n";
} else {
print " .ret_filter = (xdrproc_t) xdr_void,\n";
}
print "},\n";
} else {
if ($calls[$id]->{msg}) {
print "{ /* Async event $calls[$id]->{ProcName} => $id */\n";
} else {
print "{ /* (unused) => $id */\n";
}
print " .fn = NULL,\n";
print " .args_filter = (xdrproc_t) xdr_void,\n";
print " .ret_filter = (xdrproc_t) xdr_void,\n";
print "},\n";
}
}
}
daemon/remote_protocol.c
+2744
View File
File diff suppressed because it is too large Load Diff
daemon/remote_protocol.h
+2223
View File
File diff suppressed because it is too large Load Diff
daemon/remote_protocol.x
+1596
View File
File diff suppressed because it is too large Load Diff
daemon/rpcgen_fix.pl
+91
View File
@@ -0,0 +1,91 @@
# Fix XDR code (generated by rpcgen) so that it compiles
# with warnings turned on.
#
# This code is evil. Arguably better would be just to compile
# without -Werror. Update: The IXDR_PUT_LONG replacements are
# actually fixes for 64 bit, so this file is necessary. Arguably
# so is the type-punning fix.
#
# Copyright (C) 2007 Red Hat, Inc.
#
# See COPYING for the license of this software.
#
# Richard Jones <rjones@redhat.com>
use strict;
my $in_function = 0;
my @function = ();
while (<>) {
if (m/^{/) {
$in_function = 1;
print;
next;
}
s/\t/ /g;
# Portability for Solaris RPC
s/u_quad_t/uint64_t/g;
s/quad_t/int64_t/g;
s/xdr_u_quad_t/xdr_uint64_t/g;
s/xdr_quad_t/xdr_int64_t/g;
s/IXDR_GET_LONG/IXDR_GET_INT32/g;
s,#include "\./remote_protocol\.h",#include "remote_protocol.h",;
if (m/^}/) {
$in_function = 0;
# Note: The body of the function is in @function.
# Remove decl of buf, if buf isn't used in the function.
my @uses = grep /\bbuf\b/, @function;
@function = grep !/\bbuf\b/, @function if @uses == 1;
# Remove decl of i, if i isn't used in the function.
@uses = grep /\bi\b/, @function;
@function = grep !/\bi\b/, @function if @uses == 1;
# (char **)&objp->... gives:
# warning: dereferencing type-punned pointer will break
# strict-aliasing rules
# so rewrite it.
my %uses = ();
my $i = 0;
foreach (@function) {
$uses{$1} = $i++ if m/\(char \*\*\)\&(objp->[a-z_.]+_val)/i;
}
if (keys %uses >= 1) {
my $i = 1;
foreach (keys %uses) {
$i = $uses{$_};
unshift @function,
(" char **objp_cpp$i = (char **) (void *) &$_;\n");
$i++;
}
@function =
map { s{\(char \*\*\)\&(objp->[a-z_.]+_val)}
{objp_cpp$uses{$1}}gi; $_ } @function;
}
# The code uses 'IXDR_PUT_{U_,}LONG' but it's wrong in two
# ways: Firstly these functions are deprecated and don't
# work on 64 bit platforms. Secondly the return value should
# be ignored. Correct both these mistakes.
@function =
map { s/\bIXDR_PUT_((U_)?)LONG\b/(void)IXDR_PUT_$1INT32/; $_ }
map { s/\bXDR_INLINE\b/(int32_t*)XDR_INLINE/; $_ }
@function;
print (join ("", @function));
@function = ();
}
unless ($in_function) {
print;
} else {
push @function, $_;
}
}
daemon/test_libvirtd.aug
+545
View File
@@ -0,0 +1,545 @@
module Test_libvirtd =
let conf = "# Master libvirt daemon configuration file
#
# For further information consult http://libvirt.org/format.html
#################################################################
#
# Network connectivity controls
#
# Flag listening for secure TLS connections on the public TCP/IP port.
# NB, must pass the --listen flag to the libvirtd process for this to
# have any effect.
#
# It is necessary to setup a CA and issue server certificates before
# using this capability.
#
# This is enabled by default, uncomment this to disable it
listen_tls = 0
# Listen for unencrypted TCP connections on the public TCP/IP port.
# NB, must pass the --listen flag to the libvirtd process for this to
# have any effect.
#
# Using the TCP socket requires SASL authentication by default. Only
# SASL mechanisms which support data encryption are allowed. This is
# DIGEST_MD5 and GSSAPI (Kerberos5)
#
# This is disabled by default, uncomment this to enable it.
listen_tcp = 1
# Override the port for accepting secure TLS connections
# This can be a port number, or service name
#
tls_port = \"16514\"
# Override the port for accepting insecure TCP connections
# This can be a port number, or service name
#
tcp_port = \"16509\"
# Override the default configuration which binds to all network
# interfaces. This can be a numeric IPv4/6 address, or hostname
#
listen_addr = \"192.168.0.1\"
# Flag toggling mDNS advertizement of the libvirt service.
#
# Alternatively can disable for all services on a host by
# stopping the Avahi daemon
#
# This is enabled by default, uncomment this to disable it
mdns_adv = 0
# Override the default mDNS advertizement name. This must be
# unique on the immediate broadcast network.
#
# The default is \"Virtualization Host HOSTNAME\", where HOSTNAME
# is subsituted for the short hostname of the machine (without domain)
#
mdns_name = \"Virtualization Host Joe Demo\"
#################################################################
#
# UNIX socket access controls
#
# Set the UNIX domain socket group ownership. This can be used to
# allow a 'trusted' set of users access to management capabilities
# without becoming root.
#
# This is restricted to 'root' by default.
unix_sock_group = \"libvirt\"
# Set the UNIX socket permissions for the R/O socket. This is used
# for monitoring VM status only
#
# Default allows any user. If setting group ownership may want to
# restrict this to:
unix_sock_ro_perms = \"0777\"
# Set the UNIX socket permissions for the R/W socket. This is used
# for full management of VMs
#
# Default allows only root. If PolicyKit is enabled on the socket,
# the default will change to allow everyone (eg, 0777)
#
# If not using PolicyKit and setting group ownership for access
# control then you may want to relax this to:
unix_sock_rw_perms = \"0770\"
#################################################################
#
# Authentication.
#
# - none: do not perform auth checks. If you can connect to the
# socket you are allowed. This is suitable if there are
# restrictions on connecting to the socket (eg, UNIX
# socket permissions), or if there is a lower layer in
# the network providing auth (eg, TLS/x509 certificates)
#
# - sasl: use SASL infrastructure. The actual auth scheme is then
# controlled from /etc/sasl2/libvirt.conf. For the TCP
# socket only GSSAPI & DIGEST-MD5 mechanisms will be used.
# For non-TCP or TLS sockets, any scheme is allowed.
#
# - polkit: use PolicyKit to authenticate. This is only suitable
# for use on the UNIX sockets. The default policy will
# require a user to supply their own password to gain
# full read/write access (aka sudo like), while anyone
# is allowed read/only access.
#
# Set an authentication scheme for UNIX read-only sockets
# By default socket permissions allow anyone to connect
#
# To restrict monitoring of domains you may wish to enable
# an authentication mechanism here
auth_unix_ro = \"none\"
# Set an authentication scheme for UNIX read-write sockets
# By default socket permissions only allow root. If PolicyKit
# support was compiled into libvirt, the default will be to
# use 'polkit' auth.
#
# If the unix_sock_rw_perms are changed you may wish to enable
# an authentication mechanism here
auth_unix_rw = \"none\"
# Change the authentication scheme for TCP sockets.
#
# If you don't enable SASL, then all TCP traffic is cleartext.
# Don't do this outside of a dev/test scenario. For real world
# use, always enable SASL and use the GSSAPI or DIGEST-MD5
# mechanism in /etc/sasl2/libvirt.conf
auth_tcp = \"sasl\"
# Change the authentication scheme for TLS sockets.
#
# TLS sockets already have encryption provided by the TLS
# layer, and limited authentication is done by certificates
#
# It is possible to make use of any SASL authentication
# mechanism as well, by using 'sasl' for this option
auth_tls = \"none\"
#################################################################
#
# TLS x509 certificate configuration
#
# Override the default server key file path
#
key_file = \"/etc/pki/libvirt/private/serverkey.pem\"
# Override the default server certificate file path
#
cert_file = \"/etc/pki/libvirt/servercert.pem\"
# Override the default CA certificate path
#
ca_file = \"/etc/pki/CA/cacert.pem\"
# Specify a certificate revocation list.
#
# Defaults to not using a CRL, uncomment to enable it
crl_file = \"/etc/pki/CA/crl.pem\"
#################################################################
#
# Authorization controls
#
# Flag to disable verification of client certificates
#
# Client certificate verification is the primary authentication mechanism.
# Any client which does not present a certificate signed by the CA
# will be rejected.
#
# Default is to always verify. Uncommenting this will disable
# verification - make sure an IP whitelist is set
tls_no_verify_certificate = 1
# A whitelist of allowed x509 Distinguished Names
# This list may contain wildcards such as
#
# \"C=GB,ST=London,L=London,O=Red Hat,CN=*\"
#
# See the POSIX fnmatch function for the format of the wildcards.
#
# NB If this is an empty list, no client can connect, so comment out
# entirely rather than using empty list to disable these checks
#
# By default, no DN's are checked
tls_allowed_dn_list = [\"DN1\", \"DN2\"]
# A whitelist of allowed SASL usernames. The format for usernames
# depends on the SASL authentication mechanism. Kerberos usernames
# look like username@REALM
#
# This list may contain wildcards such as
#
# \"*@EXAMPLE.COM\"
#
# See the POSIX fnmatch function for the format of the wildcards.
#
# NB If this is an empty list, no client can connect, so comment out
# entirely rather than using empty list to disable these checks
#
# By default, no Username's are checked
sasl_allowed_username_list = [
\"joe@EXAMPLE.COM\",
\"fred@EXAMPLE.COM\"
]
#################################################################
#
# Processing controls
#
# The maximum number of concurrent client connections to allow
# over all sockets combined.
max_clients = 20
# The minimum limit sets the number of workers to start up
# initially. If the number of active clients exceeds this,
# then more threads are spawned, upto max_workers limit.
# Typically you'd want max_workers to equal maximum number
# of clients allowed
min_workers = 5
max_workers = 20
# Total global limit on concurrent RPC calls. Should be
# at least as large as max_workers. Beyond this, RPC requests
# will be read into memory and queued. This directly impact
# memory usage, currently each request requires 256 KB of
# memory. So by default upto 5 MB of memory is used
max_requests = 20
# Limit on concurrent requests from a single client
# connection. To avoid one client monopolizing the server
# this should be a small fraction of the global max_requests
# and max_workers parameter
max_client_requests = 5
# Logging level:
log_level = 4
# Logging outputs:
log_outputs=\"4:stderr\"
# Logging filters:
log_filters=\"a\"
"
test Libvirtd.lns get conf =
{ "#comment" = "Master libvirt daemon configuration file" }
{ "#comment" = "" }
{ "#comment" = "For further information consult http://libvirt.org/format.html" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################" }
{ "#comment" = "" }
{ "#comment" = "Network connectivity controls" }
{ "#comment" = "" }
{ "#empty" }
{ "#comment" = "Flag listening for secure TLS connections on the public TCP/IP port." }
{ "#comment" = "NB, must pass the --listen flag to the libvirtd process for this to" }
{ "#comment" = "have any effect." }
{ "#comment" = "" }
{ "#comment" = "It is necessary to setup a CA and issue server certificates before" }
{ "#comment" = "using this capability." }
{ "#comment" = "" }
{ "#comment" = "This is enabled by default, uncomment this to disable it" }
{ "listen_tls" = "0" }
{ "#empty" }
{ "#comment" = "Listen for unencrypted TCP connections on the public TCP/IP port." }
{ "#comment" = "NB, must pass the --listen flag to the libvirtd process for this to" }
{ "#comment" = "have any effect." }
{ "#comment" = "" }
{ "#comment" = "Using the TCP socket requires SASL authentication by default. Only" }
{ "#comment" = "SASL mechanisms which support data encryption are allowed. This is" }
{ "#comment" = "DIGEST_MD5 and GSSAPI (Kerberos5)" }
{ "#comment" = "" }
{ "#comment" = "This is disabled by default, uncomment this to enable it." }
{ "listen_tcp" = "1" }
{ "#empty" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Override the port for accepting secure TLS connections" }
{ "#comment" = "This can be a port number, or service name" }
{ "#comment" = "" }
{ "tls_port" = "16514" }
{ "#empty" }
{ "#comment" = "Override the port for accepting insecure TCP connections" }
{ "#comment" = "This can be a port number, or service name" }
{ "#comment" = "" }
{ "tcp_port" = "16509" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Override the default configuration which binds to all network" }
{ "#comment" = "interfaces. This can be a numeric IPv4/6 address, or hostname" }
{ "#comment" = "" }
{ "listen_addr" = "192.168.0.1" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Flag toggling mDNS advertizement of the libvirt service." }
{ "#comment" = "" }
{ "#comment" = "Alternatively can disable for all services on a host by" }
{ "#comment" = "stopping the Avahi daemon" }
{ "#comment" = "" }
{ "#comment" = "This is enabled by default, uncomment this to disable it" }
{ "mdns_adv" = "0" }
{ "#empty" }
{ "#comment" = "Override the default mDNS advertizement name. This must be" }
{ "#comment" = "unique on the immediate broadcast network." }
{ "#comment" = "" }
{ "#comment" = "The default is \"Virtualization Host HOSTNAME\", where HOSTNAME" }
{ "#comment" = "is subsituted for the short hostname of the machine (without domain)" }
{ "#comment" = "" }
{ "mdns_name" = "Virtualization Host Joe Demo" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################" }
{ "#comment" = "" }
{ "#comment" = "UNIX socket access controls" }
{ "#comment" = "" }
{ "#empty" }
{ "#comment" = "Set the UNIX domain socket group ownership. This can be used to" }
{ "#comment" = "allow a 'trusted' set of users access to management capabilities" }
{ "#comment" = "without becoming root." }
{ "#comment" = "" }
{ "#comment" = "This is restricted to 'root' by default." }
{ "unix_sock_group" = "libvirt" }
{ "#empty" }
{ "#comment" = "Set the UNIX socket permissions for the R/O socket. This is used" }
{ "#comment" = "for monitoring VM status only" }
{ "#comment" = "" }
{ "#comment" = "Default allows any user. If setting group ownership may want to" }
{ "#comment" = "restrict this to:" }
{ "unix_sock_ro_perms" = "0777" }
{ "#empty" }
{ "#comment" = "Set the UNIX socket permissions for the R/W socket. This is used" }
{ "#comment" = "for full management of VMs" }
{ "#comment" = "" }
{ "#comment" = "Default allows only root. If PolicyKit is enabled on the socket," }
{ "#comment" = "the default will change to allow everyone (eg, 0777)" }
{ "#comment" = "" }
{ "#comment" = "If not using PolicyKit and setting group ownership for access" }
{ "#comment" = "control then you may want to relax this to:" }
{ "unix_sock_rw_perms" = "0770" }
{ "#empty" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################" }
{ "#comment" = "" }
{ "#comment" = "Authentication." }
{ "#comment" = "" }
{ "#comment" = "- none: do not perform auth checks. If you can connect to the" }
{ "#comment" = "socket you are allowed. This is suitable if there are" }
{ "#comment" = "restrictions on connecting to the socket (eg, UNIX" }
{ "#comment" = "socket permissions), or if there is a lower layer in" }
{ "#comment" = "the network providing auth (eg, TLS/x509 certificates)" }
{ "#comment" = "" }
{ "#comment" = "- sasl: use SASL infrastructure. The actual auth scheme is then" }
{ "#comment" = "controlled from /etc/sasl2/libvirt.conf. For the TCP" }
{ "#comment" = "socket only GSSAPI & DIGEST-MD5 mechanisms will be used." }
{ "#comment" = "For non-TCP or TLS sockets, any scheme is allowed." }
{ "#comment" = "" }
{ "#comment" = "- polkit: use PolicyKit to authenticate. This is only suitable" }
{ "#comment" = "for use on the UNIX sockets. The default policy will" }
{ "#comment" = "require a user to supply their own password to gain" }
{ "#comment" = "full read/write access (aka sudo like), while anyone" }
{ "#comment" = "is allowed read/only access." }
{ "#comment" = "" }
{ "#comment" = "Set an authentication scheme for UNIX read-only sockets" }
{ "#comment" = "By default socket permissions allow anyone to connect" }
{ "#comment" = "" }
{ "#comment" = "To restrict monitoring of domains you may wish to enable" }
{ "#comment" = "an authentication mechanism here" }
{ "auth_unix_ro" = "none" }
{ "#empty" }
{ "#comment" = "Set an authentication scheme for UNIX read-write sockets" }
{ "#comment" = "By default socket permissions only allow root. If PolicyKit" }
{ "#comment" = "support was compiled into libvirt, the default will be to" }
{ "#comment" = "use 'polkit' auth." }
{ "#comment" = "" }
{ "#comment" = "If the unix_sock_rw_perms are changed you may wish to enable" }
{ "#comment" = "an authentication mechanism here" }
{ "auth_unix_rw" = "none" }
{ "#empty" }
{ "#comment" = "Change the authentication scheme for TCP sockets." }
{ "#comment" = "" }
{ "#comment" = "If you don't enable SASL, then all TCP traffic is cleartext." }
{ "#comment" = "Don't do this outside of a dev/test scenario. For real world" }
{ "#comment" = "use, always enable SASL and use the GSSAPI or DIGEST-MD5" }
{ "#comment" = "mechanism in /etc/sasl2/libvirt.conf" }
{ "auth_tcp" = "sasl" }
{ "#empty" }
{ "#comment" = "Change the authentication scheme for TLS sockets." }
{ "#comment" = "" }
{ "#comment" = "TLS sockets already have encryption provided by the TLS" }
{ "#comment" = "layer, and limited authentication is done by certificates" }
{ "#comment" = "" }
{ "#comment" = "It is possible to make use of any SASL authentication" }
{ "#comment" = "mechanism as well, by using 'sasl' for this option" }
{ "auth_tls" = "none" }
{ "#empty" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################" }
{ "#comment" = "" }
{ "#comment" = "TLS x509 certificate configuration" }
{ "#comment" = "" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Override the default server key file path" }
{ "#comment" = "" }
{ "key_file" = "/etc/pki/libvirt/private/serverkey.pem" }
{ "#empty" }
{ "#comment" = "Override the default server certificate file path" }
{ "#comment" = "" }
{ "cert_file" = "/etc/pki/libvirt/servercert.pem" }
{ "#empty" }
{ "#comment" = "Override the default CA certificate path" }
{ "#comment" = "" }
{ "ca_file" = "/etc/pki/CA/cacert.pem" }
{ "#empty" }
{ "#comment" = "Specify a certificate revocation list." }
{ "#comment" = "" }
{ "#comment" = "Defaults to not using a CRL, uncomment to enable it" }
{ "crl_file" = "/etc/pki/CA/crl.pem" }
{ "#empty" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################" }
{ "#comment" = "" }
{ "#comment" = "Authorization controls" }
{ "#comment" = "" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Flag to disable verification of client certificates" }
{ "#comment" = "" }
{ "#comment" = "Client certificate verification is the primary authentication mechanism." }
{ "#comment" = "Any client which does not present a certificate signed by the CA" }
{ "#comment" = "will be rejected." }
{ "#comment" = "" }
{ "#comment" = "Default is to always verify. Uncommenting this will disable" }
{ "#comment" = "verification - make sure an IP whitelist is set" }
{ "tls_no_verify_certificate" = "1" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "A whitelist of allowed x509 Distinguished Names" }
{ "#comment" = "This list may contain wildcards such as" }
{ "#comment" = "" }
{ "#comment" = "\"C=GB,ST=London,L=London,O=Red Hat,CN=*\"" }
{ "#comment" = "" }
{ "#comment" = "See the POSIX fnmatch function for the format of the wildcards." }
{ "#comment" = "" }
{ "#comment" = "NB If this is an empty list, no client can connect, so comment out" }
{ "#comment" = "entirely rather than using empty list to disable these checks" }
{ "#comment" = "" }
{ "#comment" = "By default, no DN's are checked" }
{ "tls_allowed_dn_list"
{ "1" = "DN1"}
{ "2" = "DN2"}
}
{ "#empty" }
{ "#empty" }
{ "#comment" = "A whitelist of allowed SASL usernames. The format for usernames" }
{ "#comment" = "depends on the SASL authentication mechanism. Kerberos usernames" }
{ "#comment" = "look like username@REALM" }
{ "#comment" = "" }
{ "#comment" = "This list may contain wildcards such as" }
{ "#comment" = "" }
{ "#comment" = "\"*@EXAMPLE.COM\"" }
{ "#comment" = "" }
{ "#comment" = "See the POSIX fnmatch function for the format of the wildcards." }
{ "#comment" = "" }
{ "#comment" = "NB If this is an empty list, no client can connect, so comment out" }
{ "#comment" = "entirely rather than using empty list to disable these checks" }
{ "#comment" = "" }
{ "#comment" = "By default, no Username's are checked" }
{ "sasl_allowed_username_list"
{ "1" = "joe@EXAMPLE.COM" }
{ "2" = "fred@EXAMPLE.COM" }
}
{ "#empty" }
{ "#empty" }
{ "#comment" = "################################################################"}
{ "#comment" = ""}
{ "#comment" = "Processing controls"}
{ "#comment" = ""}
{ "#empty" }
{ "#comment" = "The maximum number of concurrent client connections to allow"}
{ "#comment" = "over all sockets combined."}
{ "max_clients" = "20" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "The minimum limit sets the number of workers to start up"}
{ "#comment" = "initially. If the number of active clients exceeds this,"}
{ "#comment" = "then more threads are spawned, upto max_workers limit."}
{ "#comment" = "Typically you'd want max_workers to equal maximum number"}
{ "#comment" = "of clients allowed"}
{ "min_workers" = "5" }
{ "max_workers" = "20" }
{ "#empty" }
{ "#comment" = "Total global limit on concurrent RPC calls. Should be" }
{ "#comment" = "at least as large as max_workers. Beyond this, RPC requests" }
{ "#comment" = "will be read into memory and queued. This directly impact" }
{ "#comment" = "memory usage, currently each request requires 256 KB of" }
{ "#comment" = "memory. So by default upto 5 MB of memory is used" }
{ "max_requests" = "20" }
{ "#empty" }
{ "#comment" = "Limit on concurrent requests from a single client" }
{ "#comment" = "connection. To avoid one client monopolizing the server" }
{ "#comment" = "this should be a small fraction of the global max_requests" }
{ "#comment" = "and max_workers parameter" }
{ "max_client_requests" = "5" }
{ "#empty" }
{ "#comment" = "Logging level:" }
{ "log_level" = "4" }
{ "#empty" }
{ "#comment" = "Logging outputs:" }
{ "log_outputs" = "4:stderr" }
{ "#empty" }
{ "#comment" = "Logging filters:" }
{ "log_filters" = "a" }
daemon/test_libvirtd_qemu.aug
+198
View File
@@ -0,0 +1,198 @@
module Test_libvirtd_qemu =
let conf = "# Master configuration file for the QEMU driver.
# All settings described here are optional - if omitted, sensible
# defaults are used.
# VNC is configured to listen on 127.0.0.1 by default.
# To make it listen on all public interfaces, uncomment
# this next option.
#
# NB, strong recommendation to enable TLS + x509 certificate
# verification when allowing public access
#
vnc_listen = \"0.0.0.0\"
# Enable use of TLS encryption on the VNC server. This requires
# a VNC client which supports the VeNCrypt protocol extension.
# Examples include vinagre, virt-viewer, virt-manager and vencrypt
# itself. UltraVNC, RealVNC, TightVNC do not support this
#
# It is necessary to setup CA and issue a server certificate
# before enabling this.
#
vnc_tls = 1
# Use of TLS requires that x509 certificates be issued. The
# default it to keep them in /etc/pki/libvirt-vnc. This directory
# must contain
#
# ca-cert.pem - the CA master certificate
# server-cert.pem - the server certificate signed with ca-cert.pem
# server-key.pem - the server private key
#
# This option allows the certificate directory to be changed
#
vnc_tls_x509_cert_dir = \"/etc/pki/libvirt-vnc\"
# The default TLS configuration only uses certificates for the server
# allowing the client to verify the server's identity and establish
# and encrypted channel.
#
# It is possible to use x509 certificates for authentication too, by
# issuing a x509 certificate to every client who needs to connect.
#
# Enabling this option will reject any client who does not have a
# certificate signed by the CA in /etc/pki/libvirt-vnc/ca-cert.pem
#
vnc_tls_x509_verify = 1
# The default VNC password. Only 8 letters are significant for
# VNC passwords. This parameter is only used if the per-domain
# XML config does not already provide a password. To allow
# access without passwords, leave this commented out. An empty
# string will still enable passwords, but be rejected by QEMU
# effectively preventing any use of VNC. Obviously change this
# example here before you set this
#
vnc_password = \"XYZ12345\"
# Enable use of SASL encryption on the VNC server. This requires
# a VNC client which supports the SASL protocol extension.
# Examples include vinagre, virt-viewer and virt-manager
# itself. UltraVNC, RealVNC, TightVNC do not support this
#
# It is necessary to configure /etc/sasl2/qemu.conf to choose
# the desired SASL plugin (eg, GSSPI for Kerberos)
#
vnc_sasl = 1
# The default SASL configuration file is located in /etc/sasl2/
# When running libvirtd unprivileged, it may be desirable to
# override the configs in this location. Set this parameter to
# point to the directory, and create a qemu.conf in that location
#
vnc_sasl_dir = \"/some/directory/sasl2\"
security_driver = \"selinux\"
user = \"root\"
group = \"root\"
cgroup_controllers = [ \"cpu\", \"devices\" ]
cgroup_device_acl = [ \"/dev/null\", \"/dev/full\", \"/dev/zero\" ]
save_image_format = \"gzip\"
hugetlbfs_mount = \"/dev/hugepages\"
"
test Libvirtd_qemu.lns get conf =
{ "#comment" = "Master configuration file for the QEMU driver." }
{ "#comment" = "All settings described here are optional - if omitted, sensible" }
{ "#comment" = "defaults are used." }
{ "#empty" }
{ "#comment" = "VNC is configured to listen on 127.0.0.1 by default." }
{ "#comment" = "To make it listen on all public interfaces, uncomment" }
{ "#comment" = "this next option." }
{ "#comment" = "" }
{ "#comment" = "NB, strong recommendation to enable TLS + x509 certificate" }
{ "#comment" = "verification when allowing public access" }
{ "#comment" = "" }
{ "vnc_listen" = "0.0.0.0" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Enable use of TLS encryption on the VNC server. This requires" }
{ "#comment" = "a VNC client which supports the VeNCrypt protocol extension." }
{ "#comment" = "Examples include vinagre, virt-viewer, virt-manager and vencrypt" }
{ "#comment" = "itself. UltraVNC, RealVNC, TightVNC do not support this" }
{ "#comment" = "" }
{ "#comment" = "It is necessary to setup CA and issue a server certificate" }
{ "#comment" = "before enabling this." }
{ "#comment" = "" }
{ "vnc_tls" = "1" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Use of TLS requires that x509 certificates be issued. The" }
{ "#comment" = "default it to keep them in /etc/pki/libvirt-vnc. This directory" }
{ "#comment" = "must contain" }
{ "#comment" = "" }
{ "#comment" = "ca-cert.pem - the CA master certificate" }
{ "#comment" = "server-cert.pem - the server certificate signed with ca-cert.pem" }
{ "#comment" = "server-key.pem - the server private key" }
{ "#comment" = "" }
{ "#comment" = "This option allows the certificate directory to be changed" }
{ "#comment" = "" }
{ "vnc_tls_x509_cert_dir" = "/etc/pki/libvirt-vnc" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "The default TLS configuration only uses certificates for the server" }
{ "#comment" = "allowing the client to verify the server's identity and establish" }
{ "#comment" = "and encrypted channel." }
{ "#comment" = "" }
{ "#comment" = "It is possible to use x509 certificates for authentication too, by" }
{ "#comment" = "issuing a x509 certificate to every client who needs to connect." }
{ "#comment" = "" }
{ "#comment" = "Enabling this option will reject any client who does not have a" }
{ "#comment" = "certificate signed by the CA in /etc/pki/libvirt-vnc/ca-cert.pem" }
{ "#comment" = "" }
{ "vnc_tls_x509_verify" = "1" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "The default VNC password. Only 8 letters are significant for" }
{ "#comment" = "VNC passwords. This parameter is only used if the per-domain" }
{ "#comment" = "XML config does not already provide a password. To allow" }
{ "#comment" = "access without passwords, leave this commented out. An empty" }
{ "#comment" = "string will still enable passwords, but be rejected by QEMU" }
{ "#comment" = "effectively preventing any use of VNC. Obviously change this" }
{ "#comment" = "example here before you set this" }
{ "#comment" = "" }
{ "vnc_password" = "XYZ12345" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "Enable use of SASL encryption on the VNC server. This requires" }
{ "#comment" = "a VNC client which supports the SASL protocol extension." }
{ "#comment" = "Examples include vinagre, virt-viewer and virt-manager" }
{ "#comment" = "itself. UltraVNC, RealVNC, TightVNC do not support this" }
{ "#comment" = "" }
{ "#comment" = "It is necessary to configure /etc/sasl2/qemu.conf to choose" }
{ "#comment" = "the desired SASL plugin (eg, GSSPI for Kerberos)" }
{ "#comment" = "" }
{ "vnc_sasl" = "1" }
{ "#empty" }
{ "#empty" }
{ "#comment" = "The default SASL configuration file is located in /etc/sasl2/" }
{ "#comment" = "When running libvirtd unprivileged, it may be desirable to" }
{ "#comment" = "override the configs in this location. Set this parameter to" }
{ "#comment" = "point to the directory, and create a qemu.conf in that location" }
{ "#comment" = "" }
{ "vnc_sasl_dir" = "/some/directory/sasl2" }
{ "#empty" }
{ "security_driver" = "selinux" }
{ "#empty" }
{ "user" = "root" }
{ "#empty" }
{ "group" = "root" }
{ "#empty" }
{ "cgroup_controllers"
{ "1" = "cpu" }
{ "2" = "devices" }
}
{ "#empty" }
{ "cgroup_device_acl"
{ "1" = "/dev/null" }
{ "2" = "/dev/full" }
{ "3" = "/dev/zero" }
}
{ "#empty" }
{ "save_image_format" = "gzip" }
{ "#empty" }
{ "hugetlbfs_mount" = "/dev/hugepages" }