LCOV = lcov
GENHTML = genhtml
-SUBDIRS = gnulib/lib include src qemud tools proxy docs gnulib/tests \
+SUBDIRS = gnulib/lib include src daemon tools proxy docs gnulib/tests \
python tests po examples/domain-events/events-c examples/hellolibvirt
ACLOCAL_AMFLAGS = -I m4 -I gnulib/m4
cov: clean-cov
mkdir $(top_builddir)/coverage
- $(LCOV) -c -o $(top_builddir)/coverage/libvirt.info.tmp -d $(top_srcdir)/src -d $(top_srcdir)/qemud -d $(top_srcdir)/tests
+ $(LCOV) -c -o $(top_builddir)/coverage/libvirt.info.tmp -d $(top_srcdir)/src -d $(top_srcdir)/daemon -d $(top_srcdir)/tests
$(LCOV) -r $(top_builddir)/coverage/libvirt.info.tmp -o $(top_builddir)/coverage/libvirt.info *usr*
rm $(top_builddir)/coverage/libvirt.info.tmp
$(GENHTML) -s -t "libvirt" -o $(top_builddir)/coverage --legend $(top_builddir)/coverage/libvirt.info
po/Makefile.in \
include/libvirt/Makefile include/libvirt/libvirt.h \
python/Makefile python/tests/Makefile \
- qemud/Makefile \
+ daemon/Makefile \
tools/Makefile \
tests/Makefile proxy/Makefile \
tests/xml2sexprdata/Makefile \
--- /dev/null
+*.gcda
+*.gcno
+*.la
+*.lo
+.deps
+.libs
+Makefile
+Makefile.in
+libvirt_qemud
+libvirtd
+libvirtd.init
+libvirtd.logrotate
--- /dev/null
+## 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
--- /dev/null
+
+ 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.
--- /dev/null
+<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>
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+/*
+ * 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__ */
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+/*
+ * 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__ */
--- /dev/null
+(* /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
--- /dev/null
+# 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
--- /dev/null
+#!/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
--- /dev/null
+@localstatedir@/log/libvirt/qemu/*.log {
+ daily
+ missingok
+ rotate 7
+ compress
+ delaycompress
+ copytruncate
+}
--- /dev/null
+<!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>
--- /dev/null
+<!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>
--- /dev/null
+# 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
--- /dev/null
+# 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
--- /dev/null
+(* /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
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+/*
+ * 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__ */
--- /dev/null
+/*
+ * qemud.c: daemon start of day, guest process & i/o management
+ *
+ * Copyright (C) 2006, 2007, 2008, 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>
+ */
+
+#include <config.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/poll.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <string.h>
+#include <errno.h>
+#include <getopt.h>
+#include <fnmatch.h>
+#include <grp.h>
+#include <signal.h>
+#include <netdb.h>
+
+#include "libvirt_internal.h"
+#include "virterror_internal.h"
+
+#define VIR_FROM_THIS VIR_FROM_QEMU
+
+#include "qemud.h"
+#include "dispatch.h"
+
+#include "util.h"
+#include "remote_internal.h"
+#include "conf.h"
+#include "event.h"
+#include "memory.h"
+#ifdef HAVE_AVAHI
+#include "mdns.h"
+#endif
+
+#ifdef WITH_DRIVER_MODULES
+#include "driver.h"
+#else
+#ifdef WITH_QEMU
+#include "qemu_driver.h"
+#endif
+#ifdef WITH_LXC
+#include "lxc_driver.h"
+#endif
+#ifdef WITH_UML
+#include "uml_driver.h"
+#endif
+#ifdef WITH_ONE
+#include "opennebula/one_driver.h"
+#endif
+#ifdef WITH_NETWORK
+#include "network_driver.h"
+#endif
+#ifdef WITH_NETCF
+#include "interface_driver.h"
+#endif
+#ifdef WITH_STORAGE_DIR
+#include "storage_driver.h"
+#endif
+#ifdef WITH_NODE_DEVICES
+#include "node_device.h"
+#endif
+#include "secret_driver.h"
+#endif
+
+
+#ifdef __sun
+#include <ucred.h>
+#include <priv.h>
+
+#ifndef PRIV_VIRT_MANAGE
+#define PRIV_VIRT_MANAGE ((const char *)"virt_manage")
+#endif
+
+#ifndef PRIV_XVM_CONTROL
+#define PRIV_XVM_CONTROL ((const char *)"xvm_control")
+#endif
+
+#define PU_RESETGROUPS 0x0001 /* Remove supplemental groups */
+#define PU_CLEARLIMITSET 0x0008 /* L=0 */
+
+extern int __init_daemon_priv(int, uid_t, gid_t, ...);
+
+#define SYSTEM_UID 60
+
+static gid_t unix_sock_gid = 60; /* Not used */
+static int unix_sock_rw_mask = 0666;
+static int unix_sock_ro_mask = 0666;
+
+#else
+
+static gid_t unix_sock_gid = 0; /* Only root by default */
+static int unix_sock_rw_mask = 0700; /* Allow user only */
+static int unix_sock_ro_mask = 0777; /* Allow world */
+
+#endif /* __sun */
+
+static int godaemon = 0; /* -d: Be a daemon */
+static int verbose = 0; /* -v: Verbose mode */
+static int timeout = -1; /* -t: Shutdown timeout */
+static int sigwrite = -1; /* Signal handler pipe */
+static int ipsock = 0; /* -l Listen for TCP/IP */
+
+/* Defaults for configuration file elements */
+static int listen_tls = 1;
+static int listen_tcp = 0;
+static char *listen_addr = (char *) LIBVIRTD_LISTEN_ADDR;
+static char *tls_port = (char *) LIBVIRTD_TLS_PORT;
+static char *tcp_port = (char *) LIBVIRTD_TCP_PORT;
+
+static char *unix_sock_dir = NULL;
+
+#if HAVE_POLKIT
+static int auth_unix_rw = REMOTE_AUTH_POLKIT;
+static int auth_unix_ro = REMOTE_AUTH_POLKIT;
+#else
+static int auth_unix_rw = REMOTE_AUTH_NONE;
+static int auth_unix_ro = REMOTE_AUTH_NONE;
+#endif /* HAVE_POLKIT */
+#if HAVE_SASL
+static int auth_tcp = REMOTE_AUTH_SASL;
+#else
+static int auth_tcp = REMOTE_AUTH_NONE;
+#endif
+static int auth_tls = REMOTE_AUTH_NONE;
+
+static int mdns_adv = 1;
+static char *mdns_name = NULL;
+
+static int tls_no_verify_certificate = 0;
+static char **tls_allowed_dn_list = NULL;
+
+static char *key_file = (char *) LIBVIRT_SERVERKEY;
+static char *cert_file = (char *) LIBVIRT_SERVERCERT;
+static char *ca_file = (char *) LIBVIRT_CACERT;
+static char *crl_file = (char *) "";
+
+static gnutls_certificate_credentials_t x509_cred;
+static gnutls_dh_params_t dh_params;
+
+static int min_workers = 5;
+static int max_workers = 20;
+static int max_clients = 20;
+
+/* Total number of 'in-process' RPC calls allowed across all clients */
+static int max_requests = 20;
+/* Total number of 'in-process' RPC calls allowed by a single client*/
+static int max_client_requests = 5;
+
+#define DH_BITS 1024
+
+static sig_atomic_t sig_errors = 0;
+static int sig_lasterrno = 0;
+
+static void sig_handler(int sig, siginfo_t * siginfo,
+ void* context ATTRIBUTE_UNUSED) {
+ int origerrno;
+ int r;
+
+ /* set the sig num in the struct */
+ siginfo->si_signo = sig;
+
+ origerrno = errno;
+ r = safewrite(sigwrite, siginfo, sizeof(*siginfo));
+ if (r == -1) {
+ sig_errors++;
+ sig_lasterrno = errno;
+ }
+ errno = origerrno;
+}
+
+static void qemudDispatchClientEvent(int watch, int fd, int events, void *opaque);
+static void qemudDispatchServerEvent(int watch, int fd, int events, void *opaque);
+static int qemudStartWorker(struct qemud_server *server, struct qemud_worker *worker);
+
+void
+qemudClientMessageQueuePush(struct qemud_client_message **queue,
+ struct qemud_client_message *msg)
+{
+ struct qemud_client_message *tmp = *queue;
+
+ if (tmp) {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = msg;
+ } else {
+ *queue = msg;
+ }
+}
+
+struct qemud_client_message *
+qemudClientMessageQueueServe(struct qemud_client_message **queue)
+{
+ struct qemud_client_message *tmp = *queue;
+
+ if (tmp) {
+ *queue = tmp->next;
+ tmp->next = NULL;
+ }
+
+ return tmp;
+}
+
+static int
+remoteCheckCertFile(const char *type, const char *file)
+{
+ struct stat sb;
+ if (stat(file, &sb) < 0) {
+ char ebuf[1024];
+ VIR_ERROR(_("Cannot access %s '%s': %s"),
+ type, file, virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+ return 0;
+}
+
+static int
+remoteInitializeGnuTLS (void)
+{
+ int err;
+
+ /* Initialise GnuTLS. */
+ gnutls_global_init ();
+
+ err = gnutls_certificate_allocate_credentials (&x509_cred);
+ if (err) {
+ VIR_ERROR(_("gnutls_certificate_allocate_credentials: %s"),
+ gnutls_strerror (err));
+ return -1;
+ }
+
+ if (ca_file && ca_file[0] != '\0') {
+ if (remoteCheckCertFile("CA certificate", ca_file) < 0)
+ return -1;
+
+ qemudDebug ("loading CA cert from %s", ca_file);
+ err = gnutls_certificate_set_x509_trust_file (x509_cred, ca_file,
+ GNUTLS_X509_FMT_PEM);
+ if (err < 0) {
+ VIR_ERROR(_("gnutls_certificate_set_x509_trust_file: %s"),
+ gnutls_strerror (err));
+ return -1;
+ }
+ }
+
+ if (crl_file && crl_file[0] != '\0') {
+ if (remoteCheckCertFile("CA revocation list", crl_file) < 0)
+ return -1;
+
+ DEBUG("loading CRL from %s", crl_file);
+ err = gnutls_certificate_set_x509_crl_file (x509_cred, crl_file,
+ GNUTLS_X509_FMT_PEM);
+ if (err < 0) {
+ VIR_ERROR(_("gnutls_certificate_set_x509_crl_file: %s"),
+ gnutls_strerror (err));
+ return -1;
+ }
+ }
+
+ if (cert_file && cert_file[0] != '\0' && key_file && key_file[0] != '\0') {
+ if (remoteCheckCertFile("server certificate", cert_file) < 0)
+ return -1;
+ if (remoteCheckCertFile("server key", key_file) < 0)
+ return -1;
+ DEBUG("loading cert and key from %s and %s", cert_file, key_file);
+ err =
+ gnutls_certificate_set_x509_key_file (x509_cred,
+ cert_file, key_file,
+ GNUTLS_X509_FMT_PEM);
+ if (err < 0) {
+ VIR_ERROR(_("gnutls_certificate_set_x509_key_file: %s"),
+ gnutls_strerror (err));
+ return -1;
+ }
+ }
+
+ /* Generate Diffie Hellman parameters - for use with DHE
+ * kx algorithms. These should be discarded and regenerated
+ * once a day, once a week or once a month. Depending on the
+ * security requirements.
+ */
+ err = gnutls_dh_params_init (&dh_params);
+ if (err < 0) {
+ VIR_ERROR(_("gnutls_dh_params_init: %s"), gnutls_strerror (err));
+ return -1;
+ }
+ err = gnutls_dh_params_generate2 (dh_params, DH_BITS);
+ if (err < 0) {
+ VIR_ERROR(_("gnutls_dh_params_generate2: %s"), gnutls_strerror (err));
+ return -1;
+ }
+
+ gnutls_certificate_set_dh_params (x509_cred, dh_params);
+
+ return 0;
+}
+
+static void
+qemudDispatchSignalEvent(int watch ATTRIBUTE_UNUSED,
+ int fd ATTRIBUTE_UNUSED,
+ int events ATTRIBUTE_UNUSED,
+ void *opaque) {
+ struct qemud_server *server = (struct qemud_server *)opaque;
+ siginfo_t siginfo;
+ int ret;
+
+ virMutexLock(&server->lock);
+
+ if (saferead(server->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
+ char ebuf[1024];
+ VIR_ERROR(_("Failed to read from signal pipe: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ virMutexUnlock(&server->lock);
+ return;
+ }
+
+ ret = 0;
+
+ switch (siginfo.si_signo) {
+ case SIGHUP:
+ VIR_INFO0(_("Reloading configuration on SIGHUP"));
+ if (virStateReload() < 0)
+ VIR_WARN0(_("Error while reloading drivers"));
+ break;
+
+ case SIGINT:
+ case SIGQUIT:
+ case SIGTERM:
+ VIR_WARN(_("Shutting down on signal %d"), siginfo.si_signo);
+ server->shutdown = 1;
+ break;
+
+ default:
+ VIR_INFO(_("Received unexpected signal %d"), siginfo.si_signo);
+ break;
+ }
+
+ if (ret != 0)
+ server->shutdown = 1;
+
+ virMutexUnlock(&server->lock);
+}
+
+
+static int qemudGoDaemon(void) {
+ int pid = fork();
+ switch (pid) {
+ case 0:
+ {
+ int stdinfd = -1;
+ int stdoutfd = -1;
+ int nextpid;
+
+ if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
+ goto cleanup;
+ if ((stdoutfd = open("/dev/null", O_WRONLY)) < 0)
+ goto cleanup;
+ if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
+ goto cleanup;
+ if (dup2(stdoutfd, STDOUT_FILENO) != STDOUT_FILENO)
+ goto cleanup;
+ if (dup2(stdoutfd, STDERR_FILENO) != STDERR_FILENO)
+ goto cleanup;
+ if (close(stdinfd) < 0)
+ goto cleanup;
+ stdinfd = -1;
+ if (close(stdoutfd) < 0)
+ goto cleanup;
+ stdoutfd = -1;
+
+ if (setsid() < 0)
+ goto cleanup;
+
+ nextpid = fork();
+ switch (nextpid) {
+ case 0:
+ return 0;
+ case -1:
+ return -1;
+ default:
+ _exit(0);
+ }
+
+ cleanup:
+ if (stdoutfd != -1)
+ close(stdoutfd);
+ if (stdinfd != -1)
+ close(stdinfd);
+ return -1;
+
+ }
+
+ case -1:
+ return -1;
+
+ default:
+ {
+ int got, status = 0;
+ /* We wait to make sure the next child forked
+ successfully */
+ if ((got = waitpid(pid, &status, 0)) < 0 ||
+ got != pid ||
+ status != 0) {
+ return -1;
+ }
+ _exit(0);
+ }
+ }
+}
+
+static int qemudWritePidFile(const char *pidFile) {
+ int fd;
+ FILE *fh;
+ char ebuf[1024];
+
+ if (pidFile[0] == '\0')
+ return 0;
+
+ if ((fd = open(pidFile, O_WRONLY|O_CREAT|O_EXCL, 0644)) < 0) {
+ VIR_ERROR(_("Failed to open pid file '%s' : %s"),
+ pidFile, virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ if (!(fh = fdopen(fd, "w"))) {
+ VIR_ERROR(_("Failed to fdopen pid file '%s' : %s"),
+ pidFile, virStrerror(errno, ebuf, sizeof ebuf));
+ close(fd);
+ return -1;
+ }
+
+ if (fprintf(fh, "%lu\n", (unsigned long)getpid()) < 0) {
+ VIR_ERROR(_("Failed to write to pid file '%s' : %s"),
+ pidFile, virStrerror(errno, ebuf, sizeof ebuf));
+ fclose(fh);
+ return -1;
+ }
+
+ if (fclose(fh) == EOF) {
+ VIR_ERROR(_("Failed to close pid file '%s' : %s"),
+ pidFile, virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ return 0;
+}
+
+static int qemudListenUnix(struct qemud_server *server,
+ const char *path, int readonly, int auth) {
+ struct qemud_socket *sock;
+ struct sockaddr_un addr;
+ mode_t oldmask;
+ gid_t oldgrp;
+ char ebuf[1024];
+
+ if (VIR_ALLOC(sock) < 0) {
+ VIR_ERROR("%s", _("Failed to allocate memory for struct qemud_socket"));
+ return -1;
+ }
+
+ sock->readonly = readonly;
+ sock->port = -1;
+ sock->type = QEMUD_SOCK_TYPE_UNIX;
+ sock->auth = auth;
+
+ if ((sock->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
+ VIR_ERROR(_("Failed to create socket: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ goto cleanup;
+ }
+
+ if (virSetCloseExec(sock->fd) < 0 ||
+ virSetNonBlock(sock->fd) < 0)
+ goto cleanup;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, path, sizeof(addr.sun_path)-1);
+ if (addr.sun_path[0] == '@')
+ addr.sun_path[0] = '\0';
+
+
+ oldgrp = getgid();
+ oldmask = umask(readonly ? ~unix_sock_ro_mask : ~unix_sock_rw_mask);
+ if (server->privileged)
+ setgid(unix_sock_gid);
+
+ if (bind(sock->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ VIR_ERROR(_("Failed to bind socket to '%s': %s"),
+ path, virStrerror(errno, ebuf, sizeof ebuf));
+ goto cleanup;
+ }
+ umask(oldmask);
+ if (server->privileged)
+ setgid(oldgrp);
+
+ if (listen(sock->fd, 30) < 0) {
+ VIR_ERROR(_("Failed to listen for connections on '%s': %s"),
+ path, virStrerror(errno, ebuf, sizeof ebuf));
+ goto cleanup;
+ }
+
+ if ((sock->watch = virEventAddHandleImpl(sock->fd,
+ VIR_EVENT_HANDLE_READABLE |
+ VIR_EVENT_HANDLE_ERROR |
+ VIR_EVENT_HANDLE_HANGUP,
+ qemudDispatchServerEvent,
+ server, NULL)) < 0) {
+ VIR_ERROR0(_("Failed to add server event callback"));
+ goto cleanup;
+ }
+
+ sock->next = server->sockets;
+ server->sockets = sock;
+ server->nsockets++;
+
+ return 0;
+
+ cleanup:
+ if (sock->fd)
+ close(sock->fd);
+ free(sock);
+ return -1;
+}
+
+// See: http://people.redhat.com/drepper/userapi-ipv6.html
+static int
+remoteMakeSockets (int *fds, int max_fds, int *nfds_r, const char *node, const char *service)
+{
+ struct addrinfo *ai;
+ struct addrinfo hints;
+ memset (&hints, 0, sizeof hints);
+ hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+ hints.ai_socktype = SOCK_STREAM;
+
+ int e = getaddrinfo (node, service, &hints, &ai);
+ if (e != 0) {
+ VIR_ERROR(_("getaddrinfo: %s\n"), gai_strerror (e));
+ return -1;
+ }
+
+ struct addrinfo *runp = ai;
+ while (runp && *nfds_r < max_fds) {
+ char ebuf[1024];
+ fds[*nfds_r] = socket (runp->ai_family, runp->ai_socktype,
+ runp->ai_protocol);
+ if (fds[*nfds_r] == -1) {
+ VIR_ERROR(_("socket: %s"), virStrerror (errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ int opt = 1;
+ setsockopt (fds[*nfds_r], SOL_SOCKET, SO_REUSEADDR, &opt, sizeof opt);
+
+ if (bind (fds[*nfds_r], runp->ai_addr, runp->ai_addrlen) == -1) {
+ if (errno != EADDRINUSE) {
+ VIR_ERROR(_("bind: %s"), virStrerror (errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+ close (fds[*nfds_r]);
+ }
+ else {
+ if (listen (fds[*nfds_r], SOMAXCONN) == -1) {
+ VIR_ERROR(_("listen: %s"),
+ virStrerror (errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+ ++*nfds_r;
+ }
+ runp = runp->ai_next;
+ }
+
+ freeaddrinfo (ai);
+ return 0;
+}
+
+/* Listen on the named/numbered TCP port. On a machine with IPv4 and
+ * IPv6 interfaces this may generate several sockets.
+ */
+static int
+remoteListenTCP (struct qemud_server *server,
+ const char *addr,
+ const char *port,
+ int type,
+ int auth)
+{
+ int fds[2];
+ int nfds = 0;
+ int i;
+ struct qemud_socket *sock;
+
+ if (remoteMakeSockets (fds, 2, &nfds, addr, port) == -1)
+ return -1;
+
+ for (i = 0; i < nfds; ++i) {
+ union {
+ struct sockaddr_storage sa_stor;
+ struct sockaddr sa;
+ struct sockaddr_in sa_in;
+#ifdef AF_INET6
+ struct sockaddr_in6 sa_in6;
+#endif
+ } s;
+ char ebuf[1024];
+ socklen_t salen = sizeof(s);
+
+ if (VIR_ALLOC(sock) < 0) {
+ VIR_ERROR(_("remoteListenTCP: calloc: %s"),
+ virStrerror (errno, ebuf, sizeof ebuf));
+ goto cleanup;
+ }
+
+ sock->readonly = 0;
+ sock->next = server->sockets;
+ server->sockets = sock;
+ server->nsockets++;
+
+ sock->fd = fds[i];
+ sock->type = type;
+ sock->auth = auth;
+
+ if (getsockname(sock->fd, &s.sa, &salen) < 0)
+ goto cleanup;
+
+ if (s.sa.sa_family == AF_INET) {
+ sock->port = htons(s.sa_in.sin_port);
+#ifdef AF_INET6
+ } else if (s.sa.sa_family == AF_INET6)
+ sock->port = htons(s.sa_in6.sin6_port);
+#endif
+ else
+ sock->port = -1;
+
+ if (virSetCloseExec(sock->fd) < 0 ||
+ virSetNonBlock(sock->fd) < 0)
+ goto cleanup;
+
+ if (listen (sock->fd, 30) < 0) {
+ VIR_ERROR(_("remoteListenTCP: listen: %s"),
+ virStrerror (errno, ebuf, sizeof ebuf));
+ goto cleanup;
+ }
+
+ if ((sock->watch = virEventAddHandleImpl(sock->fd,
+ VIR_EVENT_HANDLE_READABLE |
+ VIR_EVENT_HANDLE_ERROR |
+ VIR_EVENT_HANDLE_HANGUP,
+ qemudDispatchServerEvent,
+ server, NULL)) < 0) {
+ VIR_ERROR0(_("Failed to add server event callback"));
+ goto cleanup;
+ }
+
+ }
+
+ return 0;
+
+cleanup:
+ for (i = 0; i < nfds; ++i)
+ close(fds[i]);
+ return -1;
+}
+
+static int qemudInitPaths(struct qemud_server *server,
+ char *sockname,
+ char *roSockname,
+ int maxlen)
+{
+ char *sock_dir;
+ char *dir_prefix = NULL;
+ int ret = -1;
+ char *sock_dir_prefix = NULL;
+
+ if (unix_sock_dir)
+ sock_dir = unix_sock_dir;
+ else {
+ sock_dir = sockname;
+ if (server->privileged) {
+ dir_prefix = strdup (LOCAL_STATE_DIR);
+ if (dir_prefix == NULL) {
+ virReportOOMError(NULL);
+ goto cleanup;
+ }
+ if (snprintf (sock_dir, maxlen, "%s/run/libvirt",
+ dir_prefix) >= maxlen)
+ goto snprintf_error;
+ } else {
+ uid_t uid = geteuid();
+ dir_prefix = virGetUserDirectory(NULL, uid);
+ if (dir_prefix == NULL) {
+ /* Do not diagnose here; virGetUserDirectory does that. */
+ goto snprintf_error;
+ }
+
+ if (snprintf(sock_dir, maxlen, "%s/.libvirt", dir_prefix) >= maxlen)
+ goto snprintf_error;
+ }
+ }
+
+ sock_dir_prefix = strdup (sock_dir);
+ if (!sock_dir_prefix) {
+ virReportOOMError(NULL);
+ goto cleanup;
+ }
+
+ if (server->privileged) {
+ if (snprintf (sockname, maxlen, "%s/libvirt-sock",
+ sock_dir_prefix) >= maxlen
+ || (snprintf (roSockname, maxlen, "%s/libvirt-sock-ro",
+ sock_dir_prefix) >= maxlen))
+ goto snprintf_error;
+ unlink(sockname);
+ unlink(roSockname);
+ } else {
+ if (snprintf(sockname, maxlen, "@%s/libvirt-sock",
+ sock_dir_prefix) >= maxlen)
+ goto snprintf_error;
+ }
+
+ if (server->privileged)
+ server->logDir = strdup (LOCAL_STATE_DIR "/log/libvirt");
+ else
+ virAsprintf(&server->logDir, "%s/.libvirt/log", dir_prefix);
+
+ if (server->logDir == NULL)
+ virReportOOMError(NULL);
+
+ ret = 0;
+
+ snprintf_error:
+ if (ret)
+ VIR_ERROR("%s",
+ _("Resulting path too long for buffer in qemudInitPaths()"));
+
+ cleanup:
+ free (dir_prefix);
+ free (sock_dir_prefix);
+ return ret;
+}
+
+static struct qemud_server *qemudInitialize(int sigread) {
+ struct qemud_server *server;
+
+ if (VIR_ALLOC(server) < 0) {
+ VIR_ERROR0(_("Failed to allocate struct qemud_server"));
+ return NULL;
+ }
+
+ if (virMutexInit(&server->lock) < 0) {
+ VIR_ERROR("%s", _("cannot initialize mutex"));
+ VIR_FREE(server);
+ }
+ if (virCondInit(&server->job) < 0) {
+ VIR_ERROR("%s", _("cannot initialize condition variable"));
+ virMutexDestroy(&server->lock);
+ VIR_FREE(server);
+ }
+
+ server->privileged = geteuid() == 0 ? 1 : 0;
+ server->sigread = sigread;
+
+ if (virEventInit() < 0) {
+ VIR_ERROR0(_("Failed to initialize event system"));
+ VIR_FREE(server);
+ return NULL;
+ }
+
+ virInitialize();
+
+ /*
+ * Note that the order is important: the first ones have a higher
+ * priority when calling virStateInitialize. We must register
+ * the network, storage and nodedev drivers before any domain
+ * drivers, since their resources must be auto-started before
+ * any domains can be auto-started.
+ */
+#ifdef WITH_DRIVER_MODULES
+ /* We don't care if any of these fail, because the whole point
+ * is to allow users to only install modules they want to use.
+ * If they try to use a open a connection for a module that
+ * is not loaded they'll get a suitable error at that point
+ */
+ virDriverLoadModule("network");
+ virDriverLoadModule("storage");
+ virDriverLoadModule("nodedev");
+ virDriverLoadModule("secret");
+ virDriverLoadModule("qemu");
+ virDriverLoadModule("lxc");
+ virDriverLoadModule("uml");
+ virDriverLoadModule("one");
+#else
+#ifdef WITH_NETWORK
+ networkRegister();
+#endif
+#ifdef WITH_NETCF
+ interfaceRegister();
+#endif
+#ifdef WITH_STORAGE_DIR
+ storageRegister();
+#endif
+#if defined(WITH_NODE_DEVICES) && \
+ (defined(HAVE_HAL) || defined(HAVE_DEVKIT))
+ nodedevRegister();
+#endif
+ secretRegister();
+#ifdef WITH_QEMU
+ qemuRegister();
+#endif
+#ifdef WITH_LXC
+ lxcRegister();
+#endif
+#ifdef WITH_UML
+ umlRegister();
+#endif
+#ifdef WITH_ONE
+ oneRegister();
+#endif
+#endif
+
+ virEventRegisterImpl(virEventAddHandleImpl,
+ virEventUpdateHandleImpl,
+ virEventRemoveHandleImpl,
+ virEventAddTimeoutImpl,
+ virEventUpdateTimeoutImpl,
+ virEventRemoveTimeoutImpl);
+
+ virStateInitialize(server->privileged);
+
+ return server;
+}
+
+static struct qemud_server *qemudNetworkInit(struct qemud_server *server) {
+ struct qemud_socket *sock;
+ char sockname[PATH_MAX];
+ char roSockname[PATH_MAX];
+#if HAVE_SASL
+ int err;
+#endif /* HAVE_SASL */
+
+ roSockname[0] = '\0';
+
+ if (qemudInitPaths(server, sockname, roSockname, PATH_MAX) < 0)
+ goto cleanup;
+
+ if (qemudListenUnix(server, sockname, 0, auth_unix_rw) < 0)
+ goto cleanup;
+
+ if (roSockname[0] != '\0' && qemudListenUnix(server, roSockname, 1, auth_unix_ro) < 0)
+ goto cleanup;
+
+#if HAVE_SASL
+ if (auth_unix_rw == REMOTE_AUTH_SASL ||
+ auth_unix_ro == REMOTE_AUTH_SASL ||
+ auth_tcp == REMOTE_AUTH_SASL ||
+ auth_tls == REMOTE_AUTH_SASL) {
+ if ((err = sasl_server_init(NULL, "libvirt")) != SASL_OK) {
+ VIR_ERROR(_("Failed to initialize SASL authentication %s"),
+ sasl_errstring(err, NULL, NULL));
+ goto cleanup;
+ }
+ }
+#endif
+
+#if HAVE_POLKIT0
+ if (auth_unix_rw == REMOTE_AUTH_POLKIT ||
+ auth_unix_ro == REMOTE_AUTH_POLKIT) {
+ DBusError derr;
+
+ dbus_connection_set_change_sigpipe(FALSE);
+ dbus_threads_init_default();
+
+ dbus_error_init(&derr);
+ server->sysbus = dbus_bus_get(DBUS_BUS_SYSTEM, &derr);
+ if (!(server->sysbus)) {
+ VIR_ERROR(_("Failed to connect to system bus for PolicyKit auth: %s"),
+ derr.message);
+ dbus_error_free(&derr);
+ goto cleanup;
+ }
+ dbus_connection_set_exit_on_disconnect(server->sysbus, FALSE);
+ }
+#endif
+
+ if (ipsock) {
+ if (listen_tcp && remoteListenTCP (server, listen_addr, tcp_port, QEMUD_SOCK_TYPE_TCP, auth_tcp) < 0)
+ goto cleanup;
+
+ if (listen_tls) {
+ if (remoteInitializeGnuTLS () < 0)
+ goto cleanup;
+
+ if (remoteListenTCP (server, listen_addr, tls_port, QEMUD_SOCK_TYPE_TLS, auth_tls) < 0)
+ goto cleanup;
+ }
+ }
+
+#ifdef HAVE_AVAHI
+ if (server->privileged && mdns_adv) {
+ struct libvirtd_mdns_group *group;
+ int port = 0;
+
+ server->mdns = libvirtd_mdns_new();
+
+ if (!mdns_name) {
+ char groupname[64], localhost[HOST_NAME_MAX+1], *tmp;
+ /* Extract the host part of the potentially FQDN */
+ gethostname(localhost, HOST_NAME_MAX);
+ localhost[HOST_NAME_MAX] = '\0';
+ if ((tmp = strchr(localhost, '.')))
+ *tmp = '\0';
+ snprintf(groupname, sizeof(groupname)-1, "Virtualization Host %s", localhost);
+ groupname[sizeof(groupname)-1] = '\0';
+ group = libvirtd_mdns_add_group(server->mdns, groupname);
+ } else {
+ group = libvirtd_mdns_add_group(server->mdns, mdns_name);
+ }
+
+ /*
+ * See if there's a TLS enabled port we can advertise. Cowardly
+ * don't bother to advertise TCP since we don't want people using
+ * them for real world apps
+ */
+ sock = server->sockets;
+ while (sock) {
+ if (sock->port != -1 && sock->type == QEMUD_SOCK_TYPE_TLS) {
+ port = sock->port;
+ break;
+ }
+ sock = sock->next;
+ }
+
+ /*
+ * Add the primary entry - we choose SSH because its most likely to always
+ * be available
+ */
+ libvirtd_mdns_add_entry(group, "_libvirt._tcp", port);
+ libvirtd_mdns_start(server->mdns);
+ }
+#endif
+
+ return server;
+
+ cleanup:
+ if (server) {
+ sock = server->sockets;
+ while (sock) {
+ close(sock->fd);
+ sock = sock->next;
+ }
+
+#if HAVE_POLKIT0
+ if (server->sysbus)
+ dbus_connection_unref(server->sysbus);
+#endif
+ free(server);
+ }
+ return NULL;
+}
+
+static gnutls_session_t
+remoteInitializeTLSSession (void)
+{
+ gnutls_session_t session;
+ int err;
+
+ err = gnutls_init (&session, GNUTLS_SERVER);
+ if (err != 0) goto failed;
+
+ /* avoid calling all the priority functions, since the defaults
+ * are adequate.
+ */
+ err = gnutls_set_default_priority (session);
+ if (err != 0) goto failed;
+
+ err = gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
+ if (err != 0) goto failed;
+
+ /* request client certificate if any.
+ */
+ gnutls_certificate_server_set_request (session, GNUTLS_CERT_REQUEST);
+
+ gnutls_dh_set_prime_bits (session, DH_BITS);
+
+ return session;
+
+ failed:
+ VIR_ERROR(_("remoteInitializeTLSSession: %s"),
+ gnutls_strerror (err));
+ return NULL;
+}
+
+/* Check DN is on tls_allowed_dn_list. */
+static int
+remoteCheckDN (gnutls_x509_crt_t cert)
+{
+ char name[256];
+ size_t namesize = sizeof name;
+ char **wildcards;
+ int err;
+
+ err = gnutls_x509_crt_get_dn (cert, name, &namesize);
+ if (err != 0) {
+ VIR_ERROR(_("remoteCheckDN: gnutls_x509_cert_get_dn: %s"),
+ gnutls_strerror (err));
+ return 0;
+ }
+
+ /* If the list is not set, allow any DN. */
+ wildcards = tls_allowed_dn_list;
+ if (!wildcards)
+ return 1;
+
+ while (*wildcards) {
+ if (fnmatch (*wildcards, name, 0) == 0)
+ return 1;
+ wildcards++;
+ }
+
+ /* Print the client's DN. */
+ DEBUG(_("remoteCheckDN: failed: client DN is %s"), name);
+
+ return 0; // Not found.
+}
+
+static int
+remoteCheckCertificate (gnutls_session_t session)
+{
+ int ret;
+ unsigned int status;
+ const gnutls_datum_t *certs;
+ unsigned int nCerts, i;
+ time_t now;
+
+ if ((ret = gnutls_certificate_verify_peers2 (session, &status)) < 0){
+ VIR_ERROR(_("remoteCheckCertificate: verify failed: %s"),
+ gnutls_strerror (ret));
+ return -1;
+ }
+
+ if (status != 0) {
+ if (status & GNUTLS_CERT_INVALID)
+ VIR_ERROR0(_("remoteCheckCertificate: "
+ "the client certificate is not trusted."));
+
+ if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
+ VIR_ERROR0(_("remoteCheckCertificate: the client "
+ "certificate has unknown issuer."));
+
+ if (status & GNUTLS_CERT_REVOKED)
+ VIR_ERROR0(_("remoteCheckCertificate: "
+ "the client certificate has been revoked."));
+
+#ifndef GNUTLS_1_0_COMPAT
+ if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
+ VIR_ERROR0(_("remoteCheckCertificate: the client certificate"
+ " uses an insecure algorithm."));
+#endif
+
+ return -1;
+ }
+
+ if (gnutls_certificate_type_get (session) != GNUTLS_CRT_X509) {
+ VIR_ERROR0(_("remoteCheckCertificate: certificate is not X.509"));
+ return -1;
+ }
+
+ if (!(certs = gnutls_certificate_get_peers(session, &nCerts))) {
+ VIR_ERROR0(_("remoteCheckCertificate: no peers"));
+ return -1;
+ }
+
+ now = time (NULL);
+
+ for (i = 0; i < nCerts; i++) {
+ gnutls_x509_crt_t cert;
+
+ if (gnutls_x509_crt_init (&cert) < 0) {
+ VIR_ERROR0(_("remoteCheckCertificate: gnutls_x509_crt_init failed"));
+ return -1;
+ }
+
+ if (gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER) < 0) {
+ gnutls_x509_crt_deinit (cert);
+ return -1;
+ }
+
+ if (gnutls_x509_crt_get_expiration_time (cert) < now) {
+ VIR_ERROR0(_("remoteCheckCertificate: "
+ "the client certificate has expired"));
+ gnutls_x509_crt_deinit (cert);
+ return -1;
+ }
+
+ if (gnutls_x509_crt_get_activation_time (cert) > now) {
+ VIR_ERROR0(_("remoteCheckCertificate: the client "
+ "certificate is not yet activated"));
+ gnutls_x509_crt_deinit (cert);
+ return -1;
+ }
+
+ if (i == 0) {
+ if (!remoteCheckDN (cert)) {
+ /* This is the most common error: make it informative. */
+ VIR_ERROR0(_("remoteCheckCertificate: client's Distinguished Name is not on the list of allowed clients (tls_allowed_dn_list). Use 'openssl x509 -in clientcert.pem -text' to view the Distinguished Name field in the client certificate, or run this daemon with --verbose option."));
+ gnutls_x509_crt_deinit (cert);
+ return -1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* Check the client's access. */
+static int
+remoteCheckAccess (struct qemud_client *client)
+{
+ struct qemud_client_message *confirm;
+
+ /* Verify client certificate. */
+ if (remoteCheckCertificate (client->tlssession) == -1) {
+ VIR_ERROR0(_("remoteCheckCertificate: "
+ "failed to verify client's certificate"));
+ if (!tls_no_verify_certificate) return -1;
+ else VIR_INFO0(_("remoteCheckCertificate: tls_no_verify_certificate "
+ "is set so the bad certificate is ignored"));
+ }
+
+ if (client->tx) {
+ VIR_INFO("%s",
+ _("client had unexpected data pending tx after access check"));
+ return -1;
+ }
+
+ if (VIR_ALLOC(confirm) < 0)
+ return -1;
+
+ /* Checks have succeeded. Write a '\1' byte back to the client to
+ * indicate this (otherwise the socket is abruptly closed).
+ * (NB. The '\1' byte is sent in an encrypted record).
+ */
+ confirm->async = 1;
+ confirm->bufferLength = 1;
+ confirm->bufferOffset = 0;
+ confirm->buffer[0] = '\1';
+
+ client->tx = confirm;
+ return 0;
+}
+
+#if HAVE_POLKIT
+int qemudGetSocketIdentity(int fd, uid_t *uid, pid_t *pid) {
+#ifdef SO_PEERCRED
+ struct ucred cr;
+ unsigned int cr_len = sizeof (cr);
+
+ if (getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) < 0) {
+ char ebuf[1024];
+ VIR_ERROR(_("Failed to verify client credentials: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ *pid = cr.pid;
+ *uid = cr.uid;
+#else
+ /* XXX Many more OS support UNIX socket credentials we could port to. See dbus ....*/
+#error "UNIX socket credentials not supported/implemented on this platform yet..."
+#endif
+ return 0;
+}
+#endif
+
+
+static int qemudDispatchServer(struct qemud_server *server, struct qemud_socket *sock) {
+ int fd;
+ struct sockaddr_storage addr;
+ socklen_t addrlen = (socklen_t) (sizeof addr);
+ struct qemud_client *client;
+ int no_slow_start = 1;
+
+ if ((fd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen)) < 0) {
+ char ebuf[1024];
+ if (errno == EAGAIN)
+ return 0;
+ VIR_ERROR(_("Failed to accept connection: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ if (server->nclients >= max_clients) {
+ VIR_ERROR(_("Too many active clients (%d), dropping connection"), max_clients);
+ close(fd);
+ return -1;
+ }
+
+ if (VIR_REALLOC_N(server->clients, server->nclients+1) < 0) {
+ VIR_ERROR0(_("Out of memory allocating clients"));
+ close(fd);
+ return -1;
+ }
+
+#ifdef __sun
+ {
+ ucred_t *ucred = NULL;
+ const priv_set_t *privs;
+
+ if (getpeerucred (fd, &ucred) == -1 ||
+ (privs = ucred_getprivset (ucred, PRIV_EFFECTIVE)) == NULL) {
+ if (ucred != NULL)
+ ucred_free (ucred);
+ close (fd);
+ return -1;
+ }
+
+ if (!priv_ismember (privs, PRIV_VIRT_MANAGE)) {
+ ucred_free (ucred);
+ close (fd);
+ return -1;
+ }
+
+ ucred_free (ucred);
+ }
+#endif /* __sun */
+
+ /* Disable Nagle. Unix sockets will ignore this. */
+ setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&no_slow_start,
+ sizeof no_slow_start);
+
+ if (virSetCloseExec(fd) < 0 ||
+ virSetNonBlock(fd) < 0) {
+ close(fd);
+ return -1;
+ }
+
+ if (VIR_ALLOC(client) < 0)
+ goto cleanup;
+ if (virMutexInit(&client->lock) < 0) {
+ VIR_ERROR("%s", _("cannot initialize mutex"));
+ VIR_FREE(client);
+ goto cleanup;
+ }
+
+ client->magic = QEMUD_CLIENT_MAGIC;
+ client->fd = fd;
+ client->readonly = sock->readonly;
+ client->type = sock->type;
+ client->auth = sock->auth;
+ memcpy (&client->addr, &addr, sizeof addr);
+ client->addrlen = addrlen;
+
+ /* Prepare one for packet receive */
+ if (VIR_ALLOC(client->rx) < 0)
+ goto cleanup;
+ client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
+
+
+#if HAVE_POLKIT
+ /* Only do policy checks for non-root - allow root user
+ through with no checks, as a fail-safe - root can easily
+ change policykit policy anyway, so its pointless trying
+ to restrict root */
+ if (client->auth == REMOTE_AUTH_POLKIT) {
+ uid_t uid;
+ pid_t pid;
+
+ if (qemudGetSocketIdentity(client->fd, &uid, &pid) < 0)
+ goto cleanup;
+
+ /* Client is running as root, so disable auth */
+ if (uid == 0) {
+ VIR_INFO(_("Turn off polkit auth for privileged client %d"), pid);
+ client->auth = REMOTE_AUTH_NONE;
+ }
+ }
+#endif
+
+ if (client->type != QEMUD_SOCK_TYPE_TLS) {
+ /* Plain socket, so prepare to read first message */
+ if (qemudRegisterClientEvent (server, client) < 0)
+ goto cleanup;
+ } else {
+ int ret;
+
+ client->tlssession = remoteInitializeTLSSession ();
+ if (client->tlssession == NULL)
+ goto cleanup;
+
+ gnutls_transport_set_ptr (client->tlssession,
+ (gnutls_transport_ptr_t) (long) fd);
+
+ /* Begin the TLS handshake. */
+ ret = gnutls_handshake (client->tlssession);
+ if (ret == 0) {
+ client->handshake = 0;
+
+ /* Unlikely, but ... Next step is to check the certificate. */
+ if (remoteCheckAccess (client) == -1)
+ goto cleanup;
+
+ /* Handshake & cert check OK, so prepare to read first message */
+ if (qemudRegisterClientEvent(server, client) < 0)
+ goto cleanup;
+ } else if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
+ /* Most likely, need to do more handshake data */
+ client->handshake = 1;
+
+ if (qemudRegisterClientEvent (server, client) < 0)
+ goto cleanup;
+ } else {
+ VIR_ERROR(_("TLS handshake failed: %s"),
+ gnutls_strerror (ret));
+ goto cleanup;
+ }
+ }
+
+ server->clients[server->nclients++] = client;
+
+ if (server->nclients > server->nactiveworkers &&
+ server->nactiveworkers < server->nworkers) {
+ int i;
+ for (i = 0 ; i < server->nworkers ; i++) {
+ if (!server->workers[i].hasThread) {
+ if (qemudStartWorker(server, &server->workers[i]) < 0)
+ return -1;
+ server->nactiveworkers++;
+ break;
+ }
+ }
+ }
+
+
+ return 0;
+
+ cleanup:
+ if (client &&
+ client->tlssession) gnutls_deinit (client->tlssession);
+ close (fd);
+ VIR_FREE(client->rx);
+ VIR_FREE(client);
+ return -1;
+}
+
+
+/*
+ * You must hold lock for at least the client
+ * We don't free stuff here, merely disconnect the client's
+ * network socket & resources.
+ * We keep the libvirt connection open until any async
+ * jobs have finished, then clean it up elsehwere
+ */
+void qemudDispatchClientFailure(struct qemud_client *client) {
+ if (client->watch != -1) {
+ virEventRemoveHandleImpl(client->watch);
+ client->watch = -1;
+ }
+
+ /* Deregister event delivery callback */
+ if(client->conn) {
+ DEBUG0("Deregistering to relay remote events");
+ virConnectDomainEventDeregister(client->conn, remoteRelayDomainEvent);
+ }
+
+#if HAVE_SASL
+ if (client->saslconn) {
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ }
+ free(client->saslUsername);
+ client->saslUsername = NULL;
+#endif
+ if (client->tlssession) {
+ gnutls_deinit (client->tlssession);
+ client->tlssession = NULL;
+ }
+ if (client->fd != -1) {
+ close(client->fd);
+ client->fd = -1;
+ }
+}
+
+
+/* Caller must hold server lock */
+static struct qemud_client *qemudPendingJob(struct qemud_server *server)
+{
+ int i;
+ for (i = 0 ; i < server->nclients ; i++) {
+ virMutexLock(&server->clients[i]->lock);
+ if (server->clients[i]->dx) {
+ /* Delibrately don't unlock client - caller wants the lock */
+ return server->clients[i];
+ }
+ virMutexUnlock(&server->clients[i]->lock);
+ }
+ return NULL;
+}
+
+static void *qemudWorker(void *data)
+{
+ struct qemud_worker *worker = data;
+ struct qemud_server *server = worker->server;
+
+ while (1) {
+ struct qemud_client *client = NULL;
+ struct qemud_client_message *msg;
+
+ virMutexLock(&server->lock);
+ while (((client = qemudPendingJob(server)) == NULL) &&
+ !worker->quitRequest) {
+ if (virCondWait(&server->job, &server->lock) < 0) {
+ virMutexUnlock(&server->lock);
+ return NULL;
+ }
+ }
+ if (worker->quitRequest) {
+ if (client)
+ virMutexUnlock(&client->lock);
+ virMutexUnlock(&server->lock);
+ return NULL;
+ }
+ worker->processingCall = 1;
+ virMutexUnlock(&server->lock);
+
+ /* We own a locked client now... */
+ client->refs++;
+
+ /* Remove our message from dispatch queue while we use it */
+ msg = qemudClientMessageQueueServe(&client->dx);
+
+ /* This function drops the lock during dispatch,
+ * and re-acquires it before returning */
+ if (remoteDispatchClientRequest (server, client, msg) < 0) {
+ VIR_FREE(msg);
+ qemudDispatchClientFailure(client);
+ client->refs--;
+ virMutexUnlock(&client->lock);
+ continue;
+ }
+
+ client->refs--;
+ virMutexUnlock(&client->lock);
+
+ virMutexLock(&server->lock);
+ worker->processingCall = 0;
+ virMutexUnlock(&server->lock);
+ }
+}
+
+static int qemudStartWorker(struct qemud_server *server,
+ struct qemud_worker *worker) {
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
+ /* We want to join workers, so don't detach them */
+ /*pthread_attr_setdetachstate(&attr, 1);*/
+
+ if (worker->hasThread)
+ return -1;
+
+ worker->server = server;
+ worker->hasThread = 1;
+ worker->quitRequest = 0;
+ worker->processingCall = 0;
+
+ if (pthread_create(&worker->thread,
+ &attr,
+ qemudWorker,
+ worker) != 0) {
+ worker->hasThread = 0;
+ worker->server = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/*
+ * Read data into buffer using wire decoding (plain or TLS)
+ *
+ * Returns:
+ * -1 on error or EOF
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static ssize_t qemudClientReadBuf(struct qemud_client *client,
+ char *data, ssize_t len) {
+ ssize_t ret;
+
+ if (len < 0) {
+ VIR_ERROR(_("unexpected negative length request %lld"),
+ (long long int) len);
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+
+ /*qemudDebug ("qemudClientRead: len = %d", len);*/
+
+ if (!client->tlssession) {
+ char ebuf[1024];
+ ret = read (client->fd, data, len);
+ if (ret == -1 && (errno == EAGAIN ||
+ errno == EINTR))
+ return 0;
+ if (ret <= 0) {
+ if (ret != 0)
+ VIR_ERROR(_("read: %s"),
+ virStrerror (errno, ebuf, sizeof ebuf));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+ } else {
+ ret = gnutls_record_recv (client->tlssession, data, len);
+
+ if (ret < 0 && (ret == GNUTLS_E_AGAIN ||
+ ret == GNUTLS_E_INTERRUPTED))
+ return 0;
+ if (ret <= 0) {
+ if (ret != 0)
+ VIR_ERROR(_("gnutls_record_recv: %s"),
+ gnutls_strerror (ret));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Read data into buffer without decoding
+ *
+ * Returns:
+ * -1 on error or EOF
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static ssize_t qemudClientReadPlain(struct qemud_client *client) {
+ ssize_t ret;
+ ret = qemudClientReadBuf(client,
+ client->rx->buffer + client->rx->bufferOffset,
+ client->rx->bufferLength - client->rx->bufferOffset);
+ if (ret <= 0)
+ return ret; /* -1 error, 0 eagain */
+
+ client->rx->bufferOffset += ret;
+ return ret;
+}
+
+#if HAVE_SASL
+/*
+ * Read data into buffer decoding with SASL
+ *
+ * Returns:
+ * -1 on error or EOF
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static ssize_t qemudClientReadSASL(struct qemud_client *client) {
+ ssize_t got, want;
+
+ /* We're doing a SSF data read, so now its times to ensure
+ * future writes are under SSF too.
+ *
+ * cf remoteSASLCheckSSF in remote.c
+ */
+ client->saslSSF |= QEMUD_SASL_SSF_WRITE;
+
+ /* Need to read some more data off the wire */
+ if (client->saslDecoded == NULL) {
+ int ret;
+ char encoded[8192];
+ ssize_t encodedLen = sizeof(encoded);
+ encodedLen = qemudClientReadBuf(client, encoded, encodedLen);
+
+ if (encodedLen <= 0)
+ return encodedLen;
+
+ ret = sasl_decode(client->saslconn, encoded, encodedLen,
+ &client->saslDecoded, &client->saslDecodedLength);
+ if (ret != SASL_OK) {
+ VIR_ERROR(_("failed to decode SASL data %s"),
+ sasl_errstring(ret, NULL, NULL));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+
+ client->saslDecodedOffset = 0;
+ }
+
+ /* Some buffered decoded data to return now */
+ got = client->saslDecodedLength - client->saslDecodedOffset;
+ want = client->rx->bufferLength - client->rx->bufferOffset;
+
+ if (want > got)
+ want = got;
+
+ memcpy(client->rx->buffer + client->rx->bufferOffset,
+ client->saslDecoded + client->saslDecodedOffset, want);
+ client->saslDecodedOffset += want;
+ client->rx->bufferOffset += want;
+
+ if (client->saslDecodedOffset == client->saslDecodedLength) {
+ client->saslDecoded = NULL;
+ client->saslDecodedOffset = client->saslDecodedLength = 0;
+ }
+
+ return want;
+}
+#endif
+
+/*
+ * Read as much data off wire as possible till we fill our
+ * buffer, or would block on I/O
+ */
+static ssize_t qemudClientRead(struct qemud_client *client) {
+#if HAVE_SASL
+ if (client->saslSSF & QEMUD_SASL_SSF_READ)
+ return qemudClientReadSASL(client);
+ else
+#endif
+ return qemudClientReadPlain(client);
+}
+
+
+/*
+ * Read data until we get a complete message to process
+ */
+static void qemudDispatchClientRead(struct qemud_server *server,
+ struct qemud_client *client) {
+ /*qemudDebug ("qemudDispatchClientRead: mode = %d", client->mode);*/
+
+readmore:
+ if (qemudClientRead(client) < 0)
+ return; /* Error */
+
+ if (client->rx->bufferOffset < client->rx->bufferLength)
+ return; /* Still not read enough */
+
+ /* Either done with length word header */
+ if (client->rx->bufferLength == REMOTE_MESSAGE_HEADER_XDR_LEN) {
+ unsigned int len;
+ XDR x;
+
+ xdrmem_create(&x, client->rx->buffer, client->rx->bufferLength, XDR_DECODE);
+
+ if (!xdr_u_int(&x, &len)) {
+ xdr_destroy (&x);
+ DEBUG0("Failed to decode packet length");
+ qemudDispatchClientFailure(client);
+ return;
+ }
+ xdr_destroy (&x);
+
+ if (len < REMOTE_MESSAGE_HEADER_XDR_LEN) {
+ DEBUG("Packet length %u too small", len);
+ qemudDispatchClientFailure(client);
+ return;
+ }
+
+ /* Length includes the size of the length word itself */
+ len -= REMOTE_MESSAGE_HEADER_XDR_LEN;
+
+ if (len > REMOTE_MESSAGE_MAX) {
+ DEBUG("Packet length %u too large", len);
+ qemudDispatchClientFailure(client);
+ return;
+ }
+
+ /* Prepare to read rest of message */
+ client->rx->bufferLength += len;
+
+ qemudUpdateClientEvent(client);
+
+ /* Try and read payload immediately instead of going back
+ into poll() because chances are the data is already
+ waiting for us */
+ goto readmore;
+ } else {
+ /* Grab the completed message */
+ struct qemud_client_message *msg = qemudClientMessageQueueServe(&client->rx);
+ struct qemud_client_filter *filter;
+
+ /* Decode the header so we can use it for routing decisions */
+ if (remoteDecodeClientMessageHeader(msg) < 0) {
+ VIR_FREE(msg);
+ qemudDispatchClientFailure(client);
+ }
+
+ /* Check if any filters match this message */
+ filter = client->filters;
+ while (filter) {
+ if ((filter->query)(msg, filter->opaque)) {
+ qemudClientMessageQueuePush(&filter->dx, msg);
+ msg = NULL;
+ break;
+ }
+ filter = filter->next;
+ }
+
+ /* Move completed message to the end of the dispatch queue */
+ if (msg)
+ qemudClientMessageQueuePush(&client->dx, msg);
+ client->nrequests++;
+
+ /* Possibly need to create another receive buffer */
+ if ((client->nrequests < max_client_requests &&
+ VIR_ALLOC(client->rx) < 0)) {
+ qemudDispatchClientFailure(client);
+ } else {
+ if (client->rx)
+ client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
+
+ qemudUpdateClientEvent(client);
+
+ /* Tell one of the workers to get on with it... */
+ virCondSignal(&server->job);
+ }
+ }
+}
+
+
+/*
+ * Send a chunk of data using wire encoding (plain or TLS)
+ *
+ * Returns:
+ * -1 on error
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static ssize_t qemudClientWriteBuf(struct qemud_client *client,
+ const char *data, ssize_t len) {
+ ssize_t ret;
+
+ if (len < 0) {
+ VIR_ERROR(_("unexpected negative length request %lld"),
+ (long long int) len);
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+
+ if (!client->tlssession) {
+ char ebuf[1024];
+ if ((ret = write(client->fd, data, len)) == -1) {
+ if (errno == EAGAIN || errno == EINTR)
+ return 0;
+ VIR_ERROR(_("write: %s"), virStrerror (errno, ebuf, sizeof ebuf));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+ } else {
+ ret = gnutls_record_send (client->tlssession, data, len);
+ if (ret < 0) {
+ if (ret == GNUTLS_E_INTERRUPTED ||
+ ret == GNUTLS_E_AGAIN)
+ return 0;
+
+ VIR_ERROR(_("gnutls_record_send: %s"), gnutls_strerror (ret));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+ }
+ return ret;
+}
+
+
+/*
+ * Send client->tx using no encoding
+ *
+ * Returns:
+ * -1 on error or EOF
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static int qemudClientWritePlain(struct qemud_client *client) {
+ int ret = qemudClientWriteBuf(client,
+ client->tx->buffer + client->tx->bufferOffset,
+ client->tx->bufferLength - client->tx->bufferOffset);
+ if (ret <= 0)
+ return ret; /* -1 error, 0 = egain */
+ client->tx->bufferOffset += ret;
+ return ret;
+}
+
+
+#if HAVE_SASL
+/*
+ * Send client->tx using SASL encoding
+ *
+ * Returns:
+ * -1 on error
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static int qemudClientWriteSASL(struct qemud_client *client) {
+ int ret;
+
+ /* Not got any pending encoded data, so we need to encode raw stuff */
+ if (client->saslEncoded == NULL) {
+ ret = sasl_encode(client->saslconn,
+ client->tx->buffer + client->tx->bufferOffset,
+ client->tx->bufferLength - client->tx->bufferOffset,
+ &client->saslEncoded,
+ &client->saslEncodedLength);
+
+ if (ret != SASL_OK) {
+ VIR_ERROR(_("failed to encode SASL data %s"),
+ sasl_errstring(ret, NULL, NULL));
+ qemudDispatchClientFailure(client);
+ return -1;
+ }
+
+ client->saslEncodedOffset = 0;
+ }
+
+ /* Send some of the encoded stuff out on the wire */
+ ret = qemudClientWriteBuf(client,
+ client->saslEncoded + client->saslEncodedOffset,
+ client->saslEncodedLength - client->saslEncodedOffset);
+
+ if (ret <= 0)
+ return ret; /* -1 error, 0 == egain */
+
+ /* Note how much we sent */
+ client->saslEncodedOffset += ret;
+
+ /* Sent all encoded, so update raw buffer to indicate completion */
+ if (client->saslEncodedOffset == client->saslEncodedLength) {
+ client->saslEncoded = NULL;
+ client->saslEncodedOffset = client->saslEncodedLength = 0;
+
+ /* Mark as complete, so caller detects completion */
+ client->tx->bufferOffset = client->tx->bufferLength;
+ }
+
+ return ret;
+}
+#endif
+
+/*
+ * Send as much data in the client->tx as possible
+ *
+ * Returns:
+ * -1 on error or EOF
+ * 0 on EAGAIN
+ * n number of bytes
+ */
+static ssize_t qemudClientWrite(struct qemud_client *client) {
+#if HAVE_SASL
+ if (client->saslSSF & QEMUD_SASL_SSF_WRITE)
+ return qemudClientWriteSASL(client);
+ else
+#endif
+ return qemudClientWritePlain(client);
+}
+
+
+/*
+ * Process all queued client->tx messages until
+ * we would block on I/O
+ */
+static void
+qemudDispatchClientWrite(struct qemud_client *client) {
+ while (client->tx) {
+ ssize_t ret;
+
+ ret = qemudClientWrite(client);
+ if (ret < 0) {
+ qemudDispatchClientFailure(client);
+ return;
+ }
+ if (ret == 0)
+ return; /* Would block on write EAGAIN */
+
+ if (client->tx->bufferOffset == client->tx->bufferLength) {
+ struct qemud_client_message *reply;
+
+ /* Get finished reply from head of tx queue */
+ reply = qemudClientMessageQueueServe(&client->tx);
+
+ /* If its not an async message, then we have
+ * just completed an RPC request */
+ if (!reply->async)
+ client->nrequests--;
+
+ /* Move record to end of 'rx' ist */
+ if (!client->rx &&
+ client->nrequests < max_client_requests) {
+ /* Reset message record for next RX attempt */
+ client->rx = reply;
+ client->rx->bufferOffset = 0;
+ client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
+ } else {
+ VIR_FREE(reply);
+ }
+
+ if (client->closing)
+ qemudDispatchClientFailure(client);
+ else
+ qemudUpdateClientEvent(client);
+ }
+ }
+}
+
+static void
+qemudDispatchClientHandshake(struct qemud_client *client) {
+ int ret;
+ /* Continue the handshake. */
+ ret = gnutls_handshake (client->tlssession);
+ if (ret == 0) {
+ client->handshake = 0;
+
+ /* Finished. Next step is to check the certificate. */
+ if (remoteCheckAccess (client) == -1)
+ qemudDispatchClientFailure(client);
+ else
+ qemudUpdateClientEvent(client);
+ } else if (ret == GNUTLS_E_AGAIN ||
+ ret == GNUTLS_E_INTERRUPTED) {
+ /* Carry on waiting for more handshake. Update
+ the events just in case handshake data flow
+ direction has changed */
+ qemudUpdateClientEvent (client);
+ } else {
+ /* Fatal error in handshake */
+ VIR_ERROR(_("TLS handshake failed: %s"),
+ gnutls_strerror (ret));
+ qemudDispatchClientFailure(client);
+ }
+}
+
+static void
+qemudDispatchClientEvent(int watch, int fd, int events, void *opaque) {
+ struct qemud_server *server = (struct qemud_server *)opaque;
+ struct qemud_client *client = NULL;
+ int i;
+
+ virMutexLock(&server->lock);
+
+ for (i = 0 ; i < server->nclients ; i++) {
+ virMutexLock(&server->clients[i]->lock);
+ if (server->clients[i]->watch == watch) {
+ client = server->clients[i];
+ break;
+ }
+ virMutexUnlock(&server->clients[i]->lock);
+ }
+
+ virMutexUnlock(&server->lock);
+
+ if (!client) {
+ return;
+ }
+
+ if (client->fd != fd) {
+ virMutexUnlock(&client->lock);
+ return;
+ }
+
+ if (events & (VIR_EVENT_HANDLE_WRITABLE |
+ VIR_EVENT_HANDLE_READABLE)) {
+ if (client->handshake) {
+ qemudDispatchClientHandshake(client);
+ } else {
+ if (events & VIR_EVENT_HANDLE_WRITABLE)
+ qemudDispatchClientWrite(client);
+ if (events & VIR_EVENT_HANDLE_READABLE)
+ qemudDispatchClientRead(server, client);
+ }
+ }
+
+ /* NB, will get HANGUP + READABLE at same time upon
+ * disconnect */
+ if (events & (VIR_EVENT_HANDLE_ERROR |
+ VIR_EVENT_HANDLE_HANGUP))
+ qemudDispatchClientFailure(client);
+
+ virMutexUnlock(&client->lock);
+}
+
+
+/*
+ * @client: a locked client object
+ */
+static int
+qemudCalculateHandleMode(struct qemud_client *client) {
+ int mode = 0;
+
+ if (client->handshake) {
+ if (gnutls_record_get_direction (client->tlssession) == 0)
+ mode |= VIR_EVENT_HANDLE_READABLE;
+ else
+ mode |= VIR_EVENT_HANDLE_WRITABLE;
+ } else {
+ /* If there is a message on the rx queue then
+ * we're wanting more input */
+ if (client->rx)
+ mode |= VIR_EVENT_HANDLE_READABLE;
+
+ /* If there are one or more messages to send back to client,
+ then monitor for writability on socket */
+ if (client->tx)
+ mode |= VIR_EVENT_HANDLE_WRITABLE;
+ }
+
+ return mode;
+}
+
+/*
+ * @server: a locked or unlocked server object
+ * @client: a locked client object
+ */
+int qemudRegisterClientEvent(struct qemud_server *server,
+ struct qemud_client *client) {
+ int mode;
+
+ mode = qemudCalculateHandleMode(client);
+
+ if ((client->watch = virEventAddHandleImpl(client->fd,
+ mode,
+ qemudDispatchClientEvent,
+ server, NULL)) < 0)
+ return -1;
+
+ return 0;
+}
+
+/*
+ * @client: a locked client object
+ */
+void qemudUpdateClientEvent(struct qemud_client *client) {
+ int mode;
+
+ mode = qemudCalculateHandleMode(client);
+
+ virEventUpdateHandleImpl(client->watch, mode);
+}
+
+
+static void
+qemudDispatchServerEvent(int watch, int fd, int events, void *opaque) {
+ struct qemud_server *server = (struct qemud_server *)opaque;
+ struct qemud_socket *sock;
+
+ virMutexLock(&server->lock);
+
+ sock = server->sockets;
+
+ while (sock) {
+ if (sock->watch == watch)
+ break;
+
+ sock = sock->next;
+ }
+
+ if (sock && sock->fd == fd && events)
+ qemudDispatchServer(server, sock);
+
+ virMutexUnlock(&server->lock);
+}
+
+
+static int qemudOneLoop(void) {
+ sig_atomic_t errors;
+
+ if (virEventRunOnce() < 0)
+ return -1;
+
+ /* Check for any signal handling errors and log them. */
+ errors = sig_errors;
+ if (errors) {
+ char ebuf[1024];
+ sig_errors -= errors;
+ VIR_ERROR(_("Signal handler reported %d errors: last error: %s"),
+ errors, virStrerror (sig_lasterrno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ return 0;
+}
+
+static void qemudInactiveTimer(int timerid, void *data) {
+ struct qemud_server *server = (struct qemud_server *)data;
+
+ if (virStateActive() ||
+ server->clients) {
+ DEBUG0("Timer expired but still active, not shutting down");
+ virEventUpdateTimeoutImpl(timerid, -1);
+ } else {
+ DEBUG0("Timer expired and inactive, shutting down");
+ server->shutdown = 1;
+ }
+}
+
+static void qemudFreeClient(struct qemud_client *client) {
+ while (client->rx) {
+ struct qemud_client_message *msg
+ = qemudClientMessageQueueServe(&client->rx);
+ VIR_FREE(msg);
+ }
+ while (client->dx) {
+ struct qemud_client_message *msg
+ = qemudClientMessageQueueServe(&client->dx);
+ VIR_FREE(msg);
+ }
+ while (client->tx) {
+ struct qemud_client_message *msg
+ = qemudClientMessageQueueServe(&client->tx);
+ VIR_FREE(msg);
+ }
+
+ if (client->conn)
+ virConnectClose(client->conn);
+ virMutexDestroy(&client->lock);
+ VIR_FREE(client);
+}
+
+static int qemudRunLoop(struct qemud_server *server) {
+ int timerid = -1;
+ int ret = -1, i;
+ int timerActive = 0;
+
+ virMutexLock(&server->lock);
+
+ if (timeout > 0 &&
+ (timerid = virEventAddTimeoutImpl(-1,
+ qemudInactiveTimer,
+ server, NULL)) < 0) {
+ VIR_ERROR0(_("Failed to register shutdown timeout"));
+ return -1;
+ }
+
+ if (min_workers > max_workers)
+ max_workers = min_workers;
+
+ server->nworkers = max_workers;
+ if (VIR_ALLOC_N(server->workers, server->nworkers) < 0) {
+ VIR_ERROR0(_("Failed to allocate workers"));
+ return -1;
+ }
+
+ for (i = 0 ; i < min_workers ; i++) {
+ if (qemudStartWorker(server, &server->workers[i]) < 0)
+ goto cleanup;
+ server->nactiveworkers++;
+ }
+
+ for (;;) {
+ /* A shutdown timeout is specified, so check
+ * if any drivers have active state, if not
+ * shutdown after timeout seconds
+ */
+ if (timeout > 0) {
+ if (timerActive) {
+ if (server->clients) {
+ DEBUG("Deactivating shutdown timer %d", timerid);
+ virEventUpdateTimeoutImpl(timerid, -1);
+ timerActive = 0;
+ }
+ } else {
+ if (!virStateActive() &&
+ !server->clients) {
+ DEBUG("Activating shutdown timer %d", timerid);
+ virEventUpdateTimeoutImpl(timerid, timeout * 1000);
+ timerActive = 1;
+ }
+ }
+ }
+
+ virMutexUnlock(&server->lock);
+ if (qemudOneLoop() < 0) {
+ virMutexLock(&server->lock);
+ DEBUG0("Loop iteration error, exiting\n");
+ break;
+ }
+ virMutexLock(&server->lock);
+
+ reprocess:
+ for (i = 0 ; i < server->nclients ; i++) {
+ int inactive;
+ virMutexLock(&server->clients[i]->lock);
+ inactive = server->clients[i]->fd == -1
+ && server->clients[i]->refs == 0;
+ virMutexUnlock(&server->clients[i]->lock);
+ if (inactive) {
+ qemudFreeClient(server->clients[i]);
+ server->nclients--;
+ if (i < server->nclients)
+ memmove(server->clients + i,
+ server->clients + i + 1,
+ sizeof (*server->clients) * (server->nclients - i));
+
+ if (VIR_REALLOC_N(server->clients,
+ server->nclients) < 0) {
+ ; /* ignore */
+ }
+ goto reprocess;
+ }
+ }
+
+ /* If number of active workers exceeds both the min_workers
+ * threshold and the number of clients, then kill some
+ * off */
+ for (i = 0 ; (i < server->nworkers &&
+ server->nactiveworkers > server->nclients &&
+ server->nactiveworkers > min_workers) ; i++) {
+
+ if (server->workers[i].hasThread &&
+ !server->workers[i].processingCall) {
+ server->workers[i].quitRequest = 1;
+
+ virCondBroadcast(&server->job);
+ virMutexUnlock(&server->lock);
+ pthread_join(server->workers[i].thread, NULL);
+ virMutexLock(&server->lock);
+ server->workers[i].hasThread = 0;
+ server->nactiveworkers--;
+ }
+ }
+
+ if (server->shutdown) {
+ ret = 0;
+ break;
+ }
+ }
+
+cleanup:
+ for (i = 0 ; i < server->nworkers ; i++) {
+ if (!server->workers[i].hasThread)
+ continue;
+
+ server->workers[i].quitRequest = 1;
+ virCondBroadcast(&server->job);
+
+ virMutexUnlock(&server->lock);
+ pthread_join(server->workers[i].thread, NULL);
+ virMutexLock(&server->lock);
+ server->workers[i].hasThread = 0;
+ }
+ VIR_FREE(server->workers);
+
+ free(server->workers);
+ virMutexUnlock(&server->lock);
+ return ret;
+}
+
+static void qemudCleanup(struct qemud_server *server) {
+ struct qemud_socket *sock;
+
+ close(server->sigread);
+
+ sock = server->sockets;
+ while (sock) {
+ struct qemud_socket *next = sock->next;
+ close(sock->fd);
+ free(sock);
+ sock = next;
+ }
+ free(server->logDir);
+
+#ifdef HAVE_SASL
+ if (server->saslUsernameWhitelist) {
+ char **list = server->saslUsernameWhitelist;
+ while (*list) {
+ free(*list);
+ list++;
+ }
+ free(server->saslUsernameWhitelist);
+ }
+#endif
+
+ virStateCleanup();
+
+ if (virCondDestroy(&server->job) < 0) {
+ ;
+ }
+ virMutexDestroy(&server->lock);
+
+ VIR_FREE(server);
+}
+
+/* Allocate an array of malloc'd strings from the config file, filename
+ * (used only in diagnostics), using handle "conf". Upon error, return -1
+ * and free any allocated memory. Otherwise, save the array in *list_arg
+ * and return 0.
+ */
+static int
+remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
+ const char *filename)
+{
+ char **list;
+ virConfValuePtr p = virConfGetValue (conf, key);
+ if (!p)
+ return 0;
+
+ switch (p->type) {
+ case VIR_CONF_STRING:
+ if (VIR_ALLOC_N(list, 2) < 0) {
+ VIR_ERROR(_("failed to allocate memory for %s config list"), key);
+ return -1;
+ }
+ list[0] = strdup (p->str);
+ list[1] = NULL;
+ if (list[0] == NULL) {
+ VIR_ERROR(_("failed to allocate memory for %s config list value"),
+ key);
+ VIR_FREE(list);
+ return -1;
+ }
+ break;
+
+ case VIR_CONF_LIST: {
+ int i, len = 0;
+ virConfValuePtr pp;
+ for (pp = p->list; pp; pp = pp->next)
+ len++;
+ if (VIR_ALLOC_N(list, 1+len) < 0) {
+ VIR_ERROR(_("failed to allocate memory for %s config list"), key);
+ return -1;
+ }
+ for (i = 0, pp = p->list; pp; ++i, pp = pp->next) {
+ if (pp->type != VIR_CONF_STRING) {
+ VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
+ " must be a string or list of strings\n"),
+ filename, key);
+ VIR_FREE(list);
+ return -1;
+ }
+ list[i] = strdup (pp->str);
+ if (list[i] == NULL) {
+ int j;
+ for (j = 0 ; j < i ; j++)
+ VIR_FREE(list[j]);
+ VIR_FREE(list);
+ VIR_ERROR(_("failed to allocate memory for %s config list value"),
+ key);
+ return -1;
+ }
+
+ }
+ list[i] = NULL;
+ break;
+ }
+
+ default:
+ VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
+ " must be a string or list of strings\n"),
+ filename, key);
+ return -1;
+ }
+
+ *list_arg = list;
+ return 0;
+}
+
+/* A helper function used by each of the following macros. */
+static int
+checkType (virConfValuePtr p, const char *filename,
+ const char *key, virConfType required_type)
+{
+ if (p->type != required_type) {
+ VIR_ERROR(_("remoteReadConfigFile: %s: %s: invalid type:"
+ " got %s; expected %s\n"), filename, key,
+ virConfTypeName (p->type),
+ virConfTypeName (required_type));
+ return -1;
+ }
+ return 0;
+}
+
+/* If there is no config data for the key, #var_name, then do nothing.
+ If there is valid data of type VIR_CONF_STRING, and strdup succeeds,
+ store the result in var_name. Otherwise, (i.e. invalid type, or strdup
+ failure), give a diagnostic and "goto" the cleanup-and-fail label. */
+#define GET_CONF_STR(conf, filename, var_name) \
+ do { \
+ virConfValuePtr p = virConfGetValue (conf, #var_name); \
+ if (p) { \
+ if (checkType (p, filename, #var_name, VIR_CONF_STRING) < 0) \
+ goto free_and_fail; \
+ (var_name) = strdup (p->str); \
+ if ((var_name) == NULL) { \
+ char ebuf[1024]; \
+ VIR_ERROR(_("remoteReadConfigFile: %s\n"), \
+ virStrerror(errno, ebuf, sizeof ebuf)); \
+ goto free_and_fail; \
+ } \
+ } \
+ } while (0)
+
+/* Like GET_CONF_STR, but for integral values. */
+#define GET_CONF_INT(conf, filename, var_name) \
+ do { \
+ virConfValuePtr p = virConfGetValue (conf, #var_name); \
+ if (p) { \
+ if (checkType (p, filename, #var_name, VIR_CONF_LONG) < 0) \
+ goto free_and_fail; \
+ (var_name) = p->l; \
+ } \
+ } while (0)
+
+
+static int remoteConfigGetAuth(virConfPtr conf, const char *key, int *auth, const char *filename) {
+ virConfValuePtr p;
+
+ p = virConfGetValue (conf, key);
+ if (!p)
+ return 0;
+
+ if (checkType (p, filename, key, VIR_CONF_STRING) < 0)
+ return -1;
+
+ if (!p->str)
+ return 0;
+
+ if (STREQ(p->str, "none")) {
+ *auth = REMOTE_AUTH_NONE;
+#if HAVE_SASL
+ } else if (STREQ(p->str, "sasl")) {
+ *auth = REMOTE_AUTH_SASL;
+#endif
+#if HAVE_POLKIT
+ } else if (STREQ(p->str, "polkit")) {
+ *auth = REMOTE_AUTH_POLKIT;
+#endif
+ } else {
+ VIR_ERROR(_("remoteReadConfigFile: %s: %s: unsupported auth %s\n"),
+ filename, key, p->str);
+ return -1;
+ }
+
+ return 0;
+}
+
+#ifdef HAVE_SASL
+static inline int
+remoteReadSaslAllowedUsernameList (virConfPtr conf,
+ struct qemud_server *server,
+ const char *filename)
+{
+ return
+ remoteConfigGetStringList (conf, "sasl_allowed_username_list",
+ &server->saslUsernameWhitelist, filename);
+}
+#else
+static inline int
+remoteReadSaslAllowedUsernameList (virConfPtr conf ATTRIBUTE_UNUSED,
+ struct qemud_server *server ATTRIBUTE_UNUSED,
+ const char *filename ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+#endif
+
+/*
+ * Set up the logging environment
+ * By default if daemonized all errors go to syslog and the logging
+ * is also saved onto the logfile libvird.log, but if verbose or error
+ * debugging is asked for then output informations or debug.
+ */
+static int
+qemudSetLogging(virConfPtr conf, const char *filename) {
+ int log_level;
+ char *log_filters = NULL;
+ char *log_outputs = NULL;
+ int ret = -1;
+
+ virLogReset();
+
+ /*
+ * Libvirtd's order of precedence is:
+ * cmdline > environment > config
+ *
+ * In order to achieve this, we must process configuration in
+ * different order for the log level versus the filters and
+ * outputs. Because filters and outputs append, we have to look at
+ * the environment first and then only check the config file if
+ * there was no result from the environment. The default output is
+ * then applied only if there was no setting from either of the
+ * first two. Because we don't have a way to determine if the log
+ * level has been set, we must process variables in the opposite
+ * order, each one overriding the previous.
+ */
+ /*
+ * GET_CONF_INT returns 0 when there is no log_level setting in
+ * the config file. The conditional below eliminates a false
+ * warning in that case, but also has the side effect of missing
+ * a warning if the user actually does say log_level=0.
+ */
+ GET_CONF_INT (conf, filename, log_level);
+ if (log_level != 0)
+ virLogSetDefaultPriority(log_level);
+
+ virLogSetFromEnv();
+
+ if (virLogGetNbFilters() == 0) {
+ GET_CONF_STR (conf, filename, log_filters);
+ virLogParseFilters(log_filters);
+ }
+
+ if (virLogGetNbOutputs() == 0) {
+ GET_CONF_STR (conf, filename, log_outputs);
+ virLogParseOutputs(log_outputs);
+ }
+
+ /*
+ * If no defined outputs, then direct to syslog when running
+ * as daemon. Otherwise the default output is stderr.
+ */
+ if (virLogGetNbOutputs() == 0) {
+ char *tmp = NULL;
+ if (godaemon) {
+ if (virAsprintf (&tmp, "%d:syslog:libvirtd",
+ virLogGetDefaultPriority()) < 0)
+ goto free_and_fail;
+ } else {
+ if (virAsprintf (&tmp, "%d:stderr",
+ virLogGetDefaultPriority()) < 0)
+ goto free_and_fail;
+ }
+ virLogParseOutputs(tmp);
+ VIR_FREE(tmp);
+ }
+
+ /*
+ * Command line override for --verbose
+ */
+ if ((verbose) && (virLogGetDefaultPriority() > VIR_LOG_INFO))
+ virLogSetDefaultPriority(VIR_LOG_INFO);
+
+ ret = 0;
+
+free_and_fail:
+ VIR_FREE(log_filters);
+ VIR_FREE(log_outputs);
+ return(ret);
+}
+
+/* Read the config file if it exists.
+ * Only used in the remote case, hence the name.
+ */
+static int
+remoteReadConfigFile (struct qemud_server *server, const char *filename)
+{
+ virConfPtr conf;
+
+ /* The following variable names must match the corresponding
+ configuration strings. */
+ char *unix_sock_ro_perms = NULL;
+ char *unix_sock_rw_perms = NULL;
+ char *unix_sock_group = NULL;
+ char *buf = NULL;
+
+#if HAVE_POLKIT
+ /* Change the default back to no auth for non-root */
+ if (!server->privileged && auth_unix_rw == REMOTE_AUTH_POLKIT)
+ auth_unix_rw = REMOTE_AUTH_NONE;
+ if (!server->privileged && auth_unix_ro == REMOTE_AUTH_POLKIT)
+ auth_unix_ro = REMOTE_AUTH_NONE;
+#endif
+
+ conf = virConfReadFile (filename, 0);
+ if (!conf) return -1;
+
+ /*
+ * First get all the logging settings and activate them
+ */
+ if (qemudSetLogging(conf, filename) < 0)
+ goto free_and_fail;
+
+ GET_CONF_INT (conf, filename, listen_tcp);
+ GET_CONF_INT (conf, filename, listen_tls);
+ GET_CONF_STR (conf, filename, tls_port);
+ GET_CONF_STR (conf, filename, tcp_port);
+ GET_CONF_STR (conf, filename, listen_addr);
+
+ if (remoteConfigGetAuth(conf, "auth_unix_rw", &auth_unix_rw, filename) < 0)
+ goto free_and_fail;
+#if HAVE_POLKIT
+ /* Change default perms to be wide-open if PolicyKit is enabled.
+ * Admin can always override in config file
+ */
+ if (auth_unix_rw == REMOTE_AUTH_POLKIT)
+ unix_sock_rw_mask = 0777;
+#endif
+ if (remoteConfigGetAuth(conf, "auth_unix_ro", &auth_unix_ro, filename) < 0)
+ goto free_and_fail;
+ if (remoteConfigGetAuth(conf, "auth_tcp", &auth_tcp, filename) < 0)
+ goto free_and_fail;
+ if (remoteConfigGetAuth(conf, "auth_tls", &auth_tls, filename) < 0)
+ goto free_and_fail;
+
+ GET_CONF_STR (conf, filename, unix_sock_group);
+ if (unix_sock_group) {
+ if (!server->privileged) {
+ VIR_WARN0(_("Cannot set group when not running as root"));
+ } else {
+ int ret;
+ struct group grpdata, *grp;
+ size_t maxbuf = sysconf(_SC_GETGR_R_SIZE_MAX);
+
+ if (maxbuf == -1)
+ maxbuf = 1024;
+
+ if (VIR_ALLOC_N(buf, maxbuf) < 0) {
+ VIR_ERROR("%s", _("Failed to allocate memory for buffer"));
+ goto free_and_fail;
+ }
+
+ while ((ret = getgrnam_r(unix_sock_group, &grpdata,
+ buf, maxbuf,
+ &grp)) == ERANGE) {
+ maxbuf *= 2;
+ if (maxbuf > 65536 || VIR_REALLOC_N(buf, maxbuf) < 0) {
+ VIR_ERROR("%s", _("Failed to reallocate enough memory for buffer"));
+ goto free_and_fail;
+ }
+ }
+
+ if (ret != 0 || !grp) {
+ VIR_ERROR(_("Failed to lookup group '%s'"), unix_sock_group);
+ goto free_and_fail;
+ }
+ unix_sock_gid = grp->gr_gid;
+ VIR_FREE (buf);
+ }
+ free (unix_sock_group);
+ unix_sock_group = NULL;
+ }
+
+ GET_CONF_STR (conf, filename, unix_sock_ro_perms);
+ if (unix_sock_ro_perms) {
+ if (virStrToLong_i (unix_sock_ro_perms, NULL, 8, &unix_sock_ro_mask) != 0) {
+ VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_ro_perms);
+ goto free_and_fail;
+ }
+ free (unix_sock_ro_perms);
+ unix_sock_ro_perms = NULL;
+ }
+
+ GET_CONF_STR (conf, filename, unix_sock_rw_perms);
+ if (unix_sock_rw_perms) {
+ if (virStrToLong_i (unix_sock_rw_perms, NULL, 8, &unix_sock_rw_mask) != 0) {
+ VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_rw_perms);
+ goto free_and_fail;
+ }
+ free (unix_sock_rw_perms);
+ unix_sock_rw_perms = NULL;
+ }
+
+ GET_CONF_STR (conf, filename, unix_sock_dir);
+
+ GET_CONF_INT (conf, filename, mdns_adv);
+ GET_CONF_STR (conf, filename, mdns_name);
+
+ GET_CONF_INT (conf, filename, tls_no_verify_certificate);
+
+ GET_CONF_STR (conf, filename, key_file);
+ GET_CONF_STR (conf, filename, cert_file);
+ GET_CONF_STR (conf, filename, ca_file);
+ GET_CONF_STR (conf, filename, crl_file);
+
+ if (remoteConfigGetStringList (conf, "tls_allowed_dn_list",
+ &tls_allowed_dn_list, filename) < 0)
+ goto free_and_fail;
+
+ if (remoteReadSaslAllowedUsernameList (conf, server, filename) < 0)
+ goto free_and_fail;
+
+
+ GET_CONF_INT (conf, filename, min_workers);
+ GET_CONF_INT (conf, filename, max_workers);
+ GET_CONF_INT (conf, filename, max_clients);
+
+ GET_CONF_INT (conf, filename, max_requests);
+ GET_CONF_INT (conf, filename, max_client_requests);
+
+ virConfFree (conf);
+ return 0;
+
+ free_and_fail:
+ virConfFree (conf);
+ free (mdns_name);
+ mdns_name = NULL;
+ free (unix_sock_ro_perms);
+ free (unix_sock_rw_perms);
+ free (unix_sock_group);
+ VIR_FREE (buf);
+
+ /* Don't bother trying to free listen_addr, tcp_port, tls_port, key_file,
+ cert_file, ca_file, or crl_file, since they are initialized to
+ non-malloc'd strings. Besides, these are static variables, and callers
+ are unlikely to call this function more than once, so there wouldn't
+ even be a real leak. */
+
+ if (tls_allowed_dn_list) {
+ int i;
+ for (i = 0; tls_allowed_dn_list[i]; i++)
+ free (tls_allowed_dn_list[i]);
+ free (tls_allowed_dn_list);
+ tls_allowed_dn_list = NULL;
+ }
+
+ return -1;
+}
+
+/* Display version information. */
+static void
+version (const char *argv0)
+{
+ printf ("%s (%s) %s\n", argv0, PACKAGE_NAME, PACKAGE_VERSION);
+}
+
+#ifdef __sun
+static int
+qemudSetupPrivs (void)
+{
+ chown ("/var/run/libvirt", SYSTEM_UID, SYSTEM_UID);
+
+ if (__init_daemon_priv (PU_RESETGROUPS | PU_CLEARLIMITSET,
+ SYSTEM_UID, SYSTEM_UID, PRIV_XVM_CONTROL, NULL)) {
+ VIR_ERROR0(_("additional privileges are required\n"));
+ return -1;
+ }
+
+ if (priv_set (PRIV_OFF, PRIV_ALLSETS, PRIV_FILE_LINK_ANY, PRIV_PROC_INFO,
+ PRIV_PROC_SESSION, PRIV_PROC_EXEC, PRIV_PROC_FORK, NULL)) {
+ VIR_ERROR0(_("failed to set reduced privileges\n"));
+ return -1;
+ }
+
+ return 0;
+}
+#else
+#define qemudSetupPrivs() 0
+#endif
+
+/* Print command-line usage. */
+static void
+usage (const char *argv0)
+{
+ fprintf (stderr,
+ "\n\
+Usage:\n\
+ %s [options]\n\
+\n\
+Options:\n\
+ -v | --verbose Verbose messages.\n\
+ -d | --daemon Run as a daemon & write PID file.\n\
+ -l | --listen Listen for TCP/IP connections.\n\
+ -t | --timeout <secs> Exit after timeout period.\n\
+ -f | --config <file> Configuration file.\n\
+ | --version Display version information.\n\
+ -p | --pid-file <file> Change name of PID file.\n\
+\n\
+libvirt management daemon:\n\
+\n\
+ Default paths:\n\
+\n\
+ Configuration file (unless overridden by -c):\n\
+ " SYSCONF_DIR "/libvirt/libvirtd.conf\n\
+\n\
+ Sockets (as root):\n\
+ " LOCAL_STATE_DIR "/run/libvirt/libvirt-sock\n\
+ " LOCAL_STATE_DIR "/run/libvirt/libvirt-sock-ro\n\
+\n\
+ Sockets (as non-root):\n\
+ $HOME/.libvirt/libvirt-sock (in UNIX abstract namespace)\n\
+\n\
+ TLS:\n\
+ CA certificate: " LIBVIRT_CACERT "\n\
+ Server certificate: " LIBVIRT_SERVERCERT "\n\
+ Server private key: " LIBVIRT_SERVERKEY "\n\
+\n\
+ PID file (unless overridden by --pid-file):\n\
+ %s\n\
+\n",
+ argv0,
+ REMOTE_PID_FILE[0] != '\0'
+ ? REMOTE_PID_FILE
+ : "(disabled in ./configure)");
+}
+
+enum {
+ OPT_VERSION = 129
+};
+
+#define MAX_LISTEN 5
+int main(int argc, char **argv) {
+ struct qemud_server *server = NULL;
+ struct sigaction sig_action;
+ int sigpipe[2];
+ const char *pid_file = NULL;
+ const char *remote_config_file = NULL;
+ int ret = 1;
+
+ struct option opts[] = {
+ { "verbose", no_argument, &verbose, 1},
+ { "daemon", no_argument, &godaemon, 1},
+ { "listen", no_argument, &ipsock, 1},
+ { "config", required_argument, NULL, 'f'},
+ { "timeout", required_argument, NULL, 't'},
+ { "pid-file", required_argument, NULL, 'p'},
+ { "version", no_argument, NULL, OPT_VERSION },
+ { "help", no_argument, NULL, '?' },
+ {0, 0, 0, 0}
+ };
+
+ while (1) {
+ int optidx = 0;
+ int c;
+ char *tmp;
+
+ c = getopt_long(argc, argv, "ldf:p:t:v", opts, &optidx);
+
+ if (c == -1) {
+ break;
+ }
+
+ switch (c) {
+ case 0:
+ /* Got one of the flags */
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case 'd':
+ godaemon = 1;
+ break;
+ case 'l':
+ ipsock = 1;
+ break;
+
+ case 't':
+ if (virStrToLong_i(optarg, &tmp, 10, &timeout) != 0
+ || timeout <= 0
+ /* Ensure that we can multiply by 1000 without overflowing. */
+ || timeout > INT_MAX / 1000)
+ timeout = -1;
+ break;
+
+ case 'p':
+ pid_file = optarg;
+ break;
+
+ case 'f':
+ remote_config_file = optarg;
+ break;
+
+ case OPT_VERSION:
+ version (argv[0]);
+ return 0;
+
+ case '?':
+ usage (argv[0]);
+ return 2;
+
+ default:
+ fprintf (stderr, "libvirtd: internal error: unknown flag: %c\n",
+ c);
+ exit (1);
+ }
+ }
+
+ if (remote_config_file == NULL) {
+ static const char *default_config_file
+ = SYSCONF_DIR "/libvirt/libvirtd.conf";
+ remote_config_file =
+ (access(default_config_file, R_OK) == 0
+ ? default_config_file
+ : "/dev/null");
+ }
+
+ if (godaemon) {
+ char ebuf[1024];
+ if (qemudGoDaemon() < 0) {
+ VIR_ERROR(_("Failed to fork as daemon: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ goto error1;
+ }
+ }
+
+ /* If running as root and no PID file is set, use the default */
+ if (pid_file == NULL &&
+ geteuid() == 0 &&
+ REMOTE_PID_FILE[0] != '\0')
+ pid_file = REMOTE_PID_FILE;
+
+ /* If we have a pidfile set, claim it now, exiting if already taken */
+ if (pid_file != NULL &&
+ qemudWritePidFile (pid_file) < 0)
+ goto error1;
+
+ if (pipe(sigpipe) < 0 ||
+ virSetNonBlock(sigpipe[0]) < 0 ||
+ virSetNonBlock(sigpipe[1]) < 0 ||
+ virSetCloseExec(sigpipe[0]) < 0 ||
+ virSetCloseExec(sigpipe[1]) < 0) {
+ char ebuf[1024];
+ VIR_ERROR(_("Failed to create pipe: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ goto error2;
+ }
+ sigwrite = sigpipe[1];
+
+ sig_action.sa_sigaction = sig_handler;
+ sig_action.sa_flags = SA_SIGINFO;
+ sigemptyset(&sig_action.sa_mask);
+
+ sigaction(SIGHUP, &sig_action, NULL);
+ sigaction(SIGINT, &sig_action, NULL);
+ sigaction(SIGQUIT, &sig_action, NULL);
+ sigaction(SIGTERM, &sig_action, NULL);
+ sigaction(SIGCHLD, &sig_action, NULL);
+
+ sig_action.sa_handler = SIG_IGN;
+ sigaction(SIGPIPE, &sig_action, NULL);
+
+ /* Ensure the rundir exists (on tmpfs on some systems) */
+ if (geteuid() == 0) {
+ const char *rundir = LOCAL_STATE_DIR "/run/libvirt";
+
+ if (mkdir (rundir, 0755)) {
+ if (errno != EEXIST) {
+ VIR_ERROR0 (_("unable to create rundir"));
+ return -1;
+ }
+ }
+ }
+
+ /* Beyond this point, nothing should rely on using
+ * getuid/geteuid() == 0, for privilege level checks.
+ * It must all use the flag 'server->privileged'
+ * which is also passed into all libvirt stateful
+ * drivers
+ */
+ if (qemudSetupPrivs() < 0)
+ goto error2;
+
+ if (!(server = qemudInitialize(sigpipe[0]))) {
+ ret = 2;
+ goto error2;
+ }
+
+ /* Read the config file (if it exists). */
+ if (remoteReadConfigFile (server, remote_config_file) < 0)
+ goto error2;
+
+ /* Change the group ownership of /var/run/libvirt to unix_sock_gid */
+ if (unix_sock_dir && server->privileged) {
+ if (chown(unix_sock_dir, -1, unix_sock_gid) < 0)
+ VIR_ERROR(_("Failed to change group ownership of %s"),
+ unix_sock_dir);
+ }
+
+ if (virEventAddHandleImpl(sigpipe[0],
+ VIR_EVENT_HANDLE_READABLE,
+ qemudDispatchSignalEvent,
+ server, NULL) < 0) {
+ VIR_ERROR0(_("Failed to register callback for signal pipe"));
+ ret = 3;
+ goto error2;
+ }
+
+ if (!(server = qemudNetworkInit(server))) {
+ ret = 2;
+ goto error2;
+ }
+
+ qemudRunLoop(server);
+
+ ret = 0;
+
+error2:
+ if (server)
+ qemudCleanup(server);
+ if (pid_file)
+ unlink (pid_file);
+ close(sigwrite);
+
+error1:
+ virLogShutdown();
+ return ret;
+}
--- /dev/null
+/*
+ * 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
--- /dev/null
+/*
+ * remote.c: 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>
+ */
+
+#include <config.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/poll.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <string.h>
+#include <errno.h>
+#include <fnmatch.h>
+#include "virterror_internal.h"
+
+#if HAVE_POLKIT0
+#include <polkit/polkit.h>
+#include <polkit-dbus/polkit-dbus.h>
+#endif
+
+#include "remote.h"
+#include "dispatch.h"
+
+#include "libvirt_internal.h"
+#include "datatypes.h"
+#include "memory.h"
+#include "util.h"
+
+#define VIR_FROM_THIS VIR_FROM_REMOTE
+#define REMOTE_DEBUG(fmt, ...) DEBUG(fmt, __VA_ARGS__)
+
+static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
+static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
+static virInterfacePtr get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface iface);
+static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
+static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
+static virSecretPtr get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret);
+static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
+static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
+static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
+static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src);
+static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
+static void make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src);
+static void make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
+
+
+#include "remote_dispatch_prototypes.h"
+
+static const dispatch_data const dispatch_table[] = {
+#include "remote_dispatch_table.h"
+};
+
+const dispatch_data const *remoteGetDispatchData(int proc)
+{
+ if (proc >= ARRAY_CARDINALITY(dispatch_table) ||
+ dispatch_table[proc].fn == NULL) {
+ return NULL;
+ }
+
+ return &(dispatch_table[proc]);
+}
+
+/* Prototypes */
+static void
+remoteDispatchDomainEventSend (struct qemud_client *client,
+ remote_domain_event_msg *data);
+
+int remoteRelayDomainEvent (virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int event,
+ int detail,
+ void *opaque)
+{
+ struct qemud_client *client = opaque;
+ REMOTE_DEBUG("Relaying domain event %d %d", event, detail);
+
+ if (client) {
+ remote_domain_event_msg data;
+
+ virMutexLock(&client->lock);
+
+ /* build return data */
+ memset(&data, 0, sizeof data);
+ make_nonnull_domain (&data.dom, dom);
+ data.event = event;
+ data.detail = detail;
+
+ remoteDispatchDomainEventSend (client, &data);
+
+ virMutexUnlock(&client->lock);
+ }
+ return 0;
+}
+
+
+/*----- Functions. -----*/
+
+static int
+remoteDispatchOpen (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *rerr,
+ struct remote_open_args *args, void *ret ATTRIBUTE_UNUSED)
+{
+ const char *name;
+ int flags, rc;
+
+ /* Already opened? */
+ if (conn) {
+ remoteDispatchFormatError (rerr, "%s", _("connection already open"));
+ return -1;
+ }
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ name = args->name ? *args->name : NULL;
+
+ /* If this connection arrived on a readonly socket, force
+ * the connection to be readonly.
+ */
+ flags = args->flags;
+ if (client->readonly) flags |= VIR_CONNECT_RO;
+
+ client->conn =
+ flags & VIR_CONNECT_RO
+ ? virConnectOpenReadOnly (name)
+ : virConnectOpen (name);
+
+ if (client->conn == NULL)
+ remoteDispatchConnError(rerr, NULL);
+
+ rc = client->conn ? 0 : -1;
+ virMutexUnlock(&client->lock);
+ return rc;
+}
+
+#define CHECK_CONN(client) \
+ if (!client->conn) { \
+ remoteDispatchFormatError (rerr, "%s", _("connection not open")); \
+ return -1; \
+ }
+
+static int
+remoteDispatchClose (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr ATTRIBUTE_UNUSED,
+ void *args ATTRIBUTE_UNUSED, void *ret ATTRIBUTE_UNUSED)
+{
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ client->closing = 1;
+
+ virMutexUnlock(&client->lock);
+ return 0;
+}
+
+static int
+remoteDispatchSupportsFeature (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_supports_feature_args *args, remote_supports_feature_ret *ret)
+{
+ ret->supported = virDrvSupportsFeature (conn, args->feature);
+
+ if (ret->supported == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchGetType (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED, remote_get_type_ret *ret)
+{
+ const char *type;
+
+ type = virConnectGetType (conn);
+ if (type == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* We have to strdup because remoteDispatchClientRequest will
+ * free this string after it's been serialised.
+ */
+ ret->type = strdup (type);
+ if (!ret->type) {
+ remoteDispatchFormatError (rerr, "%s", _("out of memory in strdup"));
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchGetVersion (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_get_version_ret *ret)
+{
+ unsigned long hvVer;
+
+ if (virConnectGetVersion (conn, &hvVer) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->hv_ver = hvVer;
+ return 0;
+}
+
+static int
+remoteDispatchGetHostname (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_get_hostname_ret *ret)
+{
+ char *hostname;
+
+ hostname = virConnectGetHostname (conn);
+ if (hostname == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->hostname = hostname;
+ return 0;
+}
+
+static int
+remoteDispatchGetUri (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_get_uri_ret *ret)
+{
+ char *uri;
+ CHECK_CONN(client);
+
+ uri = virConnectGetURI (conn);
+ if (uri == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->uri = uri;
+ return 0;
+}
+
+static int
+remoteDispatchGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_get_max_vcpus_args *args,
+ remote_get_max_vcpus_ret *ret)
+{
+ char *type;
+
+ type = args->type ? *args->type : NULL;
+ ret->max_vcpus = virConnectGetMaxVcpus (conn, type);
+ if (ret->max_vcpus == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNodeGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_node_get_info_ret *ret)
+{
+ virNodeInfo info;
+
+ if (virNodeGetInfo (conn, &info) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ memcpy (ret->model, info.model, sizeof ret->model);
+ ret->memory = info.memory;
+ ret->cpus = info.cpus;
+ ret->mhz = info.mhz;
+ ret->nodes = info.nodes;
+ ret->sockets = info.sockets;
+ ret->cores = info.cores;
+ ret->threads = info.threads;
+
+ return 0;
+}
+
+static int
+remoteDispatchGetCapabilities (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_get_capabilities_ret *ret)
+{
+ char *caps;
+
+ caps = virConnectGetCapabilities (conn);
+ if (caps == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->capabilities = caps;
+ return 0;
+}
+
+static int
+remoteDispatchNodeGetCellsFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_get_cells_free_memory_args *args,
+ remote_node_get_cells_free_memory_ret *ret)
+{
+ int err;
+
+ if (args->maxCells > REMOTE_NODE_MAX_CELLS) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxCells > REMOTE_NODE_MAX_CELLS"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->freeMems.freeMems_val, args->maxCells) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ err = virNodeGetCellsFreeMemory(conn,
+ (unsigned long long *)ret->freeMems.freeMems_val,
+ args->startCell,
+ args->maxCells);
+ if (err <= 0) {
+ VIR_FREE(ret->freeMems.freeMems_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ ret->freeMems.freeMems_len = err;
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeGetFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_node_get_free_memory_ret *ret)
+{
+ unsigned long long freeMem;
+
+ freeMem = virNodeGetFreeMemory(conn);
+ if (freeMem == 0) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ ret->freeMem = freeMem;
+ return 0;
+}
+
+
+static int
+remoteDispatchDomainGetSchedulerType (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_scheduler_type_args *args,
+ remote_domain_get_scheduler_type_ret *ret)
+{
+ virDomainPtr dom;
+ char *type;
+ int nparams;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ type = virDomainGetSchedulerType (dom, &nparams);
+ if (type == NULL) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->type = type;
+ ret->nparams = nparams;
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_scheduler_parameters_args *args,
+ remote_domain_get_scheduler_parameters_ret *ret)
+{
+ virDomainPtr dom;
+ virSchedParameterPtr params;
+ int i, r, nparams;
+
+ nparams = args->nparams;
+
+ if (nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
+ remoteDispatchFormatError (rerr, "%s", _("nparams too large"));
+ return -1;
+ }
+ if (VIR_ALLOC_N(params, nparams) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ VIR_FREE(params);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ r = virDomainGetSchedulerParameters (dom, params, &nparams);
+ if (r == -1) {
+ virDomainFree(dom);
+ VIR_FREE(params);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Serialise the scheduler parameters. */
+ ret->params.params_len = nparams;
+ if (VIR_ALLOC_N(ret->params.params_val, nparams) < 0)
+ goto oom;
+
+ for (i = 0; i < nparams; ++i) {
+ // remoteDispatchClientRequest will free this:
+ ret->params.params_val[i].field = strdup (params[i].field);
+ if (ret->params.params_val[i].field == NULL)
+ goto oom;
+
+ ret->params.params_val[i].value.type = params[i].type;
+ switch (params[i].type) {
+ case VIR_DOMAIN_SCHED_FIELD_INT:
+ ret->params.params_val[i].value.remote_sched_param_value_u.i = params[i].value.i; break;
+ case VIR_DOMAIN_SCHED_FIELD_UINT:
+ ret->params.params_val[i].value.remote_sched_param_value_u.ui = params[i].value.ui; break;
+ case VIR_DOMAIN_SCHED_FIELD_LLONG:
+ ret->params.params_val[i].value.remote_sched_param_value_u.l = params[i].value.l; break;
+ case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+ ret->params.params_val[i].value.remote_sched_param_value_u.ul = params[i].value.ul; break;
+ case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+ ret->params.params_val[i].value.remote_sched_param_value_u.d = params[i].value.d; break;
+ case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+ ret->params.params_val[i].value.remote_sched_param_value_u.b = params[i].value.b; break;
+ default:
+ remoteDispatchFormatError (rerr, "%s", _("unknown type"));
+ goto cleanup;
+ }
+ }
+ virDomainFree(dom);
+ VIR_FREE(params);
+
+ return 0;
+
+oom:
+ remoteDispatchOOMError(rerr);
+cleanup:
+ virDomainFree(dom);
+ for (i = 0 ; i < nparams ; i++)
+ VIR_FREE(ret->params.params_val[i].field);
+ VIR_FREE(params);
+ return -1;
+}
+
+static int
+remoteDispatchDomainSetSchedulerParameters (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_set_scheduler_parameters_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+ int i, r, nparams;
+ virSchedParameterPtr params;
+
+ nparams = args->params.params_len;
+
+ if (nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
+ remoteDispatchFormatError (rerr, "%s", _("nparams too large"));
+ return -1;
+ }
+ if (VIR_ALLOC_N(params, nparams)) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ /* Deserialise parameters. */
+ for (i = 0; i < nparams; ++i) {
+ strncpy (params[i].field, args->params.params_val[i].field,
+ VIR_DOMAIN_SCHED_FIELD_LENGTH);
+ params[i].field[VIR_DOMAIN_SCHED_FIELD_LENGTH-1] = '\0';
+ params[i].type = args->params.params_val[i].value.type;
+ switch (params[i].type) {
+ case VIR_DOMAIN_SCHED_FIELD_INT:
+ params[i].value.i = args->params.params_val[i].value.remote_sched_param_value_u.i; break;
+ case VIR_DOMAIN_SCHED_FIELD_UINT:
+ params[i].value.ui = args->params.params_val[i].value.remote_sched_param_value_u.ui; break;
+ case VIR_DOMAIN_SCHED_FIELD_LLONG:
+ params[i].value.l = args->params.params_val[i].value.remote_sched_param_value_u.l; break;
+ case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+ params[i].value.ul = args->params.params_val[i].value.remote_sched_param_value_u.ul; break;
+ case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+ params[i].value.d = args->params.params_val[i].value.remote_sched_param_value_u.d; break;
+ case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+ params[i].value.b = args->params.params_val[i].value.remote_sched_param_value_u.b; break;
+ }
+ }
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ VIR_FREE(params);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ r = virDomainSetSchedulerParameters (dom, params, nparams);
+ virDomainFree(dom);
+ VIR_FREE(params);
+ if (r == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainBlockStats (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_block_stats_args *args,
+ remote_domain_block_stats_ret *ret)
+{
+ virDomainPtr dom;
+ char *path;
+ struct _virDomainBlockStats stats;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ path = args->path;
+
+ if (virDomainBlockStats (dom, path, &stats, sizeof stats) == -1) {
+ virDomainFree (dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree (dom);
+
+ ret->rd_req = stats.rd_req;
+ ret->rd_bytes = stats.rd_bytes;
+ ret->wr_req = stats.wr_req;
+ ret->wr_bytes = stats.wr_bytes;
+ ret->errs = stats.errs;
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainInterfaceStats (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_interface_stats_args *args,
+ remote_domain_interface_stats_ret *ret)
+{
+ virDomainPtr dom;
+ char *path;
+ struct _virDomainInterfaceStats stats;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ path = args->path;
+
+ if (virDomainInterfaceStats (dom, path, &stats, sizeof stats) == -1) {
+ virDomainFree (dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree (dom);
+
+ ret->rx_bytes = stats.rx_bytes;
+ ret->rx_packets = stats.rx_packets;
+ ret->rx_errs = stats.rx_errs;
+ ret->rx_drop = stats.rx_drop;
+ ret->tx_bytes = stats.tx_bytes;
+ ret->tx_packets = stats.tx_packets;
+ ret->tx_errs = stats.tx_errs;
+ ret->tx_drop = stats.tx_drop;
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainBlockPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_block_peek_args *args,
+ remote_domain_block_peek_ret *ret)
+{
+ virDomainPtr dom;
+ char *path;
+ unsigned long long offset;
+ size_t size;
+ unsigned int flags;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ path = args->path;
+ offset = args->offset;
+ size = args->size;
+ flags = args->flags;
+
+ if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
+ virDomainFree (dom);
+ remoteDispatchFormatError (rerr,
+ "%s", _("size > maximum buffer size"));
+ return -1;
+ }
+
+ ret->buffer.buffer_len = size;
+ if (VIR_ALLOC_N (ret->buffer.buffer_val, size) < 0) {
+ char ebuf[1024];
+ virDomainFree (dom);
+ remoteDispatchFormatError (rerr, "%s",
+ virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ if (virDomainBlockPeek (dom, path, offset, size,
+ ret->buffer.buffer_val, flags) == -1) {
+ /* free (ret->buffer.buffer_val); - caller frees */
+ virDomainFree (dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree (dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainMemoryPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_memory_peek_args *args,
+ remote_domain_memory_peek_ret *ret)
+{
+ virDomainPtr dom;
+ unsigned long long offset;
+ size_t size;
+ unsigned int flags;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ offset = args->offset;
+ size = args->size;
+ flags = args->flags;
+
+ if (size > REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX) {
+ virDomainFree (dom);
+ remoteDispatchFormatError (rerr,
+ "%s", _("size > maximum buffer size"));
+ return -1;
+ }
+
+ ret->buffer.buffer_len = size;
+ if (VIR_ALLOC_N (ret->buffer.buffer_val, size) < 0) {
+ char ebuf[1024];
+ virDomainFree (dom);
+ remoteDispatchFormatError (rerr, "%s",
+ virStrerror(errno, ebuf, sizeof ebuf));
+ return -1;
+ }
+
+ if (virDomainMemoryPeek (dom, offset, size,
+ ret->buffer.buffer_val, flags) == -1) {
+ /* free (ret->buffer.buffer_val); - caller frees */
+ virDomainFree (dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree (dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainAttachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_attach_device_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainAttachDevice (dom, args->xml) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainCreate (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_create_xml_args *args,
+ remote_domain_create_xml_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = virDomainCreateXML (conn, args->xml_desc, args->flags);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->dom, dom);
+ virDomainFree(dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_define_xml_args *args,
+ remote_domain_define_xml_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = virDomainDefineXML (conn, args->xml);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->dom, dom);
+ virDomainFree(dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainDestroy (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainDetachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_detach_device_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainDetachDevice (dom, args->xml) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_dump_xml_args *args,
+ remote_domain_dump_xml_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virDomainGetXMLDesc (dom, args->flags);
+ if (!ret->xml) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainXmlFromNative (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_xml_from_native_args *args,
+ remote_domain_xml_from_native_ret *ret)
+{
+ /* remoteDispatchClientRequest will free this. */
+ ret->domainXml = virConnectDomainXMLFromNative (conn,
+ args->nativeFormat,
+ args->nativeConfig,
+ args->flags);
+ if (!ret->domainXml) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ return 0;
+}
+
+static int
+remoteDispatchDomainXmlToNative (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_xml_to_native_args *args,
+ remote_domain_xml_to_native_ret *ret)
+{
+ /* remoteDispatchClientRequest will free this. */
+ ret->nativeConfig = virConnectDomainXMLToNative (conn,
+ args->nativeFormat,
+ args->domainXml,
+ args->flags);
+ if (!ret->nativeConfig) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ return 0;
+}
+
+
+static int
+remoteDispatchDomainGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_autostart_args *args,
+ remote_domain_get_autostart_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainGetAutostart (dom, &ret->autostart) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_info_args *args,
+ remote_domain_get_info_ret *ret)
+{
+ virDomainPtr dom;
+ virDomainInfo info;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainGetInfo (dom, &info) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->state = info.state;
+ ret->max_mem = info.maxMem;
+ ret->memory = info.memory;
+ ret->nr_virt_cpu = info.nrVirtCpu;
+ ret->cpu_time = info.cpuTime;
+
+ virDomainFree(dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_max_memory_args *args,
+ remote_domain_get_max_memory_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->memory = virDomainGetMaxMemory (dom);
+ if (ret->memory == 0) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_max_vcpus_args *args,
+ remote_domain_get_max_vcpus_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->num = virDomainGetMaxVcpus (dom);
+ if (ret->num == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetSecurityLabel(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_security_label_args *args,
+ remote_domain_get_security_label_ret *ret)
+{
+ virDomainPtr dom;
+ virSecurityLabel seclabel;
+
+ dom = get_nonnull_domain(conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ memset(&seclabel, 0, sizeof seclabel);
+ if (virDomainGetSecurityLabel(dom, &seclabel) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->label.label_len = strlen(seclabel.label) + 1;
+ if (VIR_ALLOC_N(ret->label.label_val, ret->label.label_len) < 0) {
+ virDomainFree(dom);
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ strcpy(ret->label.label_val, seclabel.label);
+ ret->enforcing = seclabel.enforcing;
+ virDomainFree(dom);
+
+ return 0;
+}
+
+static int
+remoteDispatchNodeGetSecurityModel(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_node_get_security_model_ret *ret)
+{
+ virSecurityModel secmodel;
+
+ memset(&secmodel, 0, sizeof secmodel);
+ if (virNodeGetSecurityModel(conn, &secmodel) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->model.model_len = strlen(secmodel.model) + 1;
+ if (VIR_ALLOC_N(ret->model.model_val, ret->model.model_len) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ strcpy(ret->model.model_val, secmodel.model);
+
+ ret->doi.doi_len = strlen(secmodel.doi) + 1;
+ if (VIR_ALLOC_N(ret->doi.doi_val, ret->doi.doi_len) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ strcpy(ret->doi.doi_val, secmodel.doi);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetOsType (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_os_type_args *args,
+ remote_domain_get_os_type_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this */
+ ret->type = virDomainGetOSType (dom);
+ if (ret->type == NULL) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_get_vcpus_args *args,
+ remote_domain_get_vcpus_ret *ret)
+{
+ virDomainPtr dom = NULL;
+ virVcpuInfoPtr info = NULL;
+ unsigned char *cpumaps = NULL;
+ int info_len, i;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (args->maxinfo > REMOTE_VCPUINFO_MAX) {
+ virDomainFree(dom);
+ remoteDispatchFormatError (rerr, "%s", _("maxinfo > REMOTE_VCPUINFO_MAX"));
+ return -1;
+ }
+
+ if (args->maxinfo * args->maplen > REMOTE_CPUMAPS_MAX) {
+ virDomainFree(dom);
+ remoteDispatchFormatError (rerr, "%s", _("maxinfo * maplen > REMOTE_CPUMAPS_MAX"));
+ return -1;
+ }
+
+ /* Allocate buffers to take the results. */
+ if (VIR_ALLOC_N(info, args->maxinfo) < 0)
+ goto oom;
+ if (args->maplen > 0 &&
+ VIR_ALLOC_N(cpumaps, args->maxinfo * args->maplen) < 0)
+ goto oom;
+
+ info_len = virDomainGetVcpus (dom,
+ info, args->maxinfo,
+ cpumaps, args->maplen);
+ if (info_len == -1) {
+ VIR_FREE(info);
+ VIR_FREE(cpumaps);
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Allocate the return buffer for info. */
+ ret->info.info_len = info_len;
+ if (VIR_ALLOC_N(ret->info.info_val, info_len) < 0)
+ goto oom;
+
+ for (i = 0; i < info_len; ++i) {
+ ret->info.info_val[i].number = info[i].number;
+ ret->info.info_val[i].state = info[i].state;
+ ret->info.info_val[i].cpu_time = info[i].cpuTime;
+ ret->info.info_val[i].cpu = info[i].cpu;
+ }
+
+ /* Don't need to allocate/copy the cpumaps if we make the reasonable
+ * assumption that unsigned char and char are the same size.
+ * Note that remoteDispatchClientRequest will free.
+ */
+ ret->cpumaps.cpumaps_len = args->maxinfo * args->maplen;
+ ret->cpumaps.cpumaps_val = (char *) cpumaps;
+
+ VIR_FREE(info);
+ virDomainFree(dom);
+ return 0;
+
+oom:
+ VIR_FREE(info);
+ VIR_FREE(cpumaps);
+ virDomainFree(dom);
+ remoteDispatchOOMError(rerr);
+ return -1;
+}
+
+static int
+remoteDispatchDomainMigratePrepare (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_migrate_prepare_args *args,
+ remote_domain_migrate_prepare_ret *ret)
+{
+ int r;
+ char *cookie = NULL;
+ int cookielen = 0;
+ char *uri_in;
+ char **uri_out;
+ char *dname;
+
+ uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
+ dname = args->dname == NULL ? NULL : *args->dname;
+
+ /* Wacky world of XDR ... */
+ if (VIR_ALLOC(uri_out) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ r = virDomainMigratePrepare (conn, &cookie, &cookielen,
+ uri_in, uri_out,
+ args->flags, dname, args->resource);
+ if (r == -1) {
+ VIR_FREE(uri_out);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free cookie, uri_out and
+ * the string if there is one.
+ */
+ ret->cookie.cookie_len = cookielen;
+ ret->cookie.cookie_val = cookie;
+ if (*uri_out == NULL) {
+ ret->uri_out = NULL;
+ VIR_FREE(uri_out);
+ } else {
+ ret->uri_out = uri_out;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainMigratePerform (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_migrate_perform_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ int r;
+ virDomainPtr dom;
+ char *dname;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ dname = args->dname == NULL ? NULL : *args->dname;
+
+ r = virDomainMigratePerform (dom,
+ args->cookie.cookie_val,
+ args->cookie.cookie_len,
+ args->uri,
+ args->flags, dname, args->resource);
+ virDomainFree (dom);
+ if (r == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainMigrateFinish (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_migrate_finish_args *args,
+ remote_domain_migrate_finish_ret *ret)
+{
+ virDomainPtr ddom;
+ CHECK_CONN (client);
+
+ ddom = virDomainMigrateFinish (conn, args->dname,
+ args->cookie.cookie_val,
+ args->cookie.cookie_len,
+ args->uri,
+ args->flags);
+ if (ddom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->ddom, ddom);
+ virDomainFree (ddom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainMigratePrepare2 (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_migrate_prepare2_args *args,
+ remote_domain_migrate_prepare2_ret *ret)
+{
+ int r;
+ char *cookie = NULL;
+ int cookielen = 0;
+ char *uri_in;
+ char **uri_out;
+ char *dname;
+ CHECK_CONN (client);
+
+ uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
+ dname = args->dname == NULL ? NULL : *args->dname;
+
+ /* Wacky world of XDR ... */
+ if (VIR_ALLOC(uri_out) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ r = virDomainMigratePrepare2 (conn, &cookie, &cookielen,
+ uri_in, uri_out,
+ args->flags, dname, args->resource,
+ args->dom_xml);
+ if (r == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free cookie, uri_out and
+ * the string if there is one.
+ */
+ ret->cookie.cookie_len = cookielen;
+ ret->cookie.cookie_val = cookie;
+ ret->uri_out = *uri_out == NULL ? NULL : uri_out;
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainMigrateFinish2 (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_migrate_finish2_args *args,
+ remote_domain_migrate_finish2_ret *ret)
+{
+ virDomainPtr ddom;
+ CHECK_CONN (client);
+
+ ddom = virDomainMigrateFinish2 (conn, args->dname,
+ args->cookie.cookie_val,
+ args->cookie.cookie_len,
+ args->uri,
+ args->flags,
+ args->retcode);
+ if (ddom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->ddom, ddom);
+
+ return 0;
+}
+
+static int
+remoteDispatchListDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_defined_domains_args *args,
+ remote_list_defined_domains_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_DOMAIN_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListDefinedDomains (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainLookupById (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_lookup_by_id_args *args,
+ remote_domain_lookup_by_id_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = virDomainLookupByID (conn, args->id);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->dom, dom);
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_lookup_by_name_args *args,
+ remote_domain_lookup_by_name_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = virDomainLookupByName (conn, args->name);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->dom, dom);
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_lookup_by_uuid_args *args,
+ remote_domain_lookup_by_uuid_ret *ret)
+{
+ virDomainPtr dom;
+
+ dom = virDomainLookupByUUID (conn, (unsigned char *) args->uuid);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain (&ret->dom, dom);
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchNumOfDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_defined_domains_ret *ret)
+{
+
+ ret->num = virConnectNumOfDefinedDomains (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainPinVcpu (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_pin_vcpu_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+ int rv;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (args->cpumap.cpumap_len > REMOTE_CPUMAP_MAX) {
+ virDomainFree(dom);
+ remoteDispatchFormatError (rerr, "%s", _("cpumap_len > REMOTE_CPUMAP_MAX"));
+ return -1;
+ }
+
+ rv = virDomainPinVcpu (dom, args->vcpu,
+ (unsigned char *) args->cpumap.cpumap_val,
+ args->cpumap.cpumap_len);
+ if (rv == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainReboot (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_reboot_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainReboot (dom, args->flags) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainRestore (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_restore_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+
+ if (virDomainRestore (conn, args->from) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainResume (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_resume_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainResume (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSave (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_save_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSave (dom, args->to) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainCoreDump (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_core_dump_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainCoreDump (dom, args->to, args->flags) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_set_autostart_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSetAutostart (dom, args->autostart) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_set_max_memory_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSetMaxMemory (dom, args->memory) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSetMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_set_memory_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSetMemory (dom, args->memory) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_set_vcpus_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSetVcpus (dom, args->nvcpus) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainShutdown (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_shutdown_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainShutdown (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainSuspend (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_suspend_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSuspend (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchDomainUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_domain_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainPtr dom;
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainUndefine (dom) == -1) {
+ virDomainFree(dom);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virDomainFree(dom);
+ return 0;
+}
+
+static int
+remoteDispatchListDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_defined_networks_args *args,
+ remote_list_defined_networks_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListDefinedNetworks (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_domains_args *args,
+ remote_list_domains_ret *ret)
+{
+
+ if (args->maxids > REMOTE_DOMAIN_ID_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxids > REMOTE_DOMAIN_ID_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->ids.ids_val, args->maxids) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->ids.ids_len = virConnectListDomains (conn,
+ ret->ids.ids_val, args->maxids);
+ if (ret->ids.ids_len == -1) {
+ VIR_FREE(ret->ids.ids_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_networks_args *args,
+ remote_list_networks_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListNetworks (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_len);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNetworkCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virNetworkCreate (net) == -1) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_create_xml_args *args,
+ remote_network_create_xml_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = virNetworkCreateXML (conn, args->xml);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_network (&ret->net, net);
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_define_xml_args *args,
+ remote_network_define_xml_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = virNetworkDefineXML (conn, args->xml);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_network (&ret->net, net);
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virNetworkDestroy (net) == -1) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_dump_xml_args *args,
+ remote_network_dump_xml_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virNetworkGetXMLDesc (net, args->flags);
+ if (!ret->xml) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_get_autostart_args *args,
+ remote_network_get_autostart_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virNetworkGetAutostart (net, &ret->autostart) == -1) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkGetBridgeName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_get_bridge_name_args *args,
+ remote_network_get_bridge_name_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->name = virNetworkGetBridgeName (net);
+ if (!ret->name) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_lookup_by_name_args *args,
+ remote_network_lookup_by_name_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = virNetworkLookupByName (conn, args->name);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_network (&ret->net, net);
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_lookup_by_uuid_args *args,
+ remote_network_lookup_by_uuid_ret *ret)
+{
+ virNetworkPtr net;
+
+ net = virNetworkLookupByUUID (conn, (unsigned char *) args->uuid);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_network (&ret->net, net);
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_set_autostart_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virNetworkSetAutostart (net, args->autostart) == -1) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNetworkUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_network_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNetworkPtr net;
+
+ net = get_nonnull_network (conn, args->net);
+ if (net == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virNetworkUndefine (net) == -1) {
+ virNetworkFree(net);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virNetworkFree(net);
+ return 0;
+}
+
+static int
+remoteDispatchNumOfDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_defined_networks_ret *ret)
+{
+
+ ret->num = virConnectNumOfDefinedNetworks (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNumOfDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_domains_ret *ret)
+{
+
+ ret->num = virConnectNumOfDomains (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNumOfNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_networks_ret *ret)
+{
+
+ ret->num = virConnectNumOfNetworks (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/*-------------------------------------------------------------*/
+static int
+remoteDispatchNumOfInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_interfaces_ret *ret)
+{
+
+ ret->num = virConnectNumOfInterfaces (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_INTERFACE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListInterfaces (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_len);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNumOfDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_defined_interfaces_ret *ret)
+{
+
+ ret->num = virConnectNumOfDefinedInterfaces (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_defined_interfaces_args *args,
+ remote_list_defined_interfaces_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListDefinedInterfaces (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_len);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret)
+{
+ virInterfacePtr iface;
+
+ iface = virInterfaceLookupByName (conn, args->name);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->iface, iface);
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByMacString (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_mac_string_args *args,
+ remote_interface_lookup_by_mac_string_ret *ret)
+{
+ virInterfacePtr iface;
+
+ iface = virInterfaceLookupByMACString (conn, args->mac);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->iface, iface);
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret)
+{
+ virInterfacePtr iface;
+
+ iface = get_nonnull_interface (conn, args->iface);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virInterfaceGetXMLDesc (iface, args->flags);
+ if (!ret->xml) {
+ virInterfaceFree(iface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret)
+{
+ virInterfacePtr iface;
+
+ iface = virInterfaceDefineXML (conn, args->xml, args->flags);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->iface, iface);
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr iface;
+
+ iface = get_nonnull_interface (conn, args->iface);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceUndefine (iface) == -1) {
+ virInterfaceFree(iface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr iface;
+
+ iface = get_nonnull_interface (conn, args->iface);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceCreate (iface, args->flags) == -1) {
+ virInterfaceFree(iface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(iface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr iface;
+
+ iface = get_nonnull_interface (conn, args->iface);
+ if (iface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceDestroy (iface, args->flags) == -1) {
+ virInterfaceFree(iface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(iface);
+ return 0;
+}
+
+/*-------------------------------------------------------------*/
+
+static int
+remoteDispatchAuthList (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_list_ret *ret)
+{
+ ret->types.types_len = 1;
+ if (VIR_ALLOC_N(ret->types.types_val, ret->types.types_len) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+ ret->types.types_val[0] = client->auth;
+ virMutexUnlock(&client->lock);
+
+ return 0;
+}
+
+
+#if HAVE_SASL
+/*
+ * NB, keep in sync with similar method in src/remote_internal.c
+ */
+static char *addrToString(remote_error *rerr,
+ struct sockaddr_storage *sa, socklen_t salen) {
+ char host[1024], port[20];
+ char *addr;
+ int err;
+
+ if ((err = getnameinfo((struct sockaddr *)sa, salen,
+ host, sizeof(host),
+ port, sizeof(port),
+ NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
+ remoteDispatchFormatError(rerr,
+ _("Cannot resolve address %d: %s"),
+ err, gai_strerror(err));
+ return NULL;
+ }
+
+ if (virAsprintf(&addr, "%s;%s", host, port) == -1) {
+ virReportOOMError(NULL);
+ return NULL;
+ }
+
+ return addr;
+}
+
+
+/*
+ * Initializes the SASL session in prepare for authentication
+ * and gives the client a list of allowed mechanisms to choose
+ *
+ * XXX callbacks for stuff like password verification ?
+ */
+static int
+remoteDispatchAuthSaslInit (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_sasl_init_ret *ret)
+{
+ const char *mechlist = NULL;
+ sasl_security_properties_t secprops;
+ int err;
+ struct sockaddr_storage sa;
+ socklen_t salen;
+ char *localAddr, *remoteAddr;
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ REMOTE_DEBUG("Initialize SASL auth %d", client->fd);
+ if (client->auth != REMOTE_AUTH_SASL ||
+ client->saslconn != NULL) {
+ VIR_ERROR0(_("client tried invalid SASL init request"));
+ goto authfail;
+ }
+
+ /* Get local address in form IPADDR:PORT */
+ salen = sizeof(sa);
+ if (getsockname(client->fd, (struct sockaddr*)&sa, &salen) < 0) {
+ char ebuf[1024];
+ remoteDispatchFormatError(rerr,
+ _("failed to get sock address: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ goto error;
+ }
+ if ((localAddr = addrToString(rerr, &sa, salen)) == NULL) {
+ goto error;
+ }
+
+ /* Get remote address in form IPADDR:PORT */
+ salen = sizeof(sa);
+ if (getpeername(client->fd, (struct sockaddr*)&sa, &salen) < 0) {
+ char ebuf[1024];
+ remoteDispatchFormatError(rerr, _("failed to get peer address: %s"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ VIR_FREE(localAddr);
+ goto error;
+ }
+ if ((remoteAddr = addrToString(rerr, &sa, salen)) == NULL) {
+ VIR_FREE(localAddr);
+ goto error;
+ }
+
+ err = sasl_server_new("libvirt",
+ NULL, /* FQDN - just delegates to gethostname */
+ NULL, /* User realm */
+ localAddr,
+ remoteAddr,
+ NULL, /* XXX Callbacks */
+ SASL_SUCCESS_DATA,
+ &client->saslconn);
+ VIR_FREE(localAddr);
+ VIR_FREE(remoteAddr);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("sasl context setup failed %d (%s)"),
+ err, sasl_errstring(err, NULL, NULL));
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ /* Inform SASL that we've got an external SSF layer from TLS */
+ if (client->type == QEMUD_SOCK_TYPE_TLS) {
+ gnutls_cipher_algorithm_t cipher;
+ sasl_ssf_t ssf;
+
+ cipher = gnutls_cipher_get(client->tlssession);
+ if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
+ VIR_ERROR0(_("cannot get TLS cipher size"));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+ ssf *= 8; /* tls key size is bytes, sasl wants bits */
+
+ err = sasl_setprop(client->saslconn, SASL_SSF_EXTERNAL, &ssf);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("cannot set SASL external SSF %d (%s)"),
+ err, sasl_errstring(err, NULL, NULL));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+ }
+
+ memset (&secprops, 0, sizeof secprops);
+ if (client->type == QEMUD_SOCK_TYPE_TLS ||
+ client->type == QEMUD_SOCK_TYPE_UNIX) {
+ /* If we've got TLS or UNIX domain sock, we don't care about SSF */
+ secprops.min_ssf = 0;
+ secprops.max_ssf = 0;
+ secprops.maxbufsize = 8192;
+ secprops.security_flags = 0;
+ } else {
+ /* Plain TCP, better get an SSF layer */
+ secprops.min_ssf = 56; /* Good enough to require kerberos */
+ secprops.max_ssf = 100000; /* Arbitrary big number */
+ secprops.maxbufsize = 8192;
+ /* Forbid any anonymous or trivially crackable auth */
+ secprops.security_flags =
+ SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
+ }
+
+ err = sasl_setprop(client->saslconn, SASL_SEC_PROPS, &secprops);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("cannot set SASL security props %d (%s)"),
+ err, sasl_errstring(err, NULL, NULL));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ err = sasl_listmech(client->saslconn,
+ NULL, /* Don't need to set user */
+ "", /* Prefix */
+ ",", /* Separator */
+ "", /* Suffix */
+ &mechlist,
+ NULL,
+ NULL);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("cannot list SASL mechanisms %d (%s)"),
+ err, sasl_errdetail(client->saslconn));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+ REMOTE_DEBUG("Available mechanisms for client: '%s'", mechlist);
+ ret->mechlist = strdup(mechlist);
+ if (!ret->mechlist) {
+ VIR_ERROR0(_("cannot allocate mechlist"));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ virMutexUnlock(&client->lock);
+ return 0;
+
+authfail:
+ remoteDispatchAuthError(rerr);
+error:
+ virMutexUnlock(&client->lock);
+ return -1;
+}
+
+
+/* We asked for an SSF layer, so sanity check that we actually
+ * got what we asked for */
+static int
+remoteSASLCheckSSF (struct qemud_client *client,
+ remote_error *rerr) {
+ const void *val;
+ int err, ssf;
+
+ if (client->type == QEMUD_SOCK_TYPE_TLS ||
+ client->type == QEMUD_SOCK_TYPE_UNIX)
+ return 0; /* TLS or UNIX domain sockets trivially OK */
+
+ err = sasl_getprop(client->saslconn, SASL_SSF, &val);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("cannot query SASL ssf on connection %d (%s)"),
+ err, sasl_errstring(err, NULL, NULL));
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+ }
+ ssf = *(const int *)val;
+ REMOTE_DEBUG("negotiated an SSF of %d", ssf);
+ if (ssf < 56) { /* 56 is good for Kerberos */
+ VIR_ERROR(_("negotiated SSF %d was not strong enough"), ssf);
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+ }
+
+ /* Only setup for read initially, because we're about to send an RPC
+ * reply which must be in plain text. When the next incoming RPC
+ * arrives, we'll switch on writes too
+ *
+ * cf qemudClientReadSASL in qemud.c
+ */
+ client->saslSSF = QEMUD_SASL_SSF_READ;
+
+ /* We have a SSF !*/
+ return 0;
+}
+
+static int
+remoteSASLCheckAccess (struct qemud_server *server,
+ struct qemud_client *client,
+ remote_error *rerr) {
+ const void *val;
+ int err;
+ char **wildcards;
+
+ err = sasl_getprop(client->saslconn, SASL_USERNAME, &val);
+ if (err != SASL_OK) {
+ VIR_ERROR(_("cannot query SASL username on connection %d (%s)"),
+ err, sasl_errstring(err, NULL, NULL));
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+ }
+ if (val == NULL) {
+ VIR_ERROR0(_("no client username was found"));
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+ }
+ REMOTE_DEBUG("SASL client username %s", (const char *)val);
+
+ client->saslUsername = strdup((const char*)val);
+ if (client->saslUsername == NULL) {
+ VIR_ERROR0(_("out of memory copying username"));
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+ }
+
+ /* If the list is not set, allow any DN. */
+ wildcards = server->saslUsernameWhitelist;
+ if (!wildcards)
+ return 0; /* No ACL, allow all */
+
+ while (*wildcards) {
+ if (fnmatch (*wildcards, client->saslUsername, 0) == 0)
+ return 0; /* Allowed */
+ wildcards++;
+ }
+
+ /* Denied */
+ VIR_ERROR(_("SASL client %s not allowed in whitelist"), client->saslUsername);
+ remoteDispatchAuthError(rerr);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ return -1;
+}
+
+
+/*
+ * This starts the SASL authentication negotiation.
+ */
+static int
+remoteDispatchAuthSaslStart (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_auth_sasl_start_args *args,
+ remote_auth_sasl_start_ret *ret)
+{
+ const char *serverout;
+ unsigned int serveroutlen;
+ int err;
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ REMOTE_DEBUG("Start SASL auth %d", client->fd);
+ if (client->auth != REMOTE_AUTH_SASL ||
+ client->saslconn == NULL) {
+ VIR_ERROR0(_("client tried invalid SASL start request"));
+ goto authfail;
+ }
+
+ REMOTE_DEBUG("Using SASL mechanism %s. Data %d bytes, nil: %d",
+ args->mech, args->data.data_len, args->nil);
+ err = sasl_server_start(client->saslconn,
+ args->mech,
+ /* NB, distinction of NULL vs "" is *critical* in SASL */
+ args->nil ? NULL : args->data.data_val,
+ args->data.data_len,
+ &serverout,
+ &serveroutlen);
+ if (err != SASL_OK &&
+ err != SASL_CONTINUE) {
+ VIR_ERROR(_("sasl start failed %d (%s)"),
+ err, sasl_errdetail(client->saslconn));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+ if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
+ VIR_ERROR(_("sasl start reply data too long %d"), serveroutlen);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ /* NB, distinction of NULL vs "" is *critical* in SASL */
+ if (serverout) {
+ if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
+ remoteDispatchOOMError(rerr);
+ goto error;
+ }
+ memcpy(ret->data.data_val, serverout, serveroutlen);
+ } else {
+ ret->data.data_val = NULL;
+ }
+ ret->nil = serverout ? 0 : 1;
+ ret->data.data_len = serveroutlen;
+
+ REMOTE_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
+ if (err == SASL_CONTINUE) {
+ ret->complete = 0;
+ } else {
+ if (remoteSASLCheckSSF(client, rerr) < 0)
+ goto error;
+
+ /* Check username whitelist ACL */
+ if (remoteSASLCheckAccess(server, client, rerr) < 0)
+ goto error;
+
+ REMOTE_DEBUG("Authentication successful %d", client->fd);
+ ret->complete = 1;
+ client->auth = REMOTE_AUTH_NONE;
+ }
+
+ virMutexUnlock(&client->lock);
+ return 0;
+
+authfail:
+ remoteDispatchAuthError(rerr);
+error:
+ virMutexUnlock(&client->lock);
+ return -1;
+}
+
+
+static int
+remoteDispatchAuthSaslStep (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_auth_sasl_step_args *args,
+ remote_auth_sasl_step_ret *ret)
+{
+ const char *serverout;
+ unsigned int serveroutlen;
+ int err;
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ REMOTE_DEBUG("Step SASL auth %d", client->fd);
+ if (client->auth != REMOTE_AUTH_SASL ||
+ client->saslconn == NULL) {
+ VIR_ERROR0(_("client tried invalid SASL start request"));
+ goto authfail;
+ }
+
+ REMOTE_DEBUG("Using SASL Data %d bytes, nil: %d",
+ args->data.data_len, args->nil);
+ err = sasl_server_step(client->saslconn,
+ /* NB, distinction of NULL vs "" is *critical* in SASL */
+ args->nil ? NULL : args->data.data_val,
+ args->data.data_len,
+ &serverout,
+ &serveroutlen);
+ if (err != SASL_OK &&
+ err != SASL_CONTINUE) {
+ VIR_ERROR(_("sasl step failed %d (%s)"),
+ err, sasl_errdetail(client->saslconn));
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
+ VIR_ERROR(_("sasl step reply data too long %d"),
+ serveroutlen);
+ sasl_dispose(&client->saslconn);
+ client->saslconn = NULL;
+ goto authfail;
+ }
+
+ /* NB, distinction of NULL vs "" is *critical* in SASL */
+ if (serverout) {
+ if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
+ remoteDispatchOOMError(rerr);
+ goto error;
+ }
+ memcpy(ret->data.data_val, serverout, serveroutlen);
+ } else {
+ ret->data.data_val = NULL;
+ }
+ ret->nil = serverout ? 0 : 1;
+ ret->data.data_len = serveroutlen;
+
+ REMOTE_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
+ if (err == SASL_CONTINUE) {
+ ret->complete = 0;
+ } else {
+ if (remoteSASLCheckSSF(client, rerr) < 0)
+ goto error;
+
+ /* Check username whitelist ACL */
+ if (remoteSASLCheckAccess(server, client, rerr) < 0)
+ goto error;
+
+ REMOTE_DEBUG("Authentication successful %d", client->fd);
+ ret->complete = 1;
+ client->auth = REMOTE_AUTH_NONE;
+ }
+
+ virMutexUnlock(&client->lock);
+ return 0;
+
+authfail:
+ remoteDispatchAuthError(rerr);
+error:
+ virMutexUnlock(&client->lock);
+ return -1;
+}
+
+
+#else /* HAVE_SASL */
+static int
+remoteDispatchAuthSaslInit (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_sasl_init_ret *ret ATTRIBUTE_UNUSED)
+{
+ VIR_ERROR0(_("client tried unsupported SASL init request"));
+ remoteDispatchAuthError(rerr);
+ return -1;
+}
+
+static int
+remoteDispatchAuthSaslStart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_auth_sasl_start_args *args ATTRIBUTE_UNUSED,
+ remote_auth_sasl_start_ret *ret ATTRIBUTE_UNUSED)
+{
+ VIR_ERROR0(_("client tried unsupported SASL start request"));
+ remoteDispatchAuthError(rerr);
+ return -1;
+}
+
+static int
+remoteDispatchAuthSaslStep (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_auth_sasl_step_args *args ATTRIBUTE_UNUSED,
+ remote_auth_sasl_step_ret *ret ATTRIBUTE_UNUSED)
+{
+ VIR_ERROR0(_("client tried unsupported SASL step request"));
+ remoteDispatchAuthError(rerr);
+ return -1;
+}
+#endif /* HAVE_SASL */
+
+
+#if HAVE_POLKIT1
+static int
+remoteDispatchAuthPolkit (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_polkit_ret *ret)
+{
+ pid_t callerPid;
+ uid_t callerUid;
+ const char *action;
+ int status = -1;
+ char pidbuf[50];
+ int rv;
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ action = client->readonly ?
+ "org.libvirt.unix.monitor" :
+ "org.libvirt.unix.manage";
+
+ const char * const pkcheck [] = {
+ PKCHECK_PATH,
+ "--action-id", action,
+ "--process", pidbuf,
+ "--allow-user-interaction",
+ NULL
+ };
+
+ REMOTE_DEBUG("Start PolicyKit auth %d", client->fd);
+ if (client->auth != REMOTE_AUTH_POLKIT) {
+ VIR_ERROR0(_("client tried invalid PolicyKit init request"));
+ goto authfail;
+ }
+
+ if (qemudGetSocketIdentity(client->fd, &callerUid, &callerPid) < 0) {
+ VIR_ERROR0(_("cannot get peer socket identity"));
+ goto authfail;
+ }
+
+ VIR_INFO(_("Checking PID %d running as %d"), callerPid, callerUid);
+
+ rv = snprintf(pidbuf, sizeof pidbuf, "%d", callerPid);
+ if (rv < 0 || rv >= sizeof pidbuf) {
+ VIR_ERROR(_("Caller PID was too large %d"), callerPid);
+ goto authfail;
+ }
+
+ if (virRun(NULL, pkcheck, &status) < 0) {
+ VIR_ERROR(_("Cannot invoke %s"), PKCHECK_PATH);
+ goto authfail;
+ }
+ if (status != 0) {
+ VIR_ERROR(_("Policy kit denied action %s from pid %d, uid %d, result: %d\n"),
+ action, callerPid, callerUid, status);
+ goto authfail;
+ }
+ VIR_INFO(_("Policy allowed action %s from pid %d, uid %d"),
+ action, callerPid, callerUid);
+ ret->complete = 1;
+ client->auth = REMOTE_AUTH_NONE;
+
+ virMutexUnlock(&client->lock);
+ return 0;
+
+authfail:
+ remoteDispatchAuthError(rerr);
+ virMutexUnlock(&client->lock);
+ return -1;
+}
+#elif HAVE_POLKIT0
+static int
+remoteDispatchAuthPolkit (struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_polkit_ret *ret)
+{
+ pid_t callerPid;
+ uid_t callerUid;
+ PolKitCaller *pkcaller = NULL;
+ PolKitAction *pkaction = NULL;
+ PolKitContext *pkcontext = NULL;
+ PolKitError *pkerr = NULL;
+ PolKitResult pkresult;
+ DBusError err;
+ const char *action;
+
+ virMutexLock(&server->lock);
+ virMutexLock(&client->lock);
+ virMutexUnlock(&server->lock);
+
+ action = client->readonly ?
+ "org.libvirt.unix.monitor" :
+ "org.libvirt.unix.manage";
+
+ REMOTE_DEBUG("Start PolicyKit auth %d", client->fd);
+ if (client->auth != REMOTE_AUTH_POLKIT) {
+ VIR_ERROR0(_("client tried invalid PolicyKit init request"));
+ goto authfail;
+ }
+
+ if (qemudGetSocketIdentity(client->fd, &callerUid, &callerPid) < 0) {
+ VIR_ERROR0(_("cannot get peer socket identity"));
+ goto authfail;
+ }
+
+ VIR_INFO(_("Checking PID %d running as %d"), callerPid, callerUid);
+ dbus_error_init(&err);
+ if (!(pkcaller = polkit_caller_new_from_pid(server->sysbus,
+ callerPid, &err))) {
+ VIR_ERROR(_("Failed to lookup policy kit caller: %s"), err.message);
+ dbus_error_free(&err);
+ goto authfail;
+ }
+
+ if (!(pkaction = polkit_action_new())) {
+ char ebuf[1024];
+ VIR_ERROR(_("Failed to create polkit action %s\n"),
+ virStrerror(errno, ebuf, sizeof ebuf));
+ polkit_caller_unref(pkcaller);
+ goto authfail;
+ }
+ polkit_action_set_action_id(pkaction, action);
+
+ if (!(pkcontext = polkit_context_new()) ||
+ !polkit_context_init(pkcontext, &pkerr)) {
+ char ebuf[1024];
+ VIR_ERROR(_("Failed to create polkit context %s\n"),
+ (pkerr ? polkit_error_get_error_message(pkerr)
+ : virStrerror(errno, ebuf, sizeof ebuf)));
+ if (pkerr)
+ polkit_error_free(pkerr);
+ polkit_caller_unref(pkcaller);
+ polkit_action_unref(pkaction);
+ dbus_error_free(&err);
+ goto authfail;
+ }
+
+#if HAVE_POLKIT_CONTEXT_IS_CALLER_AUTHORIZED
+ pkresult = polkit_context_is_caller_authorized(pkcontext,
+ pkaction,
+ pkcaller,
+ 0,
+ &pkerr);
+ if (pkerr && polkit_error_is_set(pkerr)) {
+ VIR_ERROR(_("Policy kit failed to check authorization %d %s"),
+ polkit_error_get_error_code(pkerr),
+ polkit_error_get_error_message(pkerr));
+ goto authfail;
+ }
+#else
+ pkresult = polkit_context_can_caller_do_action(pkcontext,
+ pkaction,
+ pkcaller);
+#endif
+ polkit_context_unref(pkcontext);
+ polkit_caller_unref(pkcaller);
+ polkit_action_unref(pkaction);
+ if (pkresult != POLKIT_RESULT_YES) {
+ VIR_ERROR(_("Policy kit denied action %s from pid %d, uid %d, result: %s\n"),
+ action, callerPid, callerUid,
+ polkit_result_to_string_representation(pkresult));
+ goto authfail;
+ }
+ VIR_INFO(_("Policy allowed action %s from pid %d, uid %d, result %s"),
+ action, callerPid, callerUid,
+ polkit_result_to_string_representation(pkresult));
+ ret->complete = 1;
+ client->auth = REMOTE_AUTH_NONE;
+
+ virMutexUnlock(&client->lock);
+ return 0;
+
+authfail:
+ remoteDispatchAuthError(rerr);
+ virMutexUnlock(&client->lock);
+ return -1;
+}
+
+#else /* !HAVE_POLKIT0 & !HAVE_POLKIT1*/
+
+static int
+remoteDispatchAuthPolkit (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_auth_polkit_ret *ret ATTRIBUTE_UNUSED)
+{
+ VIR_ERROR0(_("client tried unsupported PolicyKit init request"));
+ remoteDispatchAuthError(rerr);
+ return -1;
+}
+#endif /* HAVE_POLKIT1 */
+
+
+/***************************************************************
+ * STORAGE POOL APIS
+ ***************************************************************/
+
+
+static int
+remoteDispatchListDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_defined_storage_pools_args *args,
+ remote_list_defined_storage_pools_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr, "%s",
+ _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListDefinedStoragePools (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_storage_pools_args *args,
+ remote_list_storage_pools_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListStoragePools (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchFindStoragePoolSources (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_find_storage_pool_sources_args *args,
+ remote_find_storage_pool_sources_ret *ret)
+{
+ ret->xml =
+ virConnectFindStoragePoolSources (conn,
+ args->type,
+ args->srcSpec ? *args->srcSpec : NULL,
+ args->flags);
+ if (ret->xml == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolCreate (pool, args->flags) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_create_xml_args *args,
+ remote_storage_pool_create_xml_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = virStoragePoolCreateXML (conn, args->xml, args->flags);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_pool (&ret->pool, pool);
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_define_xml_args *args,
+ remote_storage_pool_define_xml_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = virStoragePoolDefineXML (conn, args->xml, args->flags);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_pool (&ret->pool, pool);
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolBuild (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_build_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolBuild (pool, args->flags) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolDestroy (pool) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_delete_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolDelete (pool, args->flags) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolRefresh (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_refresh_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolRefresh (pool, args->flags) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_get_info_args *args,
+ remote_storage_pool_get_info_ret *ret)
+{
+ virStoragePoolPtr pool;
+ virStoragePoolInfo info;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolGetInfo (pool, &info) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->state = info.state;
+ ret->capacity = info.capacity;
+ ret->allocation = info.allocation;
+ ret->available = info.available;
+
+ virStoragePoolFree(pool);
+
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_dump_xml_args *args,
+ remote_storage_pool_dump_xml_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virStoragePoolGetXMLDesc (pool, args->flags);
+ if (!ret->xml) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_get_autostart_args *args,
+ remote_storage_pool_get_autostart_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolGetAutostart (pool, &ret->autostart) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_lookup_by_name_args *args,
+ remote_storage_pool_lookup_by_name_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = virStoragePoolLookupByName (conn, args->name);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_pool (&ret->pool, pool);
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_lookup_by_uuid_args *args,
+ remote_storage_pool_lookup_by_uuid_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = virStoragePoolLookupByUUID (conn, (unsigned char *) args->uuid);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_pool (&ret->pool, pool);
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolLookupByVolume (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_lookup_by_volume_args *args,
+ remote_storage_pool_lookup_by_volume_ret *ret)
+{
+ virStoragePoolPtr pool;
+ virStorageVolPtr vol;
+
+ vol = get_nonnull_storage_vol (conn, args->vol);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ pool = virStoragePoolLookupByVolume (vol);
+ virStorageVolFree(vol);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_pool (&ret->pool, pool);
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_set_autostart_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolSetAutostart (pool, args->autostart) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStoragePoolUndefine (pool) == -1) {
+ virStoragePoolFree(pool);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStoragePoolFree(pool);
+ return 0;
+}
+
+static int
+remoteDispatchNumOfStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_storage_pools_ret *ret)
+{
+
+ ret->num = virConnectNumOfStoragePools (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchNumOfDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_defined_storage_pools_ret *ret)
+{
+
+ ret->num = virConnectNumOfDefinedStoragePools (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchStoragePoolListVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_list_volumes_args *args,
+ remote_storage_pool_list_volumes_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ if (args->maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ virStoragePoolFree(pool);
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virStoragePoolListVolumes (pool,
+ ret->names.names_val, args->maxnames);
+ virStoragePoolFree(pool);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchStoragePoolNumOfVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_pool_num_of_volumes_args *args,
+ remote_storage_pool_num_of_volumes_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->num = virStoragePoolNumOfVolumes (pool);
+ virStoragePoolFree(pool);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/***************************************************************
+ * STORAGE VOL APIS
+ ***************************************************************/
+
+
+
+static int
+remoteDispatchStorageVolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_create_xml_args *args,
+ remote_storage_vol_create_xml_ret *ret)
+{
+ virStoragePoolPtr pool;
+ virStorageVolPtr vol;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ vol = virStorageVolCreateXML (pool, args->xml, args->flags);
+ virStoragePoolFree(pool);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_vol (&ret->vol, vol);
+ virStorageVolFree(vol);
+ return 0;
+}
+
+static int
+remoteDispatchStorageVolCreateXmlFrom (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_create_xml_from_args *args,
+ remote_storage_vol_create_xml_from_ret *ret)
+{
+ virStoragePoolPtr pool;
+ virStorageVolPtr clonevol, newvol;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ clonevol = get_nonnull_storage_vol (conn, args->clonevol);
+ if (clonevol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ newvol = virStorageVolCreateXMLFrom (pool, args->xml, clonevol,
+ args->flags);
+ if (newvol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_vol (&ret->vol, newvol);
+ virStorageVolFree(newvol);
+ return 0;
+}
+
+static int
+remoteDispatchStorageVolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_delete_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virStorageVolPtr vol;
+
+ vol = get_nonnull_storage_vol (conn, args->vol);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStorageVolDelete (vol, args->flags) == -1) {
+ virStorageVolFree(vol);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStorageVolFree(vol);
+ return 0;
+}
+
+static int
+remoteDispatchStorageVolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_get_info_args *args,
+ remote_storage_vol_get_info_ret *ret)
+{
+ virStorageVolPtr vol;
+ virStorageVolInfo info;
+
+ vol = get_nonnull_storage_vol (conn, args->vol);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virStorageVolGetInfo (vol, &info) == -1) {
+ virStorageVolFree(vol);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->type = info.type;
+ ret->capacity = info.capacity;
+ ret->allocation = info.allocation;
+
+ virStorageVolFree(vol);
+
+ return 0;
+}
+
+static int
+remoteDispatchStorageVolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_dump_xml_args *args,
+ remote_storage_vol_dump_xml_ret *ret)
+{
+ virStorageVolPtr vol;
+
+ vol = get_nonnull_storage_vol (conn, args->vol);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virStorageVolGetXMLDesc (vol, args->flags);
+ if (!ret->xml) {
+ virStorageVolFree(vol);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStorageVolFree(vol);
+ return 0;
+}
+
+
+static int
+remoteDispatchStorageVolGetPath (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_get_path_args *args,
+ remote_storage_vol_get_path_ret *ret)
+{
+ virStorageVolPtr vol;
+
+ vol = get_nonnull_storage_vol (conn, args->vol);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->name = virStorageVolGetPath (vol);
+ if (!ret->name) {
+ virStorageVolFree(vol);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virStorageVolFree(vol);
+ return 0;
+}
+
+
+static int
+remoteDispatchStorageVolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_lookup_by_name_args *args,
+ remote_storage_vol_lookup_by_name_ret *ret)
+{
+ virStoragePoolPtr pool;
+ virStorageVolPtr vol;
+
+ pool = get_nonnull_storage_pool (conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ vol = virStorageVolLookupByName (pool, args->name);
+ virStoragePoolFree(pool);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_vol (&ret->vol, vol);
+ virStorageVolFree(vol);
+ return 0;
+}
+
+static int
+remoteDispatchStorageVolLookupByKey (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_lookup_by_key_args *args,
+ remote_storage_vol_lookup_by_key_ret *ret)
+{
+ virStorageVolPtr vol;
+
+ vol = virStorageVolLookupByKey (conn, args->key);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_vol (&ret->vol, vol);
+ virStorageVolFree(vol);
+ return 0;
+}
+
+
+static int
+remoteDispatchStorageVolLookupByPath (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_storage_vol_lookup_by_path_args *args,
+ remote_storage_vol_lookup_by_path_ret *ret)
+{
+ virStorageVolPtr vol;
+
+ vol = virStorageVolLookupByPath (conn, args->path);
+ if (vol == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_storage_vol (&ret->vol, vol);
+ virStorageVolFree(vol);
+ return 0;
+}
+
+
+/***************************************************************
+ * NODE INFO APIS
+ **************************************************************/
+
+static int
+remoteDispatchNodeNumOfDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_num_of_devices_args *args,
+ remote_node_num_of_devices_ret *ret)
+{
+ CHECK_CONN(client);
+
+ ret->num = virNodeNumOfDevices (conn,
+ args->cap ? *args->cap : NULL,
+ args->flags);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeListDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_list_devices_args *args,
+ remote_node_list_devices_ret *ret)
+{
+ CHECK_CONN(client);
+
+ if (args->maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
+ remoteDispatchFormatError(rerr,
+ "%s", _("maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virNodeListDevices (conn,
+ args->cap ? *args->cap : NULL,
+ ret->names.names_val, args->maxnames, args->flags);
+ if (ret->names.names_len == -1) {
+ remoteDispatchConnError(rerr, conn);
+ VIR_FREE(ret->names.names_val);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_lookup_by_name_args *args,
+ remote_node_device_lookup_by_name_ret *ret)
+{
+ virNodeDevicePtr dev;
+
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName (conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_node_device (&ret->dev, dev);
+ virNodeDeviceFree(dev);
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_dump_xml_args *args,
+ remote_node_device_dump_xml_ret *ret)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virNodeDeviceGetXMLDesc (dev, args->flags);
+ if (!ret->xml) {
+ remoteDispatchConnError(rerr, conn);
+ virNodeDeviceFree(dev);
+ return -1;
+ }
+ virNodeDeviceFree(dev);
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceGetParent (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_get_parent_args *args,
+ remote_node_device_get_parent_ret *ret)
+{
+ virNodeDevicePtr dev;
+ const char *parent;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ parent = virNodeDeviceGetParent(dev);
+
+ if (parent == NULL) {
+ ret->parent = NULL;
+ } else {
+ /* remoteDispatchClientRequest will free this. */
+ char **parent_p;
+ if (VIR_ALLOC(parent_p) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ *parent_p = strdup(parent);
+ if (*parent_p == NULL) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+ ret->parent = parent_p;
+ }
+
+ virNodeDeviceFree(dev);
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceNumOfCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_num_of_caps_args *args,
+ remote_node_device_num_of_caps_ret *ret)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ ret->num = virNodeDeviceNumOfCaps(dev);
+ if (ret->num < 0) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virNodeDeviceFree(dev);
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceListCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_list_caps_args *args,
+ remote_node_device_list_caps_ret *ret)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ if (args->maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
+ remoteDispatchFormatError(rerr,
+ "%s", _("maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virNodeDeviceListCaps (dev, ret->names.names_val,
+ args->maxnames);
+ if (ret->names.names_len == -1) {
+ remoteDispatchConnError(rerr, conn);
+ VIR_FREE(ret->names.names_val);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceDettach (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_dettach_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ if (virNodeDeviceDettach(dev) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceReAttach (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_re_attach_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ if (virNodeDeviceReAttach(dev) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceReset (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_reset_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNodeDevicePtr dev;
+ CHECK_CONN(client);
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ if (virNodeDeviceReset(dev) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceCreateXml(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_create_xml_args *args,
+ remote_node_device_create_xml_ret *ret)
+{
+ virNodeDevicePtr dev;
+
+ dev = virNodeDeviceCreateXML (conn, args->xml_desc, args->flags);
+ if (dev == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_node_device (&ret->dev, dev);
+ virNodeDeviceFree(dev);
+
+ return 0;
+}
+
+
+static int
+remoteDispatchNodeDeviceDestroy(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_node_device_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virNodeDevicePtr dev;
+
+ dev = virNodeDeviceLookupByName(conn, args->name);
+ if (dev == NULL) {
+ remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
+ return -1;
+ }
+
+ if (virNodeDeviceDestroy(dev) == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+/***************************
+ * Register / deregister events
+ ***************************/
+static int
+remoteDispatchDomainEventsRegister (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr ATTRIBUTE_UNUSED,
+ void *args ATTRIBUTE_UNUSED,
+ remote_domain_events_register_ret *ret ATTRIBUTE_UNUSED)
+{
+ CHECK_CONN(client);
+
+ /* Register event delivery callback */
+ REMOTE_DEBUG("%s","Registering to relay remote events");
+ virConnectDomainEventRegister(conn, remoteRelayDomainEvent, client, NULL);
+
+ if(ret)
+ ret->cb_registered = 1;
+ return 0;
+}
+
+static int
+remoteDispatchDomainEventsDeregister (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr ATTRIBUTE_UNUSED,
+ void *args ATTRIBUTE_UNUSED,
+ remote_domain_events_deregister_ret *ret ATTRIBUTE_UNUSED)
+{
+ CHECK_CONN(client);
+
+ /* Deregister event delivery callback */
+ REMOTE_DEBUG("%s","Deregistering to relay remote events");
+ virConnectDomainEventDeregister(conn, remoteRelayDomainEvent);
+
+ if(ret)
+ ret->cb_registered = 0;
+ return 0;
+}
+
+static void
+remoteDispatchDomainEventSend (struct qemud_client *client,
+ remote_domain_event_msg *data)
+{
+ struct qemud_client_message *msg = NULL;
+ XDR xdr;
+ unsigned int len;
+
+ if (VIR_ALLOC(msg) < 0)
+ return;
+
+ msg->hdr.prog = REMOTE_PROGRAM;
+ msg->hdr.vers = REMOTE_PROTOCOL_VERSION;
+ msg->hdr.proc = REMOTE_PROC_DOMAIN_EVENT;
+ msg->hdr.type = REMOTE_MESSAGE;
+ msg->hdr.serial = 1;
+ msg->hdr.status = REMOTE_OK;
+
+ if (remoteEncodeClientMessageHeader(msg) < 0)
+ goto error;
+
+ /* Serialise the return header and event. */
+ xdrmem_create (&xdr,
+ msg->buffer + msg->bufferOffset,
+ msg->bufferLength - msg->bufferOffset,
+ XDR_ENCODE);
+
+ if (!xdr_remote_domain_event_msg(&xdr, data))
+ goto xdr_error;
+
+
+ /* Update 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;
+
+ /* Send it. */
+ msg->async = 1;
+ msg->bufferLength = len;
+ msg->bufferOffset = 0;
+ qemudClientMessageQueuePush(&client->tx, msg);
+ qemudUpdateClientEvent(client);
+
+ xdr_destroy (&xdr);
+ return;
+
+xdr_error:
+ xdr_destroy(&xdr);
+error:
+ VIR_FREE(msg);
+}
+
+static int
+remoteDispatchNumOfSecrets (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_secrets_ret *ret)
+{
+ ret->num = virConnectNumOfSecrets (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListSecrets (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_list_secrets_args *args,
+ remote_list_secrets_ret *ret)
+{
+ if (args->maxuuids > REMOTE_SECRET_UUID_LIST_MAX) {
+ remoteDispatchFormatError (err, "%s",
+ _("maxuuids > REMOTE_SECRET_UUID_LIST_MAX"));
+ return -1;
+ }
+
+ if (VIR_ALLOC_N (ret->uuids.uuids_val, args->maxuuids) < 0) {
+ remoteDispatchOOMError (err);
+ return -1;
+ }
+
+ ret->uuids.uuids_len = virConnectListSecrets (conn, ret->uuids.uuids_val,
+ args->maxuuids);
+ if (ret->uuids.uuids_len == -1) {
+ VIR_FREE (ret->uuids.uuids_val);
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchSecretDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_define_xml_args *args,
+ remote_secret_define_xml_ret *ret)
+{
+ virSecretPtr secret;
+
+ secret = virSecretDefineXML (conn, args->xml, args->flags);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ make_nonnull_secret (&ret->secret, secret);
+ virSecretFree (secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretGetValue (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_get_value_args *args,
+ remote_secret_get_value_ret *ret)
+{
+ virSecretPtr secret;
+ size_t value_size;
+ unsigned char *value;
+
+ secret = get_nonnull_secret (conn, args->secret);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ value = virSecretGetValue (secret, &value_size, args->flags);
+ if (value == NULL) {
+ remoteDispatchConnError (err, conn);
+ virSecretFree(secret);
+ return -1;
+ }
+
+ ret->value.value_len = value_size;
+ ret->value.value_val = (char *)value;
+ virSecretFree(secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_get_xml_desc_args *args,
+ remote_secret_get_xml_desc_ret *ret)
+{
+ virSecretPtr secret;
+
+ secret = get_nonnull_secret (conn, args->secret);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+ ret->xml = virSecretGetXMLDesc (secret, args->flags);
+ if (ret->xml == NULL) {
+ remoteDispatchConnError (err, conn);
+ virSecretFree(secret);
+ return -1;
+ }
+ virSecretFree(secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_lookup_by_uuid_args *args,
+ remote_secret_lookup_by_uuid_ret *ret)
+{
+ virSecretPtr secret;
+
+ secret = virSecretLookupByUUID (conn, (unsigned char *)args->uuid);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ make_nonnull_secret (&ret->secret, secret);
+ virSecretFree (secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretSetValue (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_set_value_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virSecretPtr secret;
+
+ secret = get_nonnull_secret (conn, args->secret);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+ if (virSecretSetValue (secret, (const unsigned char *)args->value.value_val,
+ args->value.value_len, args->flags) < 0) {
+ remoteDispatchConnError (err, conn);
+ virSecretFree(secret);
+ return -1;
+ }
+
+ virSecretFree(secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virSecretPtr secret;
+
+ secret = get_nonnull_secret (conn, args->secret);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+ if (virSecretUndefine (secret) < 0) {
+ remoteDispatchConnError (err, conn);
+ virSecretFree(secret);
+ return -1;
+ }
+
+ virSecretFree(secret);
+ return 0;
+}
+
+static int
+remoteDispatchSecretLookupByUsage (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn, remote_error *err,
+ remote_secret_lookup_by_usage_args *args,
+ remote_secret_lookup_by_usage_ret *ret)
+{
+ virSecretPtr secret;
+
+ secret = virSecretLookupByUsage (conn, args->usageType, args->usageID);
+ if (secret == NULL) {
+ remoteDispatchConnError (err, conn);
+ return -1;
+ }
+
+ make_nonnull_secret (&ret->secret, secret);
+ virSecretFree (secret);
+ return 0;
+}
+
+
+/*----- Helpers. -----*/
+
+/* get_nonnull_domain and get_nonnull_network turn an on-wire
+ * (name, uuid) pair into virDomainPtr or virNetworkPtr object.
+ * virDomainPtr or virNetworkPtr cannot be NULL.
+ *
+ * NB. If these return NULL then the caller must return an error.
+ */
+static virDomainPtr
+get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain)
+{
+ virDomainPtr dom;
+ dom = virGetDomain (conn, domain.name, BAD_CAST domain.uuid);
+ /* Should we believe the domain.id sent by the client? Maybe
+ * this should be a check rather than an assignment? XXX
+ */
+ if (dom) dom->id = domain.id;
+ return dom;
+}
+
+static virNetworkPtr
+get_nonnull_network (virConnectPtr conn, remote_nonnull_network network)
+{
+ return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
+}
+
+static virInterfacePtr
+get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface iface)
+{
+ return virGetInterface (conn, iface.name, iface.mac);
+}
+
+static virStoragePoolPtr
+get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
+{
+ return virGetStoragePool (conn, pool.name, BAD_CAST pool.uuid);
+}
+
+static virStorageVolPtr
+get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol)
+{
+ virStorageVolPtr ret;
+ ret = virGetStorageVol (conn, vol.pool, vol.name, vol.key);
+ return ret;
+}
+
+static virSecretPtr
+get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret)
+{
+ return virGetSecret (conn, BAD_CAST secret.uuid, secret.usageType, secret.usageID);
+}
+
+/* Make remote_nonnull_domain and remote_nonnull_network. */
+static void
+make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
+{
+ dom_dst->id = dom_src->id;
+ dom_dst->name = strdup (dom_src->name);
+ memcpy (dom_dst->uuid, dom_src->uuid, VIR_UUID_BUFLEN);
+}
+
+static void
+make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src)
+{
+ net_dst->name = strdup (net_src->name);
+ memcpy (net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
+}
+
+static void
+make_nonnull_interface (remote_nonnull_interface *interface_dst,
+ virInterfacePtr interface_src)
+{
+ interface_dst->name = strdup (interface_src->name);
+ interface_dst->mac = strdup (interface_src->mac);
+}
+
+static void
+make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
+{
+ pool_dst->name = strdup (pool_src->name);
+ memcpy (pool_dst->uuid, pool_src->uuid, VIR_UUID_BUFLEN);
+}
+
+static void
+make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src)
+{
+ vol_dst->pool = strdup (vol_src->pool);
+ vol_dst->name = strdup (vol_src->name);
+ vol_dst->key = strdup (vol_src->key);
+}
+
+static void
+make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src)
+{
+ dev_dst->name = strdup(dev_src->name);
+}
+
+static void
+make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src)
+{
+ memcpy (secret_dst->uuid, secret_src->uuid, VIR_UUID_BUFLEN);
+ secret_dst->usageType = secret_src->usageType;
+ secret_dst->usageID = strdup (secret_src->usageID);
+}
--- /dev/null
+/*
+ * 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__ */
--- /dev/null
+/* 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;
--- /dev/null
+/* Automatically generated by remote_generate_stubs.pl.
+ * Do not edit this file. Any changes you make will be lost.
+ */
+
+static int remoteDispatchAuthList(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_auth_list_ret *ret);
+static int remoteDispatchAuthPolkit(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_auth_polkit_ret *ret);
+static int remoteDispatchAuthSaslInit(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_auth_sasl_init_ret *ret);
+static int remoteDispatchAuthSaslStart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_auth_sasl_start_args *args,
+ remote_auth_sasl_start_ret *ret);
+static int remoteDispatchAuthSaslStep(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_auth_sasl_step_args *args,
+ remote_auth_sasl_step_ret *ret);
+static int remoteDispatchClose(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ void *ret);
+static int remoteDispatchDomainAttachDevice(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_attach_device_args *args,
+ void *ret);
+static int remoteDispatchDomainBlockPeek(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_block_peek_args *args,
+ remote_domain_block_peek_ret *ret);
+static int remoteDispatchDomainBlockStats(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_block_stats_args *args,
+ remote_domain_block_stats_ret *ret);
+static int remoteDispatchDomainCoreDump(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_core_dump_args *args,
+ void *ret);
+static int remoteDispatchDomainCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_create_args *args,
+ void *ret);
+static int remoteDispatchDomainCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_create_xml_args *args,
+ remote_domain_create_xml_ret *ret);
+static int remoteDispatchDomainDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_define_xml_args *args,
+ remote_domain_define_xml_ret *ret);
+static int remoteDispatchDomainDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_destroy_args *args,
+ void *ret);
+static int remoteDispatchDomainDetachDevice(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_detach_device_args *args,
+ void *ret);
+static int remoteDispatchDomainDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_dump_xml_args *args,
+ remote_domain_dump_xml_ret *ret);
+static int remoteDispatchDomainEventsDeregister(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_domain_events_deregister_ret *ret);
+static int remoteDispatchDomainEventsRegister(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_domain_events_register_ret *ret);
+static int remoteDispatchDomainGetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_autostart_args *args,
+ remote_domain_get_autostart_ret *ret);
+static int remoteDispatchDomainGetInfo(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_info_args *args,
+ remote_domain_get_info_ret *ret);
+static int remoteDispatchDomainGetMaxMemory(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_max_memory_args *args,
+ remote_domain_get_max_memory_ret *ret);
+static int remoteDispatchDomainGetMaxVcpus(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_max_vcpus_args *args,
+ remote_domain_get_max_vcpus_ret *ret);
+static int remoteDispatchDomainGetOsType(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_os_type_args *args,
+ remote_domain_get_os_type_ret *ret);
+static int remoteDispatchDomainGetSchedulerParameters(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_scheduler_parameters_args *args,
+ remote_domain_get_scheduler_parameters_ret *ret);
+static int remoteDispatchDomainGetSchedulerType(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_scheduler_type_args *args,
+ remote_domain_get_scheduler_type_ret *ret);
+static int remoteDispatchDomainGetSecurityLabel(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_security_label_args *args,
+ remote_domain_get_security_label_ret *ret);
+static int remoteDispatchDomainGetVcpus(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_get_vcpus_args *args,
+ remote_domain_get_vcpus_ret *ret);
+static int remoteDispatchDomainInterfaceStats(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_interface_stats_args *args,
+ remote_domain_interface_stats_ret *ret);
+static int remoteDispatchDomainLookupById(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_lookup_by_id_args *args,
+ remote_domain_lookup_by_id_ret *ret);
+static int remoteDispatchDomainLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_lookup_by_name_args *args,
+ remote_domain_lookup_by_name_ret *ret);
+static int remoteDispatchDomainLookupByUuid(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_lookup_by_uuid_args *args,
+ remote_domain_lookup_by_uuid_ret *ret);
+static int remoteDispatchDomainMemoryPeek(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_memory_peek_args *args,
+ remote_domain_memory_peek_ret *ret);
+static int remoteDispatchDomainMigrateFinish(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_migrate_finish_args *args,
+ remote_domain_migrate_finish_ret *ret);
+static int remoteDispatchDomainMigrateFinish2(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_migrate_finish2_args *args,
+ remote_domain_migrate_finish2_ret *ret);
+static int remoteDispatchDomainMigratePerform(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_migrate_perform_args *args,
+ void *ret);
+static int remoteDispatchDomainMigratePrepare(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_migrate_prepare_args *args,
+ remote_domain_migrate_prepare_ret *ret);
+static int remoteDispatchDomainMigratePrepare2(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_migrate_prepare2_args *args,
+ remote_domain_migrate_prepare2_ret *ret);
+static int remoteDispatchDomainPinVcpu(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_pin_vcpu_args *args,
+ void *ret);
+static int remoteDispatchDomainReboot(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_reboot_args *args,
+ void *ret);
+static int remoteDispatchDomainRestore(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_restore_args *args,
+ void *ret);
+static int remoteDispatchDomainResume(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_resume_args *args,
+ void *ret);
+static int remoteDispatchDomainSave(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_save_args *args,
+ void *ret);
+static int remoteDispatchDomainSetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_set_autostart_args *args,
+ void *ret);
+static int remoteDispatchDomainSetMaxMemory(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_set_max_memory_args *args,
+ void *ret);
+static int remoteDispatchDomainSetMemory(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_set_memory_args *args,
+ void *ret);
+static int remoteDispatchDomainSetSchedulerParameters(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_set_scheduler_parameters_args *args,
+ void *ret);
+static int remoteDispatchDomainSetVcpus(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_set_vcpus_args *args,
+ void *ret);
+static int remoteDispatchDomainShutdown(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_shutdown_args *args,
+ void *ret);
+static int remoteDispatchDomainSuspend(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_suspend_args *args,
+ void *ret);
+static int remoteDispatchDomainUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_undefine_args *args,
+ void *ret);
+static int remoteDispatchDomainXmlFromNative(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_xml_from_native_args *args,
+ remote_domain_xml_from_native_ret *ret);
+static int remoteDispatchDomainXmlToNative(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_domain_xml_to_native_args *args,
+ remote_domain_xml_to_native_ret *ret);
+static int remoteDispatchFindStoragePoolSources(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_find_storage_pool_sources_args *args,
+ remote_find_storage_pool_sources_ret *ret);
+static int remoteDispatchGetCapabilities(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_get_capabilities_ret *ret);
+static int remoteDispatchGetHostname(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_get_hostname_ret *ret);
+static int remoteDispatchGetMaxVcpus(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_get_max_vcpus_args *args,
+ remote_get_max_vcpus_ret *ret);
+static int remoteDispatchGetType(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_get_type_ret *ret);
+static int remoteDispatchGetUri(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_get_uri_ret *ret);
+static int remoteDispatchGetVersion(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_get_version_ret *ret);
+static int remoteDispatchInterfaceCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_create_args *args,
+ void *ret);
+static int remoteDispatchInterfaceDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret);
+static int remoteDispatchInterfaceDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_destroy_args *args,
+ void *ret);
+static int remoteDispatchInterfaceGetXmlDesc(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret);
+static int remoteDispatchInterfaceLookupByMacString(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_mac_string_args *args,
+ remote_interface_lookup_by_mac_string_ret *ret);
+static int remoteDispatchInterfaceLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret);
+static int remoteDispatchInterfaceUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_undefine_args *args,
+ void *ret);
+static int remoteDispatchListDefinedDomains(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_defined_domains_args *args,
+ remote_list_defined_domains_ret *ret);
+static int remoteDispatchListDefinedInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_defined_interfaces_args *args,
+ remote_list_defined_interfaces_ret *ret);
+static int remoteDispatchListDefinedNetworks(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_defined_networks_args *args,
+ remote_list_defined_networks_ret *ret);
+static int remoteDispatchListDefinedStoragePools(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_defined_storage_pools_args *args,
+ remote_list_defined_storage_pools_ret *ret);
+static int remoteDispatchListDomains(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_domains_args *args,
+ remote_list_domains_ret *ret);
+static int remoteDispatchListInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret);
+static int remoteDispatchListNetworks(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_networks_args *args,
+ remote_list_networks_ret *ret);
+static int remoteDispatchListSecrets(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_secrets_args *args,
+ remote_list_secrets_ret *ret);
+static int remoteDispatchListStoragePools(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_storage_pools_args *args,
+ remote_list_storage_pools_ret *ret);
+static int remoteDispatchNetworkCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_create_args *args,
+ void *ret);
+static int remoteDispatchNetworkCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_create_xml_args *args,
+ remote_network_create_xml_ret *ret);
+static int remoteDispatchNetworkDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_define_xml_args *args,
+ remote_network_define_xml_ret *ret);
+static int remoteDispatchNetworkDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_destroy_args *args,
+ void *ret);
+static int remoteDispatchNetworkDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_dump_xml_args *args,
+ remote_network_dump_xml_ret *ret);
+static int remoteDispatchNetworkGetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_get_autostart_args *args,
+ remote_network_get_autostart_ret *ret);
+static int remoteDispatchNetworkGetBridgeName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_get_bridge_name_args *args,
+ remote_network_get_bridge_name_ret *ret);
+static int remoteDispatchNetworkLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_lookup_by_name_args *args,
+ remote_network_lookup_by_name_ret *ret);
+static int remoteDispatchNetworkLookupByUuid(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_lookup_by_uuid_args *args,
+ remote_network_lookup_by_uuid_ret *ret);
+static int remoteDispatchNetworkSetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_set_autostart_args *args,
+ void *ret);
+static int remoteDispatchNetworkUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_network_undefine_args *args,
+ void *ret);
+static int remoteDispatchNodeDeviceCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_create_xml_args *args,
+ remote_node_device_create_xml_ret *ret);
+static int remoteDispatchNodeDeviceDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_destroy_args *args,
+ void *ret);
+static int remoteDispatchNodeDeviceDettach(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_dettach_args *args,
+ void *ret);
+static int remoteDispatchNodeDeviceDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_dump_xml_args *args,
+ remote_node_device_dump_xml_ret *ret);
+static int remoteDispatchNodeDeviceGetParent(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_get_parent_args *args,
+ remote_node_device_get_parent_ret *ret);
+static int remoteDispatchNodeDeviceListCaps(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_list_caps_args *args,
+ remote_node_device_list_caps_ret *ret);
+static int remoteDispatchNodeDeviceLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_lookup_by_name_args *args,
+ remote_node_device_lookup_by_name_ret *ret);
+static int remoteDispatchNodeDeviceNumOfCaps(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_num_of_caps_args *args,
+ remote_node_device_num_of_caps_ret *ret);
+static int remoteDispatchNodeDeviceReAttach(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_re_attach_args *args,
+ void *ret);
+static int remoteDispatchNodeDeviceReset(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_device_reset_args *args,
+ void *ret);
+static int remoteDispatchNodeGetCellsFreeMemory(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_get_cells_free_memory_args *args,
+ remote_node_get_cells_free_memory_ret *ret);
+static int remoteDispatchNodeGetFreeMemory(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_node_get_free_memory_ret *ret);
+static int remoteDispatchNodeGetInfo(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_node_get_info_ret *ret);
+static int remoteDispatchNodeGetSecurityModel(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_node_get_security_model_ret *ret);
+static int remoteDispatchNodeListDevices(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_list_devices_args *args,
+ remote_node_list_devices_ret *ret);
+static int remoteDispatchNodeNumOfDevices(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_node_num_of_devices_args *args,
+ remote_node_num_of_devices_ret *ret);
+static int remoteDispatchNumOfDefinedDomains(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_defined_domains_ret *ret);
+static int remoteDispatchNumOfDefinedInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_defined_interfaces_ret *ret);
+static int remoteDispatchNumOfDefinedNetworks(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_defined_networks_ret *ret);
+static int remoteDispatchNumOfDefinedStoragePools(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_defined_storage_pools_ret *ret);
+static int remoteDispatchNumOfDomains(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_domains_ret *ret);
+static int remoteDispatchNumOfInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_interfaces_ret *ret);
+static int remoteDispatchNumOfNetworks(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_networks_ret *ret);
+static int remoteDispatchNumOfSecrets(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_secrets_ret *ret);
+static int remoteDispatchNumOfStoragePools(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_storage_pools_ret *ret);
+static int remoteDispatchOpen(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_open_args *args,
+ void *ret);
+static int remoteDispatchSecretDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_define_xml_args *args,
+ remote_secret_define_xml_ret *ret);
+static int remoteDispatchSecretGetValue(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_get_value_args *args,
+ remote_secret_get_value_ret *ret);
+static int remoteDispatchSecretGetXmlDesc(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_get_xml_desc_args *args,
+ remote_secret_get_xml_desc_ret *ret);
+static int remoteDispatchSecretLookupByUsage(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_lookup_by_usage_args *args,
+ remote_secret_lookup_by_usage_ret *ret);
+static int remoteDispatchSecretLookupByUuid(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_lookup_by_uuid_args *args,
+ remote_secret_lookup_by_uuid_ret *ret);
+static int remoteDispatchSecretSetValue(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_set_value_args *args,
+ void *ret);
+static int remoteDispatchSecretUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_secret_undefine_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolBuild(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_build_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_create_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_create_xml_args *args,
+ remote_storage_pool_create_xml_ret *ret);
+static int remoteDispatchStoragePoolDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_define_xml_args *args,
+ remote_storage_pool_define_xml_ret *ret);
+static int remoteDispatchStoragePoolDelete(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_delete_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_destroy_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_dump_xml_args *args,
+ remote_storage_pool_dump_xml_ret *ret);
+static int remoteDispatchStoragePoolGetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_get_autostart_args *args,
+ remote_storage_pool_get_autostart_ret *ret);
+static int remoteDispatchStoragePoolGetInfo(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_get_info_args *args,
+ remote_storage_pool_get_info_ret *ret);
+static int remoteDispatchStoragePoolListVolumes(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_list_volumes_args *args,
+ remote_storage_pool_list_volumes_ret *ret);
+static int remoteDispatchStoragePoolLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_lookup_by_name_args *args,
+ remote_storage_pool_lookup_by_name_ret *ret);
+static int remoteDispatchStoragePoolLookupByUuid(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_lookup_by_uuid_args *args,
+ remote_storage_pool_lookup_by_uuid_ret *ret);
+static int remoteDispatchStoragePoolLookupByVolume(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_lookup_by_volume_args *args,
+ remote_storage_pool_lookup_by_volume_ret *ret);
+static int remoteDispatchStoragePoolNumOfVolumes(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_num_of_volumes_args *args,
+ remote_storage_pool_num_of_volumes_ret *ret);
+static int remoteDispatchStoragePoolRefresh(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_refresh_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolSetAutostart(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_set_autostart_args *args,
+ void *ret);
+static int remoteDispatchStoragePoolUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_pool_undefine_args *args,
+ void *ret);
+static int remoteDispatchStorageVolCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_create_xml_args *args,
+ remote_storage_vol_create_xml_ret *ret);
+static int remoteDispatchStorageVolCreateXmlFrom(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_create_xml_from_args *args,
+ remote_storage_vol_create_xml_from_ret *ret);
+static int remoteDispatchStorageVolDelete(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_delete_args *args,
+ void *ret);
+static int remoteDispatchStorageVolDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_dump_xml_args *args,
+ remote_storage_vol_dump_xml_ret *ret);
+static int remoteDispatchStorageVolGetInfo(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_get_info_args *args,
+ remote_storage_vol_get_info_ret *ret);
+static int remoteDispatchStorageVolGetPath(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_get_path_args *args,
+ remote_storage_vol_get_path_ret *ret);
+static int remoteDispatchStorageVolLookupByKey(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_lookup_by_key_args *args,
+ remote_storage_vol_lookup_by_key_ret *ret);
+static int remoteDispatchStorageVolLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_lookup_by_name_args *args,
+ remote_storage_vol_lookup_by_name_ret *ret);
+static int remoteDispatchStorageVolLookupByPath(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_storage_vol_lookup_by_path_args *args,
+ remote_storage_vol_lookup_by_path_ret *ret);
+static int remoteDispatchSupportsFeature(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_supports_feature_args *args,
+ remote_supports_feature_ret *ret);
--- /dev/null
+/* 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;
--- /dev/null
+/* 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,
+},
--- /dev/null
+#!/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";
+ }
+ }
+}
--- /dev/null
+#include <config.h>
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "remote_protocol.h"
+#include "internal.h"
+#include <arpa/inet.h>
+
+bool_t
+xdr_remote_nonnull_string (XDR *xdrs, remote_nonnull_string *objp)
+{
+
+ if (!xdr_string (xdrs, objp, REMOTE_STRING_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_string (XDR *xdrs, remote_string *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_uuid (XDR *xdrs, remote_uuid objp)
+{
+
+ if (!xdr_opaque (xdrs, objp, VIR_UUID_BUFLEN))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_domain (XDR *xdrs, remote_nonnull_domain *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->id))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_network (XDR *xdrs, remote_nonnull_network *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_interface (XDR *xdrs, remote_nonnull_interface *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_storage_pool (XDR *xdrs, remote_nonnull_storage_pool *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_storage_vol (XDR *xdrs, remote_nonnull_storage_vol *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->key))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_node_device (XDR *xdrs, remote_nonnull_node_device *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_nonnull_secret (XDR *xdrs, remote_nonnull_secret *objp)
+{
+
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->usageType))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->usageID))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain (XDR *xdrs, remote_domain *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_domain), (xdrproc_t) xdr_remote_nonnull_domain))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network (XDR *xdrs, remote_network *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_network), (xdrproc_t) xdr_remote_nonnull_network))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool (XDR *xdrs, remote_storage_pool *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_pool), (xdrproc_t) xdr_remote_nonnull_storage_pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol (XDR *xdrs, remote_storage_vol *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_vol), (xdrproc_t) xdr_remote_nonnull_storage_vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device (XDR *xdrs, remote_node_device *objp)
+{
+
+ if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_node_device), (xdrproc_t) xdr_remote_nonnull_node_device))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_error (XDR *xdrs, remote_error *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->code))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->message))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->level))
+ return FALSE;
+ if (!xdr_remote_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->str1))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->str2))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->str3))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->int1))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->int2))
+ return FALSE;
+ if (!xdr_remote_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_type (XDR *xdrs, remote_auth_type *objp)
+{
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_vcpu_info (XDR *xdrs, remote_vcpu_info *objp)
+{
+
+ if (!xdr_u_int (xdrs, &objp->number))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->state))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->cpu_time))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->cpu))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_sched_param_value (XDR *xdrs, remote_sched_param_value *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->type))
+ return FALSE;
+ switch (objp->type) {
+ case VIR_DOMAIN_SCHED_FIELD_INT:
+ return FALSE;
+ break;
+ case VIR_DOMAIN_SCHED_FIELD_UINT:
+ if (!xdr_u_int (xdrs, &objp->remote_sched_param_value_u.ui))
+ return FALSE;
+ break;
+ case VIR_DOMAIN_SCHED_FIELD_LLONG:
+ if (!xdr_int64_t (xdrs, &objp->remote_sched_param_value_u.l))
+ return FALSE;
+ break;
+ case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+ if (!xdr_uint64_t (xdrs, &objp->remote_sched_param_value_u.ul))
+ return FALSE;
+ break;
+ case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+ if (!xdr_double (xdrs, &objp->remote_sched_param_value_u.d))
+ return FALSE;
+ break;
+ case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+ if (!xdr_int (xdrs, &objp->remote_sched_param_value_u.b))
+ return FALSE;
+ break;
+ default:
+ return FALSE;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_remote_sched_param (XDR *xdrs, remote_sched_param *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->field))
+ return FALSE;
+ if (!xdr_remote_sched_param_value (xdrs, &objp->value))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_open_args (XDR *xdrs, remote_open_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_supports_feature_args (XDR *xdrs, remote_supports_feature_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->feature))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_supports_feature_ret (XDR *xdrs, remote_supports_feature_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->supported))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_type_ret (XDR *xdrs, remote_get_type_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_version_ret (XDR *xdrs, remote_get_version_ret *objp)
+{
+
+ if (!xdr_int64_t (xdrs, &objp->hv_ver))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_hostname_ret (XDR *xdrs, remote_get_hostname_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->hostname))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_uri_ret (XDR *xdrs, remote_get_uri_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_max_vcpus_args (XDR *xdrs, remote_get_max_vcpus_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_max_vcpus_ret (XDR *xdrs, remote_get_max_vcpus_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->max_vcpus))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_get_info_ret (XDR *xdrs, remote_node_get_info_ret *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ if (!xdr_vector (xdrs, (char *)objp->model, 32,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->memory))
+ return FALSE;
+ buf = (int32_t*)XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_int (xdrs, &objp->cpus))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->mhz))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nodes))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->sockets))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->cores))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->threads))
+ return FALSE;
+ } else {
+ (void)IXDR_PUT_INT32(buf, objp->cpus);
+ (void)IXDR_PUT_INT32(buf, objp->mhz);
+ (void)IXDR_PUT_INT32(buf, objp->nodes);
+ (void)IXDR_PUT_INT32(buf, objp->sockets);
+ (void)IXDR_PUT_INT32(buf, objp->cores);
+ (void)IXDR_PUT_INT32(buf, objp->threads);
+ }
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ if (!xdr_vector (xdrs, (char *)objp->model, 32,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->memory))
+ return FALSE;
+ buf = (int32_t*)XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_int (xdrs, &objp->cpus))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->mhz))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nodes))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->sockets))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->cores))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->threads))
+ return FALSE;
+ } else {
+ objp->cpus = IXDR_GET_INT32(buf);
+ objp->mhz = IXDR_GET_INT32(buf);
+ objp->nodes = IXDR_GET_INT32(buf);
+ objp->sockets = IXDR_GET_INT32(buf);
+ objp->cores = IXDR_GET_INT32(buf);
+ objp->threads = IXDR_GET_INT32(buf);
+ }
+ return TRUE;
+ }
+
+ if (!xdr_vector (xdrs, (char *)objp->model, 32,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->memory))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->cpus))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->mhz))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nodes))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->sockets))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->cores))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->threads))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_capabilities_ret (XDR *xdrs, remote_get_capabilities_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->capabilities))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_get_cells_free_memory_args (XDR *xdrs, remote_node_get_cells_free_memory_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->startCell))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maxCells))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_get_cells_free_memory_ret (XDR *xdrs, remote_node_get_cells_free_memory_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->freeMems.freeMems_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->freeMems.freeMems_len, REMOTE_NODE_MAX_CELLS,
+ sizeof (int64_t), (xdrproc_t) xdr_int64_t))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_get_free_memory_ret (XDR *xdrs, remote_node_get_free_memory_ret *objp)
+{
+
+ if (!xdr_int64_t (xdrs, &objp->freeMem))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_scheduler_type_args (XDR *xdrs, remote_domain_get_scheduler_type_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_scheduler_type_ret (XDR *xdrs, remote_domain_get_scheduler_type_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nparams))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_scheduler_parameters_args (XDR *xdrs, remote_domain_get_scheduler_parameters_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nparams))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_scheduler_parameters_ret (XDR *xdrs, remote_domain_get_scheduler_parameters_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->params.params_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
+ sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_set_scheduler_parameters_args (XDR *xdrs, remote_domain_set_scheduler_parameters_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->params.params_val;
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
+ sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_block_stats_args (XDR *xdrs, remote_domain_block_stats_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->path))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_block_stats_ret (XDR *xdrs, remote_domain_block_stats_ret *objp)
+{
+
+ if (!xdr_int64_t (xdrs, &objp->rd_req))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->rd_bytes))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->wr_req))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->wr_bytes))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->errs))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_interface_stats_args (XDR *xdrs, remote_domain_interface_stats_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->path))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_interface_stats_ret (XDR *xdrs, remote_domain_interface_stats_ret *objp)
+{
+
+ if (!xdr_int64_t (xdrs, &objp->rx_bytes))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->rx_packets))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->rx_errs))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->rx_drop))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->tx_bytes))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->tx_packets))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->tx_errs))
+ return FALSE;
+ if (!xdr_int64_t (xdrs, &objp->tx_drop))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_block_peek_args (XDR *xdrs, remote_domain_block_peek_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->path))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->offset))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->size))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_block_peek_ret (XDR *xdrs, remote_domain_block_peek_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->buffer.buffer_val;
+
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->buffer.buffer_len, REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_memory_peek_args (XDR *xdrs, remote_domain_memory_peek_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->offset))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->size))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_memory_peek_ret (XDR *xdrs, remote_domain_memory_peek_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->buffer.buffer_val;
+
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->buffer.buffer_len, REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_domains_args (XDR *xdrs, remote_list_domains_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxids))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_domains_ret (XDR *xdrs, remote_list_domains_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->ids.ids_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->ids.ids_len, REMOTE_DOMAIN_ID_LIST_MAX,
+ sizeof (int), (xdrproc_t) xdr_int))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_domains_ret (XDR *xdrs, remote_num_of_domains_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_create_xml_args (XDR *xdrs, remote_domain_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_create_xml_ret (XDR *xdrs, remote_domain_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_id_args (XDR *xdrs, remote_domain_lookup_by_id_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->id))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_id_ret (XDR *xdrs, remote_domain_lookup_by_id_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_uuid_args (XDR *xdrs, remote_domain_lookup_by_uuid_args *objp)
+{
+
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_uuid_ret (XDR *xdrs, remote_domain_lookup_by_uuid_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_name_args (XDR *xdrs, remote_domain_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_lookup_by_name_ret (XDR *xdrs, remote_domain_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_suspend_args (XDR *xdrs, remote_domain_suspend_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_resume_args (XDR *xdrs, remote_domain_resume_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_shutdown_args (XDR *xdrs, remote_domain_shutdown_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_reboot_args (XDR *xdrs, remote_domain_reboot_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_destroy_args (XDR *xdrs, remote_domain_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_os_type_args (XDR *xdrs, remote_domain_get_os_type_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_os_type_ret (XDR *xdrs, remote_domain_get_os_type_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_max_memory_args (XDR *xdrs, remote_domain_get_max_memory_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_max_memory_ret (XDR *xdrs, remote_domain_get_max_memory_ret *objp)
+{
+
+ if (!xdr_uint64_t (xdrs, &objp->memory))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_set_max_memory_args (XDR *xdrs, remote_domain_set_max_memory_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->memory))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_set_memory_args (XDR *xdrs, remote_domain_set_memory_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->memory))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_info_args (XDR *xdrs, remote_domain_get_info_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_info_ret (XDR *xdrs, remote_domain_get_info_ret *objp)
+{
+
+ if (!xdr_u_char (xdrs, &objp->state))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->max_mem))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->memory))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->nr_virt_cpu))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->cpu_time))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_save_args (XDR *xdrs, remote_domain_save_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->to))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_restore_args (XDR *xdrs, remote_domain_restore_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->from))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_core_dump_args (XDR *xdrs, remote_domain_core_dump_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->to))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_dump_xml_args (XDR *xdrs, remote_domain_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_dump_xml_ret (XDR *xdrs, remote_domain_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_prepare_args (XDR *xdrs, remote_domain_migrate_prepare_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->uri_in))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->dname))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->resource))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_prepare_ret (XDR *xdrs, remote_domain_migrate_prepare_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
+
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->uri_out))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_perform_args (XDR *xdrs, remote_domain_migrate_perform_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->dname))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->resource))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_finish_args (XDR *xdrs, remote_domain_migrate_finish_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->dname))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_finish_ret (XDR *xdrs, remote_domain_migrate_finish_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->ddom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_prepare2_args (XDR *xdrs, remote_domain_migrate_prepare2_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->uri_in))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->dname))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->resource))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->dom_xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_prepare2_ret (XDR *xdrs, remote_domain_migrate_prepare2_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
+
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->uri_out))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_finish2_args (XDR *xdrs, remote_domain_migrate_finish2_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->dname))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->retcode))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_migrate_finish2_ret (XDR *xdrs, remote_domain_migrate_finish2_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->ddom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_domains_args (XDR *xdrs, remote_list_defined_domains_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_domains_ret (XDR *xdrs, remote_list_defined_domains_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DOMAIN_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_defined_domains_ret (XDR *xdrs, remote_num_of_defined_domains_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_create_args (XDR *xdrs, remote_domain_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_define_xml_args (XDR *xdrs, remote_domain_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_define_xml_ret (XDR *xdrs, remote_domain_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_undefine_args (XDR *xdrs, remote_domain_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_set_vcpus_args (XDR *xdrs, remote_domain_set_vcpus_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nvcpus))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_pin_vcpu_args (XDR *xdrs, remote_domain_pin_vcpu_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->cpumap.cpumap_val;
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->vcpu))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cpumap.cpumap_len, REMOTE_CPUMAP_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_vcpus_args (XDR *xdrs, remote_domain_get_vcpus_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maxinfo))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maplen))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_vcpus_ret (XDR *xdrs, remote_domain_get_vcpus_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->info.info_val;
+ char **objp_cpp1 = (char **) (void *) &objp->cpumaps.cpumaps_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->info.info_len, REMOTE_VCPUINFO_MAX,
+ sizeof (remote_vcpu_info), (xdrproc_t) xdr_remote_vcpu_info))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp1, (u_int *) &objp->cpumaps.cpumaps_len, REMOTE_CPUMAPS_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_max_vcpus_args (XDR *xdrs, remote_domain_get_max_vcpus_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_max_vcpus_ret (XDR *xdrs, remote_domain_get_max_vcpus_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_security_label_args (XDR *xdrs, remote_domain_get_security_label_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_security_label_ret (XDR *xdrs, remote_domain_get_security_label_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->label.label_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->label.label_len, REMOTE_SECURITY_LABEL_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->enforcing))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_get_security_model_ret (XDR *xdrs, remote_node_get_security_model_ret *objp)
+{
+ char **objp_cpp1 = (char **) (void *) &objp->doi.doi_val;
+ char **objp_cpp0 = (char **) (void *) &objp->model.model_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->model.model_len, REMOTE_SECURITY_MODEL_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp1, (u_int *) &objp->doi.doi_len, REMOTE_SECURITY_DOI_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_attach_device_args (XDR *xdrs, remote_domain_attach_device_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_detach_device_args (XDR *xdrs, remote_domain_detach_device_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_autostart_args (XDR *xdrs, remote_domain_get_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_get_autostart_ret (XDR *xdrs, remote_domain_get_autostart_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_set_autostart_args (XDR *xdrs, remote_domain_set_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_networks_ret (XDR *xdrs, remote_num_of_networks_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_networks_args (XDR *xdrs, remote_list_networks_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_networks_ret (XDR *xdrs, remote_list_networks_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_defined_networks_ret (XDR *xdrs, remote_num_of_defined_networks_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_networks_args (XDR *xdrs, remote_list_defined_networks_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_networks_ret (XDR *xdrs, remote_list_defined_networks_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_lookup_by_uuid_args (XDR *xdrs, remote_network_lookup_by_uuid_args *objp)
+{
+
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_lookup_by_uuid_ret (XDR *xdrs, remote_network_lookup_by_uuid_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_lookup_by_name_args (XDR *xdrs, remote_network_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_lookup_by_name_ret (XDR *xdrs, remote_network_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_create_xml_args (XDR *xdrs, remote_network_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_create_xml_ret (XDR *xdrs, remote_network_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_define_xml_args (XDR *xdrs, remote_network_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_define_xml_ret (XDR *xdrs, remote_network_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_undefine_args (XDR *xdrs, remote_network_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_create_args (XDR *xdrs, remote_network_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_destroy_args (XDR *xdrs, remote_network_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_dump_xml_args (XDR *xdrs, remote_network_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_dump_xml_ret (XDR *xdrs, remote_network_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_get_bridge_name_args (XDR *xdrs, remote_network_get_bridge_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_get_bridge_name_ret (XDR *xdrs, remote_network_get_bridge_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_get_autostart_args (XDR *xdrs, remote_network_get_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_get_autostart_ret (XDR *xdrs, remote_network_get_autostart_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_set_autostart_args (XDR *xdrs, remote_network_set_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_interfaces_ret (XDR *xdrs, remote_num_of_interfaces_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_args (XDR *xdrs, remote_list_interfaces_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_ret (XDR *xdrs, remote_list_interfaces_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_INTERFACE_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_defined_interfaces_ret (XDR *xdrs, remote_num_of_defined_interfaces_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_interfaces_args (XDR *xdrs, remote_list_defined_interfaces_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_interfaces_ret (XDR *xdrs, remote_list_defined_interfaces_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_args (XDR *xdrs, remote_interface_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_ret (XDR *xdrs, remote_interface_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_string_args (XDR *xdrs, remote_interface_lookup_by_mac_string_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_string_ret (XDR *xdrs, remote_interface_lookup_by_mac_string_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_args (XDR *xdrs, remote_interface_get_xml_desc_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_ret (XDR *xdrs, remote_interface_get_xml_desc_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_args (XDR *xdrs, remote_interface_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_ret (XDR *xdrs, remote_interface_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_undefine_args (XDR *xdrs, remote_interface_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_create_args (XDR *xdrs, remote_interface_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_destroy_args (XDR *xdrs, remote_interface_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_list_ret (XDR *xdrs, remote_auth_list_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->types.types_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->types.types_len, REMOTE_AUTH_TYPE_LIST_MAX,
+ sizeof (remote_auth_type), (xdrproc_t) xdr_remote_auth_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_sasl_init_ret (XDR *xdrs, remote_auth_sasl_init_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->mechlist))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_sasl_start_args (XDR *xdrs, remote_auth_sasl_start_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->mech))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nil))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_sasl_start_ret (XDR *xdrs, remote_auth_sasl_start_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
+
+ if (!xdr_int (xdrs, &objp->complete))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nil))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_sasl_step_args (XDR *xdrs, remote_auth_sasl_step_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
+
+ if (!xdr_int (xdrs, &objp->nil))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_sasl_step_ret (XDR *xdrs, remote_auth_sasl_step_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
+
+ if (!xdr_int (xdrs, &objp->complete))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nil))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
+ sizeof (char), (xdrproc_t) xdr_char))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_auth_polkit_ret (XDR *xdrs, remote_auth_polkit_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->complete))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_storage_pools_ret (XDR *xdrs, remote_num_of_storage_pools_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_storage_pools_args (XDR *xdrs, remote_list_storage_pools_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_storage_pools_ret (XDR *xdrs, remote_list_storage_pools_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_defined_storage_pools_ret (XDR *xdrs, remote_num_of_defined_storage_pools_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_storage_pools_args (XDR *xdrs, remote_list_defined_storage_pools_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_defined_storage_pools_ret (XDR *xdrs, remote_list_defined_storage_pools_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_find_storage_pool_sources_args (XDR *xdrs, remote_find_storage_pool_sources_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_remote_string (xdrs, &objp->srcSpec))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_find_storage_pool_sources_ret (XDR *xdrs, remote_find_storage_pool_sources_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_uuid_args (XDR *xdrs, remote_storage_pool_lookup_by_uuid_args *objp)
+{
+
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *xdrs, remote_storage_pool_lookup_by_uuid_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_name_args (XDR *xdrs, remote_storage_pool_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_name_ret (XDR *xdrs, remote_storage_pool_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_volume_args (XDR *xdrs, remote_storage_pool_lookup_by_volume_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_lookup_by_volume_ret (XDR *xdrs, remote_storage_pool_lookup_by_volume_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_xml_args (XDR *xdrs, remote_storage_pool_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_xml_ret (XDR *xdrs, remote_storage_pool_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_define_xml_args (XDR *xdrs, remote_storage_pool_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_define_xml_ret (XDR *xdrs, remote_storage_pool_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_build_args (XDR *xdrs, remote_storage_pool_build_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_undefine_args (XDR *xdrs, remote_storage_pool_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_create_args (XDR *xdrs, remote_storage_pool_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_destroy_args (XDR *xdrs, remote_storage_pool_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_delete_args (XDR *xdrs, remote_storage_pool_delete_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_refresh_args (XDR *xdrs, remote_storage_pool_refresh_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_dump_xml_args (XDR *xdrs, remote_storage_pool_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_dump_xml_ret (XDR *xdrs, remote_storage_pool_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_info_args (XDR *xdrs, remote_storage_pool_get_info_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_info_ret (XDR *xdrs, remote_storage_pool_get_info_ret *objp)
+{
+
+ if (!xdr_u_char (xdrs, &objp->state))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->capacity))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->allocation))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->available))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_autostart_args (XDR *xdrs, remote_storage_pool_get_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_get_autostart_ret (XDR *xdrs, remote_storage_pool_get_autostart_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_set_autostart_args (XDR *xdrs, remote_storage_pool_set_autostart_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->autostart))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_num_of_volumes_args (XDR *xdrs, remote_storage_pool_num_of_volumes_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_num_of_volumes_ret (XDR *xdrs, remote_storage_pool_num_of_volumes_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_list_volumes_args (XDR *xdrs, remote_storage_pool_list_volumes_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_list_volumes_ret (XDR *xdrs, remote_storage_pool_list_volumes_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_VOL_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_name_args (XDR *xdrs, remote_storage_vol_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_name_ret (XDR *xdrs, remote_storage_vol_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_key_args (XDR *xdrs, remote_storage_vol_lookup_by_key_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->key))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_key_ret (XDR *xdrs, remote_storage_vol_lookup_by_key_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_path_args (XDR *xdrs, remote_storage_vol_lookup_by_path_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->path))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_lookup_by_path_ret (XDR *xdrs, remote_storage_vol_lookup_by_path_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_args (XDR *xdrs, remote_storage_vol_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_ret (XDR *xdrs, remote_storage_vol_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_from_args (XDR *xdrs, remote_storage_vol_create_xml_from_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->clonevol))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_create_xml_from_ret (XDR *xdrs, remote_storage_vol_create_xml_from_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_delete_args (XDR *xdrs, remote_storage_vol_delete_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_dump_xml_args (XDR *xdrs, remote_storage_vol_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_dump_xml_ret (XDR *xdrs, remote_storage_vol_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_info_args (XDR *xdrs, remote_storage_vol_get_info_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_info_ret (XDR *xdrs, remote_storage_vol_get_info_ret *objp)
+{
+
+ if (!xdr_char (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->capacity))
+ return FALSE;
+ if (!xdr_uint64_t (xdrs, &objp->allocation))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_path_args (XDR *xdrs, remote_storage_vol_get_path_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_vol_get_path_ret (XDR *xdrs, remote_storage_vol_get_path_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_num_of_devices_args (XDR *xdrs, remote_node_num_of_devices_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->cap))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_num_of_devices_ret (XDR *xdrs, remote_node_num_of_devices_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_list_devices_args (XDR *xdrs, remote_node_list_devices_args *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->cap))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_list_devices_ret (XDR *xdrs, remote_node_list_devices_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NODE_DEVICE_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_lookup_by_name_args (XDR *xdrs, remote_node_device_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_lookup_by_name_ret (XDR *xdrs, remote_node_device_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_node_device (xdrs, &objp->dev))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_dump_xml_args (XDR *xdrs, remote_node_device_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_dump_xml_ret (XDR *xdrs, remote_node_device_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_get_parent_args (XDR *xdrs, remote_node_device_get_parent_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_get_parent_ret (XDR *xdrs, remote_node_device_get_parent_ret *objp)
+{
+
+ if (!xdr_remote_string (xdrs, &objp->parent))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_num_of_caps_args (XDR *xdrs, remote_node_device_num_of_caps_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_num_of_caps_ret (XDR *xdrs, remote_node_device_num_of_caps_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_list_caps_args (XDR *xdrs, remote_node_device_list_caps_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_list_caps_ret (XDR *xdrs, remote_node_device_list_caps_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NODE_DEVICE_CAPS_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_dettach_args (XDR *xdrs, remote_node_device_dettach_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_re_attach_args (XDR *xdrs, remote_node_device_re_attach_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_reset_args (XDR *xdrs, remote_node_device_reset_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_create_xml_args (XDR *xdrs, remote_node_device_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_create_xml_ret (XDR *xdrs, remote_node_device_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_node_device (xdrs, &objp->dev))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_node_device_destroy_args (XDR *xdrs, remote_node_device_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_events_register_ret (XDR *xdrs, remote_domain_events_register_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->cb_registered))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_events_deregister_ret (XDR *xdrs, remote_domain_events_deregister_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->cb_registered))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_event_msg (XDR *xdrs, remote_domain_event_msg *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->event))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->detail))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_xml_from_native_args (XDR *xdrs, remote_domain_xml_from_native_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->nativeFormat))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->nativeConfig))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_xml_from_native_ret (XDR *xdrs, remote_domain_xml_from_native_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->domainXml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_xml_to_native_args (XDR *xdrs, remote_domain_xml_to_native_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->nativeFormat))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->domainXml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_xml_to_native_ret (XDR *xdrs, remote_domain_xml_to_native_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->nativeConfig))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_num_of_secrets_ret (XDR *xdrs, remote_num_of_secrets_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_secrets_args (XDR *xdrs, remote_list_secrets_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxuuids))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_secrets_ret (XDR *xdrs, remote_list_secrets_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->uuids.uuids_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->uuids.uuids_len, REMOTE_SECRET_UUID_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_lookup_by_uuid_args (XDR *xdrs, remote_secret_lookup_by_uuid_args *objp)
+{
+
+ if (!xdr_remote_uuid (xdrs, objp->uuid))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_lookup_by_uuid_ret (XDR *xdrs, remote_secret_lookup_by_uuid_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_define_xml_args (XDR *xdrs, remote_secret_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_define_xml_ret (XDR *xdrs, remote_secret_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_get_xml_desc_args (XDR *xdrs, remote_secret_get_xml_desc_args *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_get_xml_desc_ret (XDR *xdrs, remote_secret_get_xml_desc_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_set_value_args (XDR *xdrs, remote_secret_set_value_args *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->value.value_val;
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->value.value_len, REMOTE_SECRET_VALUE_MAX))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_get_value_args (XDR *xdrs, remote_secret_get_value_args *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_get_value_ret (XDR *xdrs, remote_secret_get_value_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->value.value_val;
+
+ if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->value.value_len, REMOTE_SECRET_VALUE_MAX))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_undefine_args (XDR *xdrs, remote_secret_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_lookup_by_usage_args (XDR *xdrs, remote_secret_lookup_by_usage_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->usageType))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->usageID))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_secret_lookup_by_usage_ret (XDR *xdrs, remote_secret_lookup_by_usage_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
+{
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_message_type (XDR *xdrs, remote_message_type *objp)
+{
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_message_status (XDR *xdrs, remote_message_status *objp)
+{
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_message_header (XDR *xdrs, remote_message_header *objp)
+{
+
+ if (!xdr_u_int (xdrs, &objp->prog))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->vers))
+ return FALSE;
+ if (!xdr_remote_procedure (xdrs, &objp->proc))
+ return FALSE;
+ if (!xdr_remote_message_type (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->serial))
+ return FALSE;
+ if (!xdr_remote_message_status (xdrs, &objp->status))
+ return FALSE;
+ return TRUE;
+}
--- /dev/null
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _RP_H_RPCGEN
+#define _RP_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "internal.h"
+#include <arpa/inet.h>
+#define REMOTE_MESSAGE_MAX 262144
+#define REMOTE_STRING_MAX 65536
+
+typedef char *remote_nonnull_string;
+
+typedef remote_nonnull_string *remote_string;
+#define REMOTE_DOMAIN_ID_LIST_MAX 16384
+#define REMOTE_DOMAIN_NAME_LIST_MAX 1024
+#define REMOTE_CPUMAP_MAX 256
+#define REMOTE_VCPUINFO_MAX 2048
+#define REMOTE_CPUMAPS_MAX 16384
+#define REMOTE_MIGRATE_COOKIE_MAX 256
+#define REMOTE_NETWORK_NAME_LIST_MAX 256
+#define REMOTE_INTERFACE_NAME_LIST_MAX 256
+#define REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX 256
+#define REMOTE_STORAGE_POOL_NAME_LIST_MAX 256
+#define REMOTE_STORAGE_VOL_NAME_LIST_MAX 1024
+#define REMOTE_NODE_DEVICE_NAME_LIST_MAX 16384
+#define REMOTE_NODE_DEVICE_CAPS_LIST_MAX 16384
+#define REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX 16
+#define REMOTE_NODE_MAX_CELLS 1024
+#define REMOTE_AUTH_SASL_DATA_MAX 65536
+#define REMOTE_AUTH_TYPE_LIST_MAX 20
+#define REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX 65536
+#define REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX 65536
+#define REMOTE_SECURITY_MODEL_MAX VIR_SECURITY_MODEL_BUFLEN
+#define REMOTE_SECURITY_LABEL_MAX VIR_SECURITY_LABEL_BUFLEN
+#define REMOTE_SECURITY_DOI_MAX VIR_SECURITY_DOI_BUFLEN
+#define REMOTE_SECRET_VALUE_MAX 65536
+#define REMOTE_SECRET_UUID_LIST_MAX 16384
+
+typedef char remote_uuid[VIR_UUID_BUFLEN];
+
+struct remote_nonnull_domain {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+ int id;
+};
+typedef struct remote_nonnull_domain remote_nonnull_domain;
+
+struct remote_nonnull_network {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+};
+typedef struct remote_nonnull_network remote_nonnull_network;
+
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_nonnull_string mac;
+};
+typedef struct remote_nonnull_interface remote_nonnull_interface;
+
+struct remote_nonnull_storage_pool {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+};
+typedef struct remote_nonnull_storage_pool remote_nonnull_storage_pool;
+
+struct remote_nonnull_storage_vol {
+ remote_nonnull_string pool;
+ remote_nonnull_string name;
+ remote_nonnull_string key;
+};
+typedef struct remote_nonnull_storage_vol remote_nonnull_storage_vol;
+
+struct remote_nonnull_node_device {
+ remote_nonnull_string name;
+};
+typedef struct remote_nonnull_node_device remote_nonnull_node_device;
+
+struct remote_nonnull_secret {
+ remote_uuid uuid;
+ int usageType;
+ remote_nonnull_string usageID;
+};
+typedef struct remote_nonnull_secret remote_nonnull_secret;
+
+typedef remote_nonnull_domain *remote_domain;
+
+typedef remote_nonnull_network *remote_network;
+
+typedef remote_nonnull_storage_pool *remote_storage_pool;
+
+typedef remote_nonnull_storage_vol *remote_storage_vol;
+
+typedef remote_nonnull_node_device *remote_node_device;
+
+struct remote_error {
+ int code;
+ int domain;
+ remote_string message;
+ int level;
+ remote_domain dom;
+ remote_string str1;
+ remote_string str2;
+ remote_string str3;
+ int int1;
+ int int2;
+ remote_network net;
+};
+typedef struct remote_error remote_error;
+
+enum remote_auth_type {
+ REMOTE_AUTH_NONE = 0,
+ REMOTE_AUTH_SASL = 1,
+ REMOTE_AUTH_POLKIT = 2,
+};
+typedef enum remote_auth_type remote_auth_type;
+
+struct remote_vcpu_info {
+ u_int number;
+ int state;
+ uint64_t cpu_time;
+ int cpu;
+};
+typedef struct remote_vcpu_info remote_vcpu_info;
+
+struct remote_sched_param_value {
+ int type;
+ union {
+ int i;
+ u_int ui;
+ int64_t l;
+ uint64_t ul;
+ double d;
+ int b;
+ } remote_sched_param_value_u;
+};
+typedef struct remote_sched_param_value remote_sched_param_value;
+
+struct remote_sched_param {
+ remote_nonnull_string field;
+ remote_sched_param_value value;
+};
+typedef struct remote_sched_param remote_sched_param;
+
+struct remote_open_args {
+ remote_string name;
+ int flags;
+};
+typedef struct remote_open_args remote_open_args;
+
+struct remote_supports_feature_args {
+ int feature;
+};
+typedef struct remote_supports_feature_args remote_supports_feature_args;
+
+struct remote_supports_feature_ret {
+ int supported;
+};
+typedef struct remote_supports_feature_ret remote_supports_feature_ret;
+
+struct remote_get_type_ret {
+ remote_nonnull_string type;
+};
+typedef struct remote_get_type_ret remote_get_type_ret;
+
+struct remote_get_version_ret {
+ int64_t hv_ver;
+};
+typedef struct remote_get_version_ret remote_get_version_ret;
+
+struct remote_get_hostname_ret {
+ remote_nonnull_string hostname;
+};
+typedef struct remote_get_hostname_ret remote_get_hostname_ret;
+
+struct remote_get_uri_ret {
+ remote_nonnull_string uri;
+};
+typedef struct remote_get_uri_ret remote_get_uri_ret;
+
+struct remote_get_max_vcpus_args {
+ remote_string type;
+};
+typedef struct remote_get_max_vcpus_args remote_get_max_vcpus_args;
+
+struct remote_get_max_vcpus_ret {
+ int max_vcpus;
+};
+typedef struct remote_get_max_vcpus_ret remote_get_max_vcpus_ret;
+
+struct remote_node_get_info_ret {
+ char model[32];
+ int64_t memory;
+ int cpus;
+ int mhz;
+ int nodes;
+ int sockets;
+ int cores;
+ int threads;
+};
+typedef struct remote_node_get_info_ret remote_node_get_info_ret;
+
+struct remote_get_capabilities_ret {
+ remote_nonnull_string capabilities;
+};
+typedef struct remote_get_capabilities_ret remote_get_capabilities_ret;
+
+struct remote_node_get_cells_free_memory_args {
+ int startCell;
+ int maxCells;
+};
+typedef struct remote_node_get_cells_free_memory_args remote_node_get_cells_free_memory_args;
+
+struct remote_node_get_cells_free_memory_ret {
+ struct {
+ u_int freeMems_len;
+ int64_t *freeMems_val;
+ } freeMems;
+};
+typedef struct remote_node_get_cells_free_memory_ret remote_node_get_cells_free_memory_ret;
+
+struct remote_node_get_free_memory_ret {
+ int64_t freeMem;
+};
+typedef struct remote_node_get_free_memory_ret remote_node_get_free_memory_ret;
+
+struct remote_domain_get_scheduler_type_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_scheduler_type_args remote_domain_get_scheduler_type_args;
+
+struct remote_domain_get_scheduler_type_ret {
+ remote_nonnull_string type;
+ int nparams;
+};
+typedef struct remote_domain_get_scheduler_type_ret remote_domain_get_scheduler_type_ret;
+
+struct remote_domain_get_scheduler_parameters_args {
+ remote_nonnull_domain dom;
+ int nparams;
+};
+typedef struct remote_domain_get_scheduler_parameters_args remote_domain_get_scheduler_parameters_args;
+
+struct remote_domain_get_scheduler_parameters_ret {
+ struct {
+ u_int params_len;
+ remote_sched_param *params_val;
+ } params;
+};
+typedef struct remote_domain_get_scheduler_parameters_ret remote_domain_get_scheduler_parameters_ret;
+
+struct remote_domain_set_scheduler_parameters_args {
+ remote_nonnull_domain dom;
+ struct {
+ u_int params_len;
+ remote_sched_param *params_val;
+ } params;
+};
+typedef struct remote_domain_set_scheduler_parameters_args remote_domain_set_scheduler_parameters_args;
+
+struct remote_domain_block_stats_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+};
+typedef struct remote_domain_block_stats_args remote_domain_block_stats_args;
+
+struct remote_domain_block_stats_ret {
+ int64_t rd_req;
+ int64_t rd_bytes;
+ int64_t wr_req;
+ int64_t wr_bytes;
+ int64_t errs;
+};
+typedef struct remote_domain_block_stats_ret remote_domain_block_stats_ret;
+
+struct remote_domain_interface_stats_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+};
+typedef struct remote_domain_interface_stats_args remote_domain_interface_stats_args;
+
+struct remote_domain_interface_stats_ret {
+ int64_t rx_bytes;
+ int64_t rx_packets;
+ int64_t rx_errs;
+ int64_t rx_drop;
+ int64_t tx_bytes;
+ int64_t tx_packets;
+ int64_t tx_errs;
+ int64_t tx_drop;
+};
+typedef struct remote_domain_interface_stats_ret remote_domain_interface_stats_ret;
+
+struct remote_domain_block_peek_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+ uint64_t offset;
+ u_int size;
+ u_int flags;
+};
+typedef struct remote_domain_block_peek_args remote_domain_block_peek_args;
+
+struct remote_domain_block_peek_ret {
+ struct {
+ u_int buffer_len;
+ char *buffer_val;
+ } buffer;
+};
+typedef struct remote_domain_block_peek_ret remote_domain_block_peek_ret;
+
+struct remote_domain_memory_peek_args {
+ remote_nonnull_domain dom;
+ uint64_t offset;
+ u_int size;
+ u_int flags;
+};
+typedef struct remote_domain_memory_peek_args remote_domain_memory_peek_args;
+
+struct remote_domain_memory_peek_ret {
+ struct {
+ u_int buffer_len;
+ char *buffer_val;
+ } buffer;
+};
+typedef struct remote_domain_memory_peek_ret remote_domain_memory_peek_ret;
+
+struct remote_list_domains_args {
+ int maxids;
+};
+typedef struct remote_list_domains_args remote_list_domains_args;
+
+struct remote_list_domains_ret {
+ struct {
+ u_int ids_len;
+ int *ids_val;
+ } ids;
+};
+typedef struct remote_list_domains_ret remote_list_domains_ret;
+
+struct remote_num_of_domains_ret {
+ int num;
+};
+typedef struct remote_num_of_domains_ret remote_num_of_domains_ret;
+
+struct remote_domain_create_xml_args {
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+typedef struct remote_domain_create_xml_args remote_domain_create_xml_args;
+
+struct remote_domain_create_xml_ret {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_create_xml_ret remote_domain_create_xml_ret;
+
+struct remote_domain_lookup_by_id_args {
+ int id;
+};
+typedef struct remote_domain_lookup_by_id_args remote_domain_lookup_by_id_args;
+
+struct remote_domain_lookup_by_id_ret {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_lookup_by_id_ret remote_domain_lookup_by_id_ret;
+
+struct remote_domain_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+typedef struct remote_domain_lookup_by_uuid_args remote_domain_lookup_by_uuid_args;
+
+struct remote_domain_lookup_by_uuid_ret {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_lookup_by_uuid_ret remote_domain_lookup_by_uuid_ret;
+
+struct remote_domain_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_domain_lookup_by_name_args remote_domain_lookup_by_name_args;
+
+struct remote_domain_lookup_by_name_ret {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_lookup_by_name_ret remote_domain_lookup_by_name_ret;
+
+struct remote_domain_suspend_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_suspend_args remote_domain_suspend_args;
+
+struct remote_domain_resume_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_resume_args remote_domain_resume_args;
+
+struct remote_domain_shutdown_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_shutdown_args remote_domain_shutdown_args;
+
+struct remote_domain_reboot_args {
+ remote_nonnull_domain dom;
+ int flags;
+};
+typedef struct remote_domain_reboot_args remote_domain_reboot_args;
+
+struct remote_domain_destroy_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_destroy_args remote_domain_destroy_args;
+
+struct remote_domain_get_os_type_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_os_type_args remote_domain_get_os_type_args;
+
+struct remote_domain_get_os_type_ret {
+ remote_nonnull_string type;
+};
+typedef struct remote_domain_get_os_type_ret remote_domain_get_os_type_ret;
+
+struct remote_domain_get_max_memory_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_max_memory_args remote_domain_get_max_memory_args;
+
+struct remote_domain_get_max_memory_ret {
+ uint64_t memory;
+};
+typedef struct remote_domain_get_max_memory_ret remote_domain_get_max_memory_ret;
+
+struct remote_domain_set_max_memory_args {
+ remote_nonnull_domain dom;
+ uint64_t memory;
+};
+typedef struct remote_domain_set_max_memory_args remote_domain_set_max_memory_args;
+
+struct remote_domain_set_memory_args {
+ remote_nonnull_domain dom;
+ uint64_t memory;
+};
+typedef struct remote_domain_set_memory_args remote_domain_set_memory_args;
+
+struct remote_domain_get_info_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_info_args remote_domain_get_info_args;
+
+struct remote_domain_get_info_ret {
+ u_char state;
+ uint64_t max_mem;
+ uint64_t memory;
+ u_short nr_virt_cpu;
+ uint64_t cpu_time;
+};
+typedef struct remote_domain_get_info_ret remote_domain_get_info_ret;
+
+struct remote_domain_save_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string to;
+};
+typedef struct remote_domain_save_args remote_domain_save_args;
+
+struct remote_domain_restore_args {
+ remote_nonnull_string from;
+};
+typedef struct remote_domain_restore_args remote_domain_restore_args;
+
+struct remote_domain_core_dump_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string to;
+ int flags;
+};
+typedef struct remote_domain_core_dump_args remote_domain_core_dump_args;
+
+struct remote_domain_dump_xml_args {
+ remote_nonnull_domain dom;
+ int flags;
+};
+typedef struct remote_domain_dump_xml_args remote_domain_dump_xml_args;
+
+struct remote_domain_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_domain_dump_xml_ret remote_domain_dump_xml_ret;
+
+struct remote_domain_migrate_prepare_args {
+ remote_string uri_in;
+ uint64_t flags;
+ remote_string dname;
+ uint64_t resource;
+};
+typedef struct remote_domain_migrate_prepare_args remote_domain_migrate_prepare_args;
+
+struct remote_domain_migrate_prepare_ret {
+ struct {
+ u_int cookie_len;
+ char *cookie_val;
+ } cookie;
+ remote_string uri_out;
+};
+typedef struct remote_domain_migrate_prepare_ret remote_domain_migrate_prepare_ret;
+
+struct remote_domain_migrate_perform_args {
+ remote_nonnull_domain dom;
+ struct {
+ u_int cookie_len;
+ char *cookie_val;
+ } cookie;
+ remote_nonnull_string uri;
+ uint64_t flags;
+ remote_string dname;
+ uint64_t resource;
+};
+typedef struct remote_domain_migrate_perform_args remote_domain_migrate_perform_args;
+
+struct remote_domain_migrate_finish_args {
+ remote_nonnull_string dname;
+ struct {
+ u_int cookie_len;
+ char *cookie_val;
+ } cookie;
+ remote_nonnull_string uri;
+ uint64_t flags;
+};
+typedef struct remote_domain_migrate_finish_args remote_domain_migrate_finish_args;
+
+struct remote_domain_migrate_finish_ret {
+ remote_nonnull_domain ddom;
+};
+typedef struct remote_domain_migrate_finish_ret remote_domain_migrate_finish_ret;
+
+struct remote_domain_migrate_prepare2_args {
+ remote_string uri_in;
+ uint64_t flags;
+ remote_string dname;
+ uint64_t resource;
+ remote_nonnull_string dom_xml;
+};
+typedef struct remote_domain_migrate_prepare2_args remote_domain_migrate_prepare2_args;
+
+struct remote_domain_migrate_prepare2_ret {
+ struct {
+ u_int cookie_len;
+ char *cookie_val;
+ } cookie;
+ remote_string uri_out;
+};
+typedef struct remote_domain_migrate_prepare2_ret remote_domain_migrate_prepare2_ret;
+
+struct remote_domain_migrate_finish2_args {
+ remote_nonnull_string dname;
+ struct {
+ u_int cookie_len;
+ char *cookie_val;
+ } cookie;
+ remote_nonnull_string uri;
+ uint64_t flags;
+ int retcode;
+};
+typedef struct remote_domain_migrate_finish2_args remote_domain_migrate_finish2_args;
+
+struct remote_domain_migrate_finish2_ret {
+ remote_nonnull_domain ddom;
+};
+typedef struct remote_domain_migrate_finish2_ret remote_domain_migrate_finish2_ret;
+
+struct remote_list_defined_domains_args {
+ int maxnames;
+};
+typedef struct remote_list_defined_domains_args remote_list_defined_domains_args;
+
+struct remote_list_defined_domains_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_defined_domains_ret remote_list_defined_domains_ret;
+
+struct remote_num_of_defined_domains_ret {
+ int num;
+};
+typedef struct remote_num_of_defined_domains_ret remote_num_of_defined_domains_ret;
+
+struct remote_domain_create_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_create_args remote_domain_create_args;
+
+struct remote_domain_define_xml_args {
+ remote_nonnull_string xml;
+};
+typedef struct remote_domain_define_xml_args remote_domain_define_xml_args;
+
+struct remote_domain_define_xml_ret {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_define_xml_ret remote_domain_define_xml_ret;
+
+struct remote_domain_undefine_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_undefine_args remote_domain_undefine_args;
+
+struct remote_domain_set_vcpus_args {
+ remote_nonnull_domain dom;
+ int nvcpus;
+};
+typedef struct remote_domain_set_vcpus_args remote_domain_set_vcpus_args;
+
+struct remote_domain_pin_vcpu_args {
+ remote_nonnull_domain dom;
+ int vcpu;
+ struct {
+ u_int cpumap_len;
+ char *cpumap_val;
+ } cpumap;
+};
+typedef struct remote_domain_pin_vcpu_args remote_domain_pin_vcpu_args;
+
+struct remote_domain_get_vcpus_args {
+ remote_nonnull_domain dom;
+ int maxinfo;
+ int maplen;
+};
+typedef struct remote_domain_get_vcpus_args remote_domain_get_vcpus_args;
+
+struct remote_domain_get_vcpus_ret {
+ struct {
+ u_int info_len;
+ remote_vcpu_info *info_val;
+ } info;
+ struct {
+ u_int cpumaps_len;
+ char *cpumaps_val;
+ } cpumaps;
+};
+typedef struct remote_domain_get_vcpus_ret remote_domain_get_vcpus_ret;
+
+struct remote_domain_get_max_vcpus_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_max_vcpus_args remote_domain_get_max_vcpus_args;
+
+struct remote_domain_get_max_vcpus_ret {
+ int num;
+};
+typedef struct remote_domain_get_max_vcpus_ret remote_domain_get_max_vcpus_ret;
+
+struct remote_domain_get_security_label_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_security_label_args remote_domain_get_security_label_args;
+
+struct remote_domain_get_security_label_ret {
+ struct {
+ u_int label_len;
+ char *label_val;
+ } label;
+ int enforcing;
+};
+typedef struct remote_domain_get_security_label_ret remote_domain_get_security_label_ret;
+
+struct remote_node_get_security_model_ret {
+ struct {
+ u_int model_len;
+ char *model_val;
+ } model;
+ struct {
+ u_int doi_len;
+ char *doi_val;
+ } doi;
+};
+typedef struct remote_node_get_security_model_ret remote_node_get_security_model_ret;
+
+struct remote_domain_attach_device_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string xml;
+};
+typedef struct remote_domain_attach_device_args remote_domain_attach_device_args;
+
+struct remote_domain_detach_device_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string xml;
+};
+typedef struct remote_domain_detach_device_args remote_domain_detach_device_args;
+
+struct remote_domain_get_autostart_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_get_autostart_args remote_domain_get_autostart_args;
+
+struct remote_domain_get_autostart_ret {
+ int autostart;
+};
+typedef struct remote_domain_get_autostart_ret remote_domain_get_autostart_ret;
+
+struct remote_domain_set_autostart_args {
+ remote_nonnull_domain dom;
+ int autostart;
+};
+typedef struct remote_domain_set_autostart_args remote_domain_set_autostart_args;
+
+struct remote_num_of_networks_ret {
+ int num;
+};
+typedef struct remote_num_of_networks_ret remote_num_of_networks_ret;
+
+struct remote_list_networks_args {
+ int maxnames;
+};
+typedef struct remote_list_networks_args remote_list_networks_args;
+
+struct remote_list_networks_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_networks_ret remote_list_networks_ret;
+
+struct remote_num_of_defined_networks_ret {
+ int num;
+};
+typedef struct remote_num_of_defined_networks_ret remote_num_of_defined_networks_ret;
+
+struct remote_list_defined_networks_args {
+ int maxnames;
+};
+typedef struct remote_list_defined_networks_args remote_list_defined_networks_args;
+
+struct remote_list_defined_networks_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_defined_networks_ret remote_list_defined_networks_ret;
+
+struct remote_network_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+typedef struct remote_network_lookup_by_uuid_args remote_network_lookup_by_uuid_args;
+
+struct remote_network_lookup_by_uuid_ret {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_lookup_by_uuid_ret remote_network_lookup_by_uuid_ret;
+
+struct remote_network_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_network_lookup_by_name_args remote_network_lookup_by_name_args;
+
+struct remote_network_lookup_by_name_ret {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_lookup_by_name_ret remote_network_lookup_by_name_ret;
+
+struct remote_network_create_xml_args {
+ remote_nonnull_string xml;
+};
+typedef struct remote_network_create_xml_args remote_network_create_xml_args;
+
+struct remote_network_create_xml_ret {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_create_xml_ret remote_network_create_xml_ret;
+
+struct remote_network_define_xml_args {
+ remote_nonnull_string xml;
+};
+typedef struct remote_network_define_xml_args remote_network_define_xml_args;
+
+struct remote_network_define_xml_ret {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_define_xml_ret remote_network_define_xml_ret;
+
+struct remote_network_undefine_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_undefine_args remote_network_undefine_args;
+
+struct remote_network_create_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_create_args remote_network_create_args;
+
+struct remote_network_destroy_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_destroy_args remote_network_destroy_args;
+
+struct remote_network_dump_xml_args {
+ remote_nonnull_network net;
+ int flags;
+};
+typedef struct remote_network_dump_xml_args remote_network_dump_xml_args;
+
+struct remote_network_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_network_dump_xml_ret remote_network_dump_xml_ret;
+
+struct remote_network_get_bridge_name_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_get_bridge_name_args remote_network_get_bridge_name_args;
+
+struct remote_network_get_bridge_name_ret {
+ remote_nonnull_string name;
+};
+typedef struct remote_network_get_bridge_name_ret remote_network_get_bridge_name_ret;
+
+struct remote_network_get_autostart_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_get_autostart_args remote_network_get_autostart_args;
+
+struct remote_network_get_autostart_ret {
+ int autostart;
+};
+typedef struct remote_network_get_autostart_ret remote_network_get_autostart_ret;
+
+struct remote_network_set_autostart_args {
+ remote_nonnull_network net;
+ int autostart;
+};
+typedef struct remote_network_set_autostart_args remote_network_set_autostart_args;
+
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+typedef struct remote_num_of_interfaces_ret remote_num_of_interfaces_ret;
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+typedef struct remote_list_interfaces_args remote_list_interfaces_args;
+
+struct remote_list_interfaces_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_interfaces_ret remote_list_interfaces_ret;
+
+struct remote_num_of_defined_interfaces_ret {
+ int num;
+};
+typedef struct remote_num_of_defined_interfaces_ret remote_num_of_defined_interfaces_ret;
+
+struct remote_list_defined_interfaces_args {
+ int maxnames;
+};
+typedef struct remote_list_defined_interfaces_args remote_list_defined_interfaces_args;
+
+struct remote_list_defined_interfaces_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_defined_interfaces_ret remote_list_defined_interfaces_ret;
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_interface_lookup_by_name_args remote_interface_lookup_by_name_args;
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface iface;
+};
+typedef struct remote_interface_lookup_by_name_ret remote_interface_lookup_by_name_ret;
+
+struct remote_interface_lookup_by_mac_string_args {
+ remote_nonnull_string mac;
+};
+typedef struct remote_interface_lookup_by_mac_string_args remote_interface_lookup_by_mac_string_args;
+
+struct remote_interface_lookup_by_mac_string_ret {
+ remote_nonnull_interface iface;
+};
+typedef struct remote_interface_lookup_by_mac_string_ret remote_interface_lookup_by_mac_string_ret;
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface iface;
+ u_int flags;
+};
+typedef struct remote_interface_get_xml_desc_args remote_interface_get_xml_desc_args;
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_interface_get_xml_desc_ret remote_interface_get_xml_desc_ret;
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ u_int flags;
+};
+typedef struct remote_interface_define_xml_args remote_interface_define_xml_args;
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface iface;
+};
+typedef struct remote_interface_define_xml_ret remote_interface_define_xml_ret;
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface iface;
+};
+typedef struct remote_interface_undefine_args remote_interface_undefine_args;
+
+struct remote_interface_create_args {
+ remote_nonnull_interface iface;
+ u_int flags;
+};
+typedef struct remote_interface_create_args remote_interface_create_args;
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface iface;
+ u_int flags;
+};
+typedef struct remote_interface_destroy_args remote_interface_destroy_args;
+
+struct remote_auth_list_ret {
+ struct {
+ u_int types_len;
+ remote_auth_type *types_val;
+ } types;
+};
+typedef struct remote_auth_list_ret remote_auth_list_ret;
+
+struct remote_auth_sasl_init_ret {
+ remote_nonnull_string mechlist;
+};
+typedef struct remote_auth_sasl_init_ret remote_auth_sasl_init_ret;
+
+struct remote_auth_sasl_start_args {
+ remote_nonnull_string mech;
+ int nil;
+ struct {
+ u_int data_len;
+ char *data_val;
+ } data;
+};
+typedef struct remote_auth_sasl_start_args remote_auth_sasl_start_args;
+
+struct remote_auth_sasl_start_ret {
+ int complete;
+ int nil;
+ struct {
+ u_int data_len;
+ char *data_val;
+ } data;
+};
+typedef struct remote_auth_sasl_start_ret remote_auth_sasl_start_ret;
+
+struct remote_auth_sasl_step_args {
+ int nil;
+ struct {
+ u_int data_len;
+ char *data_val;
+ } data;
+};
+typedef struct remote_auth_sasl_step_args remote_auth_sasl_step_args;
+
+struct remote_auth_sasl_step_ret {
+ int complete;
+ int nil;
+ struct {
+ u_int data_len;
+ char *data_val;
+ } data;
+};
+typedef struct remote_auth_sasl_step_ret remote_auth_sasl_step_ret;
+
+struct remote_auth_polkit_ret {
+ int complete;
+};
+typedef struct remote_auth_polkit_ret remote_auth_polkit_ret;
+
+struct remote_num_of_storage_pools_ret {
+ int num;
+};
+typedef struct remote_num_of_storage_pools_ret remote_num_of_storage_pools_ret;
+
+struct remote_list_storage_pools_args {
+ int maxnames;
+};
+typedef struct remote_list_storage_pools_args remote_list_storage_pools_args;
+
+struct remote_list_storage_pools_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_storage_pools_ret remote_list_storage_pools_ret;
+
+struct remote_num_of_defined_storage_pools_ret {
+ int num;
+};
+typedef struct remote_num_of_defined_storage_pools_ret remote_num_of_defined_storage_pools_ret;
+
+struct remote_list_defined_storage_pools_args {
+ int maxnames;
+};
+typedef struct remote_list_defined_storage_pools_args remote_list_defined_storage_pools_args;
+
+struct remote_list_defined_storage_pools_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_defined_storage_pools_ret remote_list_defined_storage_pools_ret;
+
+struct remote_find_storage_pool_sources_args {
+ remote_nonnull_string type;
+ remote_string srcSpec;
+ u_int flags;
+};
+typedef struct remote_find_storage_pool_sources_args remote_find_storage_pool_sources_args;
+
+struct remote_find_storage_pool_sources_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_find_storage_pool_sources_ret remote_find_storage_pool_sources_ret;
+
+struct remote_storage_pool_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+typedef struct remote_storage_pool_lookup_by_uuid_args remote_storage_pool_lookup_by_uuid_args;
+
+struct remote_storage_pool_lookup_by_uuid_ret {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_lookup_by_uuid_ret remote_storage_pool_lookup_by_uuid_ret;
+
+struct remote_storage_pool_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_storage_pool_lookup_by_name_args remote_storage_pool_lookup_by_name_args;
+
+struct remote_storage_pool_lookup_by_name_ret {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_lookup_by_name_ret remote_storage_pool_lookup_by_name_ret;
+
+struct remote_storage_pool_lookup_by_volume_args {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_pool_lookup_by_volume_args remote_storage_pool_lookup_by_volume_args;
+
+struct remote_storage_pool_lookup_by_volume_ret {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_lookup_by_volume_ret remote_storage_pool_lookup_by_volume_ret;
+
+struct remote_storage_pool_create_xml_args {
+ remote_nonnull_string xml;
+ u_int flags;
+};
+typedef struct remote_storage_pool_create_xml_args remote_storage_pool_create_xml_args;
+
+struct remote_storage_pool_create_xml_ret {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_create_xml_ret remote_storage_pool_create_xml_ret;
+
+struct remote_storage_pool_define_xml_args {
+ remote_nonnull_string xml;
+ u_int flags;
+};
+typedef struct remote_storage_pool_define_xml_args remote_storage_pool_define_xml_args;
+
+struct remote_storage_pool_define_xml_ret {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_define_xml_ret remote_storage_pool_define_xml_ret;
+
+struct remote_storage_pool_build_args {
+ remote_nonnull_storage_pool pool;
+ u_int flags;
+};
+typedef struct remote_storage_pool_build_args remote_storage_pool_build_args;
+
+struct remote_storage_pool_undefine_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_undefine_args remote_storage_pool_undefine_args;
+
+struct remote_storage_pool_create_args {
+ remote_nonnull_storage_pool pool;
+ u_int flags;
+};
+typedef struct remote_storage_pool_create_args remote_storage_pool_create_args;
+
+struct remote_storage_pool_destroy_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_destroy_args remote_storage_pool_destroy_args;
+
+struct remote_storage_pool_delete_args {
+ remote_nonnull_storage_pool pool;
+ u_int flags;
+};
+typedef struct remote_storage_pool_delete_args remote_storage_pool_delete_args;
+
+struct remote_storage_pool_refresh_args {
+ remote_nonnull_storage_pool pool;
+ u_int flags;
+};
+typedef struct remote_storage_pool_refresh_args remote_storage_pool_refresh_args;
+
+struct remote_storage_pool_dump_xml_args {
+ remote_nonnull_storage_pool pool;
+ u_int flags;
+};
+typedef struct remote_storage_pool_dump_xml_args remote_storage_pool_dump_xml_args;
+
+struct remote_storage_pool_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_storage_pool_dump_xml_ret remote_storage_pool_dump_xml_ret;
+
+struct remote_storage_pool_get_info_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_get_info_args remote_storage_pool_get_info_args;
+
+struct remote_storage_pool_get_info_ret {
+ u_char state;
+ uint64_t capacity;
+ uint64_t allocation;
+ uint64_t available;
+};
+typedef struct remote_storage_pool_get_info_ret remote_storage_pool_get_info_ret;
+
+struct remote_storage_pool_get_autostart_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_get_autostart_args remote_storage_pool_get_autostart_args;
+
+struct remote_storage_pool_get_autostart_ret {
+ int autostart;
+};
+typedef struct remote_storage_pool_get_autostart_ret remote_storage_pool_get_autostart_ret;
+
+struct remote_storage_pool_set_autostart_args {
+ remote_nonnull_storage_pool pool;
+ int autostart;
+};
+typedef struct remote_storage_pool_set_autostart_args remote_storage_pool_set_autostart_args;
+
+struct remote_storage_pool_num_of_volumes_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_num_of_volumes_args remote_storage_pool_num_of_volumes_args;
+
+struct remote_storage_pool_num_of_volumes_ret {
+ int num;
+};
+typedef struct remote_storage_pool_num_of_volumes_ret remote_storage_pool_num_of_volumes_ret;
+
+struct remote_storage_pool_list_volumes_args {
+ remote_nonnull_storage_pool pool;
+ int maxnames;
+};
+typedef struct remote_storage_pool_list_volumes_args remote_storage_pool_list_volumes_args;
+
+struct remote_storage_pool_list_volumes_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_storage_pool_list_volumes_ret remote_storage_pool_list_volumes_ret;
+
+struct remote_storage_vol_lookup_by_name_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string name;
+};
+typedef struct remote_storage_vol_lookup_by_name_args remote_storage_vol_lookup_by_name_args;
+
+struct remote_storage_vol_lookup_by_name_ret {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_lookup_by_name_ret remote_storage_vol_lookup_by_name_ret;
+
+struct remote_storage_vol_lookup_by_key_args {
+ remote_nonnull_string key;
+};
+typedef struct remote_storage_vol_lookup_by_key_args remote_storage_vol_lookup_by_key_args;
+
+struct remote_storage_vol_lookup_by_key_ret {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_lookup_by_key_ret remote_storage_vol_lookup_by_key_ret;
+
+struct remote_storage_vol_lookup_by_path_args {
+ remote_nonnull_string path;
+};
+typedef struct remote_storage_vol_lookup_by_path_args remote_storage_vol_lookup_by_path_args;
+
+struct remote_storage_vol_lookup_by_path_ret {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_lookup_by_path_ret remote_storage_vol_lookup_by_path_ret;
+
+struct remote_storage_vol_create_xml_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string xml;
+ u_int flags;
+};
+typedef struct remote_storage_vol_create_xml_args remote_storage_vol_create_xml_args;
+
+struct remote_storage_vol_create_xml_ret {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_create_xml_ret remote_storage_vol_create_xml_ret;
+
+struct remote_storage_vol_create_xml_from_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string xml;
+ remote_nonnull_storage_vol clonevol;
+ u_int flags;
+};
+typedef struct remote_storage_vol_create_xml_from_args remote_storage_vol_create_xml_from_args;
+
+struct remote_storage_vol_create_xml_from_ret {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_create_xml_from_ret remote_storage_vol_create_xml_from_ret;
+
+struct remote_storage_vol_delete_args {
+ remote_nonnull_storage_vol vol;
+ u_int flags;
+};
+typedef struct remote_storage_vol_delete_args remote_storage_vol_delete_args;
+
+struct remote_storage_vol_dump_xml_args {
+ remote_nonnull_storage_vol vol;
+ u_int flags;
+};
+typedef struct remote_storage_vol_dump_xml_args remote_storage_vol_dump_xml_args;
+
+struct remote_storage_vol_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_storage_vol_dump_xml_ret remote_storage_vol_dump_xml_ret;
+
+struct remote_storage_vol_get_info_args {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_get_info_args remote_storage_vol_get_info_args;
+
+struct remote_storage_vol_get_info_ret {
+ char type;
+ uint64_t capacity;
+ uint64_t allocation;
+};
+typedef struct remote_storage_vol_get_info_ret remote_storage_vol_get_info_ret;
+
+struct remote_storage_vol_get_path_args {
+ remote_nonnull_storage_vol vol;
+};
+typedef struct remote_storage_vol_get_path_args remote_storage_vol_get_path_args;
+
+struct remote_storage_vol_get_path_ret {
+ remote_nonnull_string name;
+};
+typedef struct remote_storage_vol_get_path_ret remote_storage_vol_get_path_ret;
+
+struct remote_node_num_of_devices_args {
+ remote_string cap;
+ u_int flags;
+};
+typedef struct remote_node_num_of_devices_args remote_node_num_of_devices_args;
+
+struct remote_node_num_of_devices_ret {
+ int num;
+};
+typedef struct remote_node_num_of_devices_ret remote_node_num_of_devices_ret;
+
+struct remote_node_list_devices_args {
+ remote_string cap;
+ int maxnames;
+ u_int flags;
+};
+typedef struct remote_node_list_devices_args remote_node_list_devices_args;
+
+struct remote_node_list_devices_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_node_list_devices_ret remote_node_list_devices_ret;
+
+struct remote_node_device_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_lookup_by_name_args remote_node_device_lookup_by_name_args;
+
+struct remote_node_device_lookup_by_name_ret {
+ remote_nonnull_node_device dev;
+};
+typedef struct remote_node_device_lookup_by_name_ret remote_node_device_lookup_by_name_ret;
+
+struct remote_node_device_dump_xml_args {
+ remote_nonnull_string name;
+ u_int flags;
+};
+typedef struct remote_node_device_dump_xml_args remote_node_device_dump_xml_args;
+
+struct remote_node_device_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_node_device_dump_xml_ret remote_node_device_dump_xml_ret;
+
+struct remote_node_device_get_parent_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_get_parent_args remote_node_device_get_parent_args;
+
+struct remote_node_device_get_parent_ret {
+ remote_string parent;
+};
+typedef struct remote_node_device_get_parent_ret remote_node_device_get_parent_ret;
+
+struct remote_node_device_num_of_caps_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_num_of_caps_args remote_node_device_num_of_caps_args;
+
+struct remote_node_device_num_of_caps_ret {
+ int num;
+};
+typedef struct remote_node_device_num_of_caps_ret remote_node_device_num_of_caps_ret;
+
+struct remote_node_device_list_caps_args {
+ remote_nonnull_string name;
+ int maxnames;
+};
+typedef struct remote_node_device_list_caps_args remote_node_device_list_caps_args;
+
+struct remote_node_device_list_caps_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_node_device_list_caps_ret remote_node_device_list_caps_ret;
+
+struct remote_node_device_dettach_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_dettach_args remote_node_device_dettach_args;
+
+struct remote_node_device_re_attach_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_re_attach_args remote_node_device_re_attach_args;
+
+struct remote_node_device_reset_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_reset_args remote_node_device_reset_args;
+
+struct remote_node_device_create_xml_args {
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+typedef struct remote_node_device_create_xml_args remote_node_device_create_xml_args;
+
+struct remote_node_device_create_xml_ret {
+ remote_nonnull_node_device dev;
+};
+typedef struct remote_node_device_create_xml_ret remote_node_device_create_xml_ret;
+
+struct remote_node_device_destroy_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_node_device_destroy_args remote_node_device_destroy_args;
+
+struct remote_domain_events_register_ret {
+ int cb_registered;
+};
+typedef struct remote_domain_events_register_ret remote_domain_events_register_ret;
+
+struct remote_domain_events_deregister_ret {
+ int cb_registered;
+};
+typedef struct remote_domain_events_deregister_ret remote_domain_events_deregister_ret;
+
+struct remote_domain_event_msg {
+ remote_nonnull_domain dom;
+ int event;
+ int detail;
+};
+typedef struct remote_domain_event_msg remote_domain_event_msg;
+
+struct remote_domain_xml_from_native_args {
+ remote_nonnull_string nativeFormat;
+ remote_nonnull_string nativeConfig;
+ u_int flags;
+};
+typedef struct remote_domain_xml_from_native_args remote_domain_xml_from_native_args;
+
+struct remote_domain_xml_from_native_ret {
+ remote_nonnull_string domainXml;
+};
+typedef struct remote_domain_xml_from_native_ret remote_domain_xml_from_native_ret;
+
+struct remote_domain_xml_to_native_args {
+ remote_nonnull_string nativeFormat;
+ remote_nonnull_string domainXml;
+ u_int flags;
+};
+typedef struct remote_domain_xml_to_native_args remote_domain_xml_to_native_args;
+
+struct remote_domain_xml_to_native_ret {
+ remote_nonnull_string nativeConfig;
+};
+typedef struct remote_domain_xml_to_native_ret remote_domain_xml_to_native_ret;
+
+struct remote_num_of_secrets_ret {
+ int num;
+};
+typedef struct remote_num_of_secrets_ret remote_num_of_secrets_ret;
+
+struct remote_list_secrets_args {
+ int maxuuids;
+};
+typedef struct remote_list_secrets_args remote_list_secrets_args;
+
+struct remote_list_secrets_ret {
+ struct {
+ u_int uuids_len;
+ remote_nonnull_string *uuids_val;
+ } uuids;
+};
+typedef struct remote_list_secrets_ret remote_list_secrets_ret;
+
+struct remote_secret_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+typedef struct remote_secret_lookup_by_uuid_args remote_secret_lookup_by_uuid_args;
+
+struct remote_secret_lookup_by_uuid_ret {
+ remote_nonnull_secret secret;
+};
+typedef struct remote_secret_lookup_by_uuid_ret remote_secret_lookup_by_uuid_ret;
+
+struct remote_secret_define_xml_args {
+ remote_nonnull_string xml;
+ u_int flags;
+};
+typedef struct remote_secret_define_xml_args remote_secret_define_xml_args;
+
+struct remote_secret_define_xml_ret {
+ remote_nonnull_secret secret;
+};
+typedef struct remote_secret_define_xml_ret remote_secret_define_xml_ret;
+
+struct remote_secret_get_xml_desc_args {
+ remote_nonnull_secret secret;
+ u_int flags;
+};
+typedef struct remote_secret_get_xml_desc_args remote_secret_get_xml_desc_args;
+
+struct remote_secret_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_secret_get_xml_desc_ret remote_secret_get_xml_desc_ret;
+
+struct remote_secret_set_value_args {
+ remote_nonnull_secret secret;
+ struct {
+ u_int value_len;
+ char *value_val;
+ } value;
+ u_int flags;
+};
+typedef struct remote_secret_set_value_args remote_secret_set_value_args;
+
+struct remote_secret_get_value_args {
+ remote_nonnull_secret secret;
+ u_int flags;
+};
+typedef struct remote_secret_get_value_args remote_secret_get_value_args;
+
+struct remote_secret_get_value_ret {
+ struct {
+ u_int value_len;
+ char *value_val;
+ } value;
+};
+typedef struct remote_secret_get_value_ret remote_secret_get_value_ret;
+
+struct remote_secret_undefine_args {
+ remote_nonnull_secret secret;
+};
+typedef struct remote_secret_undefine_args remote_secret_undefine_args;
+
+struct remote_secret_lookup_by_usage_args {
+ int usageType;
+ remote_nonnull_string usageID;
+};
+typedef struct remote_secret_lookup_by_usage_args remote_secret_lookup_by_usage_args;
+
+struct remote_secret_lookup_by_usage_ret {
+ remote_nonnull_secret secret;
+};
+typedef struct remote_secret_lookup_by_usage_ret remote_secret_lookup_by_usage_ret;
+#define REMOTE_PROGRAM 0x20008086
+#define REMOTE_PROTOCOL_VERSION 1
+
+enum remote_procedure {
+ REMOTE_PROC_OPEN = 1,
+ REMOTE_PROC_CLOSE = 2,
+ REMOTE_PROC_GET_TYPE = 3,
+ REMOTE_PROC_GET_VERSION = 4,
+ REMOTE_PROC_GET_MAX_VCPUS = 5,
+ REMOTE_PROC_NODE_GET_INFO = 6,
+ REMOTE_PROC_GET_CAPABILITIES = 7,
+ REMOTE_PROC_DOMAIN_ATTACH_DEVICE = 8,
+ REMOTE_PROC_DOMAIN_CREATE = 9,
+ REMOTE_PROC_DOMAIN_CREATE_XML = 10,
+ REMOTE_PROC_DOMAIN_DEFINE_XML = 11,
+ REMOTE_PROC_DOMAIN_DESTROY = 12,
+ REMOTE_PROC_DOMAIN_DETACH_DEVICE = 13,
+ REMOTE_PROC_DOMAIN_DUMP_XML = 14,
+ REMOTE_PROC_DOMAIN_GET_AUTOSTART = 15,
+ REMOTE_PROC_DOMAIN_GET_INFO = 16,
+ REMOTE_PROC_DOMAIN_GET_MAX_MEMORY = 17,
+ REMOTE_PROC_DOMAIN_GET_MAX_VCPUS = 18,
+ REMOTE_PROC_DOMAIN_GET_OS_TYPE = 19,
+ REMOTE_PROC_DOMAIN_GET_VCPUS = 20,
+ REMOTE_PROC_LIST_DEFINED_DOMAINS = 21,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_ID = 22,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME = 23,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID = 24,
+ REMOTE_PROC_NUM_OF_DEFINED_DOMAINS = 25,
+ REMOTE_PROC_DOMAIN_PIN_VCPU = 26,
+ REMOTE_PROC_DOMAIN_REBOOT = 27,
+ REMOTE_PROC_DOMAIN_RESUME = 28,
+ REMOTE_PROC_DOMAIN_SET_AUTOSTART = 29,
+ REMOTE_PROC_DOMAIN_SET_MAX_MEMORY = 30,
+ REMOTE_PROC_DOMAIN_SET_MEMORY = 31,
+ REMOTE_PROC_DOMAIN_SET_VCPUS = 32,
+ REMOTE_PROC_DOMAIN_SHUTDOWN = 33,
+ REMOTE_PROC_DOMAIN_SUSPEND = 34,
+ REMOTE_PROC_DOMAIN_UNDEFINE = 35,
+ REMOTE_PROC_LIST_DEFINED_NETWORKS = 36,
+ REMOTE_PROC_LIST_DOMAINS = 37,
+ REMOTE_PROC_LIST_NETWORKS = 38,
+ REMOTE_PROC_NETWORK_CREATE = 39,
+ REMOTE_PROC_NETWORK_CREATE_XML = 40,
+ REMOTE_PROC_NETWORK_DEFINE_XML = 41,
+ REMOTE_PROC_NETWORK_DESTROY = 42,
+ REMOTE_PROC_NETWORK_DUMP_XML = 43,
+ REMOTE_PROC_NETWORK_GET_AUTOSTART = 44,
+ REMOTE_PROC_NETWORK_GET_BRIDGE_NAME = 45,
+ REMOTE_PROC_NETWORK_LOOKUP_BY_NAME = 46,
+ REMOTE_PROC_NETWORK_LOOKUP_BY_UUID = 47,
+ REMOTE_PROC_NETWORK_SET_AUTOSTART = 48,
+ REMOTE_PROC_NETWORK_UNDEFINE = 49,
+ REMOTE_PROC_NUM_OF_DEFINED_NETWORKS = 50,
+ REMOTE_PROC_NUM_OF_DOMAINS = 51,
+ REMOTE_PROC_NUM_OF_NETWORKS = 52,
+ REMOTE_PROC_DOMAIN_CORE_DUMP = 53,
+ REMOTE_PROC_DOMAIN_RESTORE = 54,
+ REMOTE_PROC_DOMAIN_SAVE = 55,
+ REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE = 56,
+ REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS = 57,
+ REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS = 58,
+ REMOTE_PROC_GET_HOSTNAME = 59,
+ REMOTE_PROC_SUPPORTS_FEATURE = 60,
+ REMOTE_PROC_DOMAIN_MIGRATE_PREPARE = 61,
+ REMOTE_PROC_DOMAIN_MIGRATE_PERFORM = 62,
+ REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
+ REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
+ REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
+ REMOTE_PROC_AUTH_LIST = 66,
+ REMOTE_PROC_AUTH_SASL_INIT = 67,
+ REMOTE_PROC_AUTH_SASL_START = 68,
+ REMOTE_PROC_AUTH_SASL_STEP = 69,
+ REMOTE_PROC_AUTH_POLKIT = 70,
+ REMOTE_PROC_NUM_OF_STORAGE_POOLS = 71,
+ REMOTE_PROC_LIST_STORAGE_POOLS = 72,
+ REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 73,
+ REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 74,
+ REMOTE_PROC_FIND_STORAGE_POOL_SOURCES = 75,
+ REMOTE_PROC_STORAGE_POOL_CREATE_XML = 76,
+ REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 77,
+ REMOTE_PROC_STORAGE_POOL_CREATE = 78,
+ REMOTE_PROC_STORAGE_POOL_BUILD = 79,
+ REMOTE_PROC_STORAGE_POOL_DESTROY = 80,
+ REMOTE_PROC_STORAGE_POOL_DELETE = 81,
+ REMOTE_PROC_STORAGE_POOL_UNDEFINE = 82,
+ REMOTE_PROC_STORAGE_POOL_REFRESH = 83,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 84,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 85,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME = 86,
+ REMOTE_PROC_STORAGE_POOL_GET_INFO = 87,
+ REMOTE_PROC_STORAGE_POOL_DUMP_XML = 88,
+ REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 89,
+ REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 90,
+ REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 91,
+ REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 92,
+ REMOTE_PROC_STORAGE_VOL_CREATE_XML = 93,
+ REMOTE_PROC_STORAGE_VOL_DELETE = 94,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 95,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY = 96,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH = 97,
+ REMOTE_PROC_STORAGE_VOL_GET_INFO = 98,
+ REMOTE_PROC_STORAGE_VOL_DUMP_XML = 99,
+ REMOTE_PROC_STORAGE_VOL_GET_PATH = 100,
+ REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY = 101,
+ REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
+ REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
+ REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
+ REMOTE_PROC_DOMAIN_EVENTS_REGISTER = 105,
+ REMOTE_PROC_DOMAIN_EVENTS_DEREGISTER = 106,
+ REMOTE_PROC_DOMAIN_EVENT = 107,
+ REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2 = 108,
+ REMOTE_PROC_DOMAIN_MIGRATE_FINISH2 = 109,
+ REMOTE_PROC_GET_URI = 110,
+ REMOTE_PROC_NODE_NUM_OF_DEVICES = 111,
+ REMOTE_PROC_NODE_LIST_DEVICES = 112,
+ REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME = 113,
+ REMOTE_PROC_NODE_DEVICE_DUMP_XML = 114,
+ REMOTE_PROC_NODE_DEVICE_GET_PARENT = 115,
+ REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS = 116,
+ REMOTE_PROC_NODE_DEVICE_LIST_CAPS = 117,
+ REMOTE_PROC_NODE_DEVICE_DETTACH = 118,
+ REMOTE_PROC_NODE_DEVICE_RE_ATTACH = 119,
+ REMOTE_PROC_NODE_DEVICE_RESET = 120,
+ REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL = 121,
+ REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
+ REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
+ REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+ REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM = 125,
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134,
+ REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
+ REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
+ REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
+ REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
+ REMOTE_PROC_NUM_OF_SECRETS = 139,
+ REMOTE_PROC_LIST_SECRETS = 140,
+ REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
+ REMOTE_PROC_SECRET_DEFINE_XML = 142,
+ REMOTE_PROC_SECRET_GET_XML_DESC = 143,
+ REMOTE_PROC_SECRET_SET_VALUE = 144,
+ REMOTE_PROC_SECRET_GET_VALUE = 145,
+ REMOTE_PROC_SECRET_UNDEFINE = 146,
+ REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
+};
+typedef enum remote_procedure remote_procedure;
+
+enum remote_message_type {
+ REMOTE_CALL = 0,
+ REMOTE_REPLY = 1,
+ REMOTE_MESSAGE = 2,
+};
+typedef enum remote_message_type remote_message_type;
+
+enum remote_message_status {
+ REMOTE_OK = 0,
+ REMOTE_ERROR = 1,
+};
+typedef enum remote_message_status remote_message_status;
+#define REMOTE_MESSAGE_HEADER_XDR_LEN 4
+
+struct remote_message_header {
+ u_int prog;
+ u_int vers;
+ remote_procedure proc;
+ remote_message_type type;
+ u_int serial;
+ remote_message_status status;
+};
+typedef struct remote_message_header remote_message_header;
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern bool_t xdr_remote_nonnull_string (XDR *, remote_nonnull_string*);
+extern bool_t xdr_remote_string (XDR *, remote_string*);
+extern bool_t xdr_remote_uuid (XDR *, remote_uuid);
+extern bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*);
+extern bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*);
+extern bool_t xdr_remote_nonnull_interface (XDR *, remote_nonnull_interface*);
+extern bool_t xdr_remote_nonnull_storage_pool (XDR *, remote_nonnull_storage_pool*);
+extern bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
+extern bool_t xdr_remote_nonnull_node_device (XDR *, remote_nonnull_node_device*);
+extern bool_t xdr_remote_nonnull_secret (XDR *, remote_nonnull_secret*);
+extern bool_t xdr_remote_domain (XDR *, remote_domain*);
+extern bool_t xdr_remote_network (XDR *, remote_network*);
+extern bool_t xdr_remote_storage_pool (XDR *, remote_storage_pool*);
+extern bool_t xdr_remote_storage_vol (XDR *, remote_storage_vol*);
+extern bool_t xdr_remote_node_device (XDR *, remote_node_device*);
+extern bool_t xdr_remote_error (XDR *, remote_error*);
+extern bool_t xdr_remote_auth_type (XDR *, remote_auth_type*);
+extern bool_t xdr_remote_vcpu_info (XDR *, remote_vcpu_info*);
+extern bool_t xdr_remote_sched_param_value (XDR *, remote_sched_param_value*);
+extern bool_t xdr_remote_sched_param (XDR *, remote_sched_param*);
+extern bool_t xdr_remote_open_args (XDR *, remote_open_args*);
+extern bool_t xdr_remote_supports_feature_args (XDR *, remote_supports_feature_args*);
+extern bool_t xdr_remote_supports_feature_ret (XDR *, remote_supports_feature_ret*);
+extern bool_t xdr_remote_get_type_ret (XDR *, remote_get_type_ret*);
+extern bool_t xdr_remote_get_version_ret (XDR *, remote_get_version_ret*);
+extern bool_t xdr_remote_get_hostname_ret (XDR *, remote_get_hostname_ret*);
+extern bool_t xdr_remote_get_uri_ret (XDR *, remote_get_uri_ret*);
+extern bool_t xdr_remote_get_max_vcpus_args (XDR *, remote_get_max_vcpus_args*);
+extern bool_t xdr_remote_get_max_vcpus_ret (XDR *, remote_get_max_vcpus_ret*);
+extern bool_t xdr_remote_node_get_info_ret (XDR *, remote_node_get_info_ret*);
+extern bool_t xdr_remote_get_capabilities_ret (XDR *, remote_get_capabilities_ret*);
+extern bool_t xdr_remote_node_get_cells_free_memory_args (XDR *, remote_node_get_cells_free_memory_args*);
+extern bool_t xdr_remote_node_get_cells_free_memory_ret (XDR *, remote_node_get_cells_free_memory_ret*);
+extern bool_t xdr_remote_node_get_free_memory_ret (XDR *, remote_node_get_free_memory_ret*);
+extern bool_t xdr_remote_domain_get_scheduler_type_args (XDR *, remote_domain_get_scheduler_type_args*);
+extern bool_t xdr_remote_domain_get_scheduler_type_ret (XDR *, remote_domain_get_scheduler_type_ret*);
+extern bool_t xdr_remote_domain_get_scheduler_parameters_args (XDR *, remote_domain_get_scheduler_parameters_args*);
+extern bool_t xdr_remote_domain_get_scheduler_parameters_ret (XDR *, remote_domain_get_scheduler_parameters_ret*);
+extern bool_t xdr_remote_domain_set_scheduler_parameters_args (XDR *, remote_domain_set_scheduler_parameters_args*);
+extern bool_t xdr_remote_domain_block_stats_args (XDR *, remote_domain_block_stats_args*);
+extern bool_t xdr_remote_domain_block_stats_ret (XDR *, remote_domain_block_stats_ret*);
+extern bool_t xdr_remote_domain_interface_stats_args (XDR *, remote_domain_interface_stats_args*);
+extern bool_t xdr_remote_domain_interface_stats_ret (XDR *, remote_domain_interface_stats_ret*);
+extern bool_t xdr_remote_domain_block_peek_args (XDR *, remote_domain_block_peek_args*);
+extern bool_t xdr_remote_domain_block_peek_ret (XDR *, remote_domain_block_peek_ret*);
+extern bool_t xdr_remote_domain_memory_peek_args (XDR *, remote_domain_memory_peek_args*);
+extern bool_t xdr_remote_domain_memory_peek_ret (XDR *, remote_domain_memory_peek_ret*);
+extern bool_t xdr_remote_list_domains_args (XDR *, remote_list_domains_args*);
+extern bool_t xdr_remote_list_domains_ret (XDR *, remote_list_domains_ret*);
+extern bool_t xdr_remote_num_of_domains_ret (XDR *, remote_num_of_domains_ret*);
+extern bool_t xdr_remote_domain_create_xml_args (XDR *, remote_domain_create_xml_args*);
+extern bool_t xdr_remote_domain_create_xml_ret (XDR *, remote_domain_create_xml_ret*);
+extern bool_t xdr_remote_domain_lookup_by_id_args (XDR *, remote_domain_lookup_by_id_args*);
+extern bool_t xdr_remote_domain_lookup_by_id_ret (XDR *, remote_domain_lookup_by_id_ret*);
+extern bool_t xdr_remote_domain_lookup_by_uuid_args (XDR *, remote_domain_lookup_by_uuid_args*);
+extern bool_t xdr_remote_domain_lookup_by_uuid_ret (XDR *, remote_domain_lookup_by_uuid_ret*);
+extern bool_t xdr_remote_domain_lookup_by_name_args (XDR *, remote_domain_lookup_by_name_args*);
+extern bool_t xdr_remote_domain_lookup_by_name_ret (XDR *, remote_domain_lookup_by_name_ret*);
+extern bool_t xdr_remote_domain_suspend_args (XDR *, remote_domain_suspend_args*);
+extern bool_t xdr_remote_domain_resume_args (XDR *, remote_domain_resume_args*);
+extern bool_t xdr_remote_domain_shutdown_args (XDR *, remote_domain_shutdown_args*);
+extern bool_t xdr_remote_domain_reboot_args (XDR *, remote_domain_reboot_args*);
+extern bool_t xdr_remote_domain_destroy_args (XDR *, remote_domain_destroy_args*);
+extern bool_t xdr_remote_domain_get_os_type_args (XDR *, remote_domain_get_os_type_args*);
+extern bool_t xdr_remote_domain_get_os_type_ret (XDR *, remote_domain_get_os_type_ret*);
+extern bool_t xdr_remote_domain_get_max_memory_args (XDR *, remote_domain_get_max_memory_args*);
+extern bool_t xdr_remote_domain_get_max_memory_ret (XDR *, remote_domain_get_max_memory_ret*);
+extern bool_t xdr_remote_domain_set_max_memory_args (XDR *, remote_domain_set_max_memory_args*);
+extern bool_t xdr_remote_domain_set_memory_args (XDR *, remote_domain_set_memory_args*);
+extern bool_t xdr_remote_domain_get_info_args (XDR *, remote_domain_get_info_args*);
+extern bool_t xdr_remote_domain_get_info_ret (XDR *, remote_domain_get_info_ret*);
+extern bool_t xdr_remote_domain_save_args (XDR *, remote_domain_save_args*);
+extern bool_t xdr_remote_domain_restore_args (XDR *, remote_domain_restore_args*);
+extern bool_t xdr_remote_domain_core_dump_args (XDR *, remote_domain_core_dump_args*);
+extern bool_t xdr_remote_domain_dump_xml_args (XDR *, remote_domain_dump_xml_args*);
+extern bool_t xdr_remote_domain_dump_xml_ret (XDR *, remote_domain_dump_xml_ret*);
+extern bool_t xdr_remote_domain_migrate_prepare_args (XDR *, remote_domain_migrate_prepare_args*);
+extern bool_t xdr_remote_domain_migrate_prepare_ret (XDR *, remote_domain_migrate_prepare_ret*);
+extern bool_t xdr_remote_domain_migrate_perform_args (XDR *, remote_domain_migrate_perform_args*);
+extern bool_t xdr_remote_domain_migrate_finish_args (XDR *, remote_domain_migrate_finish_args*);
+extern bool_t xdr_remote_domain_migrate_finish_ret (XDR *, remote_domain_migrate_finish_ret*);
+extern bool_t xdr_remote_domain_migrate_prepare2_args (XDR *, remote_domain_migrate_prepare2_args*);
+extern bool_t xdr_remote_domain_migrate_prepare2_ret (XDR *, remote_domain_migrate_prepare2_ret*);
+extern bool_t xdr_remote_domain_migrate_finish2_args (XDR *, remote_domain_migrate_finish2_args*);
+extern bool_t xdr_remote_domain_migrate_finish2_ret (XDR *, remote_domain_migrate_finish2_ret*);
+extern bool_t xdr_remote_list_defined_domains_args (XDR *, remote_list_defined_domains_args*);
+extern bool_t xdr_remote_list_defined_domains_ret (XDR *, remote_list_defined_domains_ret*);
+extern bool_t xdr_remote_num_of_defined_domains_ret (XDR *, remote_num_of_defined_domains_ret*);
+extern bool_t xdr_remote_domain_create_args (XDR *, remote_domain_create_args*);
+extern bool_t xdr_remote_domain_define_xml_args (XDR *, remote_domain_define_xml_args*);
+extern bool_t xdr_remote_domain_define_xml_ret (XDR *, remote_domain_define_xml_ret*);
+extern bool_t xdr_remote_domain_undefine_args (XDR *, remote_domain_undefine_args*);
+extern bool_t xdr_remote_domain_set_vcpus_args (XDR *, remote_domain_set_vcpus_args*);
+extern bool_t xdr_remote_domain_pin_vcpu_args (XDR *, remote_domain_pin_vcpu_args*);
+extern bool_t xdr_remote_domain_get_vcpus_args (XDR *, remote_domain_get_vcpus_args*);
+extern bool_t xdr_remote_domain_get_vcpus_ret (XDR *, remote_domain_get_vcpus_ret*);
+extern bool_t xdr_remote_domain_get_max_vcpus_args (XDR *, remote_domain_get_max_vcpus_args*);
+extern bool_t xdr_remote_domain_get_max_vcpus_ret (XDR *, remote_domain_get_max_vcpus_ret*);
+extern bool_t xdr_remote_domain_get_security_label_args (XDR *, remote_domain_get_security_label_args*);
+extern bool_t xdr_remote_domain_get_security_label_ret (XDR *, remote_domain_get_security_label_ret*);
+extern bool_t xdr_remote_node_get_security_model_ret (XDR *, remote_node_get_security_model_ret*);
+extern bool_t xdr_remote_domain_attach_device_args (XDR *, remote_domain_attach_device_args*);
+extern bool_t xdr_remote_domain_detach_device_args (XDR *, remote_domain_detach_device_args*);
+extern bool_t xdr_remote_domain_get_autostart_args (XDR *, remote_domain_get_autostart_args*);
+extern bool_t xdr_remote_domain_get_autostart_ret (XDR *, remote_domain_get_autostart_ret*);
+extern bool_t xdr_remote_domain_set_autostart_args (XDR *, remote_domain_set_autostart_args*);
+extern bool_t xdr_remote_num_of_networks_ret (XDR *, remote_num_of_networks_ret*);
+extern bool_t xdr_remote_list_networks_args (XDR *, remote_list_networks_args*);
+extern bool_t xdr_remote_list_networks_ret (XDR *, remote_list_networks_ret*);
+extern bool_t xdr_remote_num_of_defined_networks_ret (XDR *, remote_num_of_defined_networks_ret*);
+extern bool_t xdr_remote_list_defined_networks_args (XDR *, remote_list_defined_networks_args*);
+extern bool_t xdr_remote_list_defined_networks_ret (XDR *, remote_list_defined_networks_ret*);
+extern bool_t xdr_remote_network_lookup_by_uuid_args (XDR *, remote_network_lookup_by_uuid_args*);
+extern bool_t xdr_remote_network_lookup_by_uuid_ret (XDR *, remote_network_lookup_by_uuid_ret*);
+extern bool_t xdr_remote_network_lookup_by_name_args (XDR *, remote_network_lookup_by_name_args*);
+extern bool_t xdr_remote_network_lookup_by_name_ret (XDR *, remote_network_lookup_by_name_ret*);
+extern bool_t xdr_remote_network_create_xml_args (XDR *, remote_network_create_xml_args*);
+extern bool_t xdr_remote_network_create_xml_ret (XDR *, remote_network_create_xml_ret*);
+extern bool_t xdr_remote_network_define_xml_args (XDR *, remote_network_define_xml_args*);
+extern bool_t xdr_remote_network_define_xml_ret (XDR *, remote_network_define_xml_ret*);
+extern bool_t xdr_remote_network_undefine_args (XDR *, remote_network_undefine_args*);
+extern bool_t xdr_remote_network_create_args (XDR *, remote_network_create_args*);
+extern bool_t xdr_remote_network_destroy_args (XDR *, remote_network_destroy_args*);
+extern bool_t xdr_remote_network_dump_xml_args (XDR *, remote_network_dump_xml_args*);
+extern bool_t xdr_remote_network_dump_xml_ret (XDR *, remote_network_dump_xml_ret*);
+extern bool_t xdr_remote_network_get_bridge_name_args (XDR *, remote_network_get_bridge_name_args*);
+extern bool_t xdr_remote_network_get_bridge_name_ret (XDR *, remote_network_get_bridge_name_ret*);
+extern bool_t xdr_remote_network_get_autostart_args (XDR *, remote_network_get_autostart_args*);
+extern bool_t xdr_remote_network_get_autostart_ret (XDR *, remote_network_get_autostart_ret*);
+extern bool_t xdr_remote_network_set_autostart_args (XDR *, remote_network_set_autostart_args*);
+extern bool_t xdr_remote_num_of_interfaces_ret (XDR *, remote_num_of_interfaces_ret*);
+extern bool_t xdr_remote_list_interfaces_args (XDR *, remote_list_interfaces_args*);
+extern bool_t xdr_remote_list_interfaces_ret (XDR *, remote_list_interfaces_ret*);
+extern bool_t xdr_remote_num_of_defined_interfaces_ret (XDR *, remote_num_of_defined_interfaces_ret*);
+extern bool_t xdr_remote_list_defined_interfaces_args (XDR *, remote_list_defined_interfaces_args*);
+extern bool_t xdr_remote_list_defined_interfaces_ret (XDR *, remote_list_defined_interfaces_ret*);
+extern bool_t xdr_remote_interface_lookup_by_name_args (XDR *, remote_interface_lookup_by_name_args*);
+extern bool_t xdr_remote_interface_lookup_by_name_ret (XDR *, remote_interface_lookup_by_name_ret*);
+extern bool_t xdr_remote_interface_lookup_by_mac_string_args (XDR *, remote_interface_lookup_by_mac_string_args*);
+extern bool_t xdr_remote_interface_lookup_by_mac_string_ret (XDR *, remote_interface_lookup_by_mac_string_ret*);
+extern bool_t xdr_remote_interface_get_xml_desc_args (XDR *, remote_interface_get_xml_desc_args*);
+extern bool_t xdr_remote_interface_get_xml_desc_ret (XDR *, remote_interface_get_xml_desc_ret*);
+extern bool_t xdr_remote_interface_define_xml_args (XDR *, remote_interface_define_xml_args*);
+extern bool_t xdr_remote_interface_define_xml_ret (XDR *, remote_interface_define_xml_ret*);
+extern bool_t xdr_remote_interface_undefine_args (XDR *, remote_interface_undefine_args*);
+extern bool_t xdr_remote_interface_create_args (XDR *, remote_interface_create_args*);
+extern bool_t xdr_remote_interface_destroy_args (XDR *, remote_interface_destroy_args*);
+extern bool_t xdr_remote_auth_list_ret (XDR *, remote_auth_list_ret*);
+extern bool_t xdr_remote_auth_sasl_init_ret (XDR *, remote_auth_sasl_init_ret*);
+extern bool_t xdr_remote_auth_sasl_start_args (XDR *, remote_auth_sasl_start_args*);
+extern bool_t xdr_remote_auth_sasl_start_ret (XDR *, remote_auth_sasl_start_ret*);
+extern bool_t xdr_remote_auth_sasl_step_args (XDR *, remote_auth_sasl_step_args*);
+extern bool_t xdr_remote_auth_sasl_step_ret (XDR *, remote_auth_sasl_step_ret*);
+extern bool_t xdr_remote_auth_polkit_ret (XDR *, remote_auth_polkit_ret*);
+extern bool_t xdr_remote_num_of_storage_pools_ret (XDR *, remote_num_of_storage_pools_ret*);
+extern bool_t xdr_remote_list_storage_pools_args (XDR *, remote_list_storage_pools_args*);
+extern bool_t xdr_remote_list_storage_pools_ret (XDR *, remote_list_storage_pools_ret*);
+extern bool_t xdr_remote_num_of_defined_storage_pools_ret (XDR *, remote_num_of_defined_storage_pools_ret*);
+extern bool_t xdr_remote_list_defined_storage_pools_args (XDR *, remote_list_defined_storage_pools_args*);
+extern bool_t xdr_remote_list_defined_storage_pools_ret (XDR *, remote_list_defined_storage_pools_ret*);
+extern bool_t xdr_remote_find_storage_pool_sources_args (XDR *, remote_find_storage_pool_sources_args*);
+extern bool_t xdr_remote_find_storage_pool_sources_ret (XDR *, remote_find_storage_pool_sources_ret*);
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_args (XDR *, remote_storage_pool_lookup_by_uuid_args*);
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *, remote_storage_pool_lookup_by_uuid_ret*);
+extern bool_t xdr_remote_storage_pool_lookup_by_name_args (XDR *, remote_storage_pool_lookup_by_name_args*);
+extern bool_t xdr_remote_storage_pool_lookup_by_name_ret (XDR *, remote_storage_pool_lookup_by_name_ret*);
+extern bool_t xdr_remote_storage_pool_lookup_by_volume_args (XDR *, remote_storage_pool_lookup_by_volume_args*);
+extern bool_t xdr_remote_storage_pool_lookup_by_volume_ret (XDR *, remote_storage_pool_lookup_by_volume_ret*);
+extern bool_t xdr_remote_storage_pool_create_xml_args (XDR *, remote_storage_pool_create_xml_args*);
+extern bool_t xdr_remote_storage_pool_create_xml_ret (XDR *, remote_storage_pool_create_xml_ret*);
+extern bool_t xdr_remote_storage_pool_define_xml_args (XDR *, remote_storage_pool_define_xml_args*);
+extern bool_t xdr_remote_storage_pool_define_xml_ret (XDR *, remote_storage_pool_define_xml_ret*);
+extern bool_t xdr_remote_storage_pool_build_args (XDR *, remote_storage_pool_build_args*);
+extern bool_t xdr_remote_storage_pool_undefine_args (XDR *, remote_storage_pool_undefine_args*);
+extern bool_t xdr_remote_storage_pool_create_args (XDR *, remote_storage_pool_create_args*);
+extern bool_t xdr_remote_storage_pool_destroy_args (XDR *, remote_storage_pool_destroy_args*);
+extern bool_t xdr_remote_storage_pool_delete_args (XDR *, remote_storage_pool_delete_args*);
+extern bool_t xdr_remote_storage_pool_refresh_args (XDR *, remote_storage_pool_refresh_args*);
+extern bool_t xdr_remote_storage_pool_dump_xml_args (XDR *, remote_storage_pool_dump_xml_args*);
+extern bool_t xdr_remote_storage_pool_dump_xml_ret (XDR *, remote_storage_pool_dump_xml_ret*);
+extern bool_t xdr_remote_storage_pool_get_info_args (XDR *, remote_storage_pool_get_info_args*);
+extern bool_t xdr_remote_storage_pool_get_info_ret (XDR *, remote_storage_pool_get_info_ret*);
+extern bool_t xdr_remote_storage_pool_get_autostart_args (XDR *, remote_storage_pool_get_autostart_args*);
+extern bool_t xdr_remote_storage_pool_get_autostart_ret (XDR *, remote_storage_pool_get_autostart_ret*);
+extern bool_t xdr_remote_storage_pool_set_autostart_args (XDR *, remote_storage_pool_set_autostart_args*);
+extern bool_t xdr_remote_storage_pool_num_of_volumes_args (XDR *, remote_storage_pool_num_of_volumes_args*);
+extern bool_t xdr_remote_storage_pool_num_of_volumes_ret (XDR *, remote_storage_pool_num_of_volumes_ret*);
+extern bool_t xdr_remote_storage_pool_list_volumes_args (XDR *, remote_storage_pool_list_volumes_args*);
+extern bool_t xdr_remote_storage_pool_list_volumes_ret (XDR *, remote_storage_pool_list_volumes_ret*);
+extern bool_t xdr_remote_storage_vol_lookup_by_name_args (XDR *, remote_storage_vol_lookup_by_name_args*);
+extern bool_t xdr_remote_storage_vol_lookup_by_name_ret (XDR *, remote_storage_vol_lookup_by_name_ret*);
+extern bool_t xdr_remote_storage_vol_lookup_by_key_args (XDR *, remote_storage_vol_lookup_by_key_args*);
+extern bool_t xdr_remote_storage_vol_lookup_by_key_ret (XDR *, remote_storage_vol_lookup_by_key_ret*);
+extern bool_t xdr_remote_storage_vol_lookup_by_path_args (XDR *, remote_storage_vol_lookup_by_path_args*);
+extern bool_t xdr_remote_storage_vol_lookup_by_path_ret (XDR *, remote_storage_vol_lookup_by_path_ret*);
+extern bool_t xdr_remote_storage_vol_create_xml_args (XDR *, remote_storage_vol_create_xml_args*);
+extern bool_t xdr_remote_storage_vol_create_xml_ret (XDR *, remote_storage_vol_create_xml_ret*);
+extern bool_t xdr_remote_storage_vol_create_xml_from_args (XDR *, remote_storage_vol_create_xml_from_args*);
+extern bool_t xdr_remote_storage_vol_create_xml_from_ret (XDR *, remote_storage_vol_create_xml_from_ret*);
+extern bool_t xdr_remote_storage_vol_delete_args (XDR *, remote_storage_vol_delete_args*);
+extern bool_t xdr_remote_storage_vol_dump_xml_args (XDR *, remote_storage_vol_dump_xml_args*);
+extern bool_t xdr_remote_storage_vol_dump_xml_ret (XDR *, remote_storage_vol_dump_xml_ret*);
+extern bool_t xdr_remote_storage_vol_get_info_args (XDR *, remote_storage_vol_get_info_args*);
+extern bool_t xdr_remote_storage_vol_get_info_ret (XDR *, remote_storage_vol_get_info_ret*);
+extern bool_t xdr_remote_storage_vol_get_path_args (XDR *, remote_storage_vol_get_path_args*);
+extern bool_t xdr_remote_storage_vol_get_path_ret (XDR *, remote_storage_vol_get_path_ret*);
+extern bool_t xdr_remote_node_num_of_devices_args (XDR *, remote_node_num_of_devices_args*);
+extern bool_t xdr_remote_node_num_of_devices_ret (XDR *, remote_node_num_of_devices_ret*);
+extern bool_t xdr_remote_node_list_devices_args (XDR *, remote_node_list_devices_args*);
+extern bool_t xdr_remote_node_list_devices_ret (XDR *, remote_node_list_devices_ret*);
+extern bool_t xdr_remote_node_device_lookup_by_name_args (XDR *, remote_node_device_lookup_by_name_args*);
+extern bool_t xdr_remote_node_device_lookup_by_name_ret (XDR *, remote_node_device_lookup_by_name_ret*);
+extern bool_t xdr_remote_node_device_dump_xml_args (XDR *, remote_node_device_dump_xml_args*);
+extern bool_t xdr_remote_node_device_dump_xml_ret (XDR *, remote_node_device_dump_xml_ret*);
+extern bool_t xdr_remote_node_device_get_parent_args (XDR *, remote_node_device_get_parent_args*);
+extern bool_t xdr_remote_node_device_get_parent_ret (XDR *, remote_node_device_get_parent_ret*);
+extern bool_t xdr_remote_node_device_num_of_caps_args (XDR *, remote_node_device_num_of_caps_args*);
+extern bool_t xdr_remote_node_device_num_of_caps_ret (XDR *, remote_node_device_num_of_caps_ret*);
+extern bool_t xdr_remote_node_device_list_caps_args (XDR *, remote_node_device_list_caps_args*);
+extern bool_t xdr_remote_node_device_list_caps_ret (XDR *, remote_node_device_list_caps_ret*);
+extern bool_t xdr_remote_node_device_dettach_args (XDR *, remote_node_device_dettach_args*);
+extern bool_t xdr_remote_node_device_re_attach_args (XDR *, remote_node_device_re_attach_args*);
+extern bool_t xdr_remote_node_device_reset_args (XDR *, remote_node_device_reset_args*);
+extern bool_t xdr_remote_node_device_create_xml_args (XDR *, remote_node_device_create_xml_args*);
+extern bool_t xdr_remote_node_device_create_xml_ret (XDR *, remote_node_device_create_xml_ret*);
+extern bool_t xdr_remote_node_device_destroy_args (XDR *, remote_node_device_destroy_args*);
+extern bool_t xdr_remote_domain_events_register_ret (XDR *, remote_domain_events_register_ret*);
+extern bool_t xdr_remote_domain_events_deregister_ret (XDR *, remote_domain_events_deregister_ret*);
+extern bool_t xdr_remote_domain_event_msg (XDR *, remote_domain_event_msg*);
+extern bool_t xdr_remote_domain_xml_from_native_args (XDR *, remote_domain_xml_from_native_args*);
+extern bool_t xdr_remote_domain_xml_from_native_ret (XDR *, remote_domain_xml_from_native_ret*);
+extern bool_t xdr_remote_domain_xml_to_native_args (XDR *, remote_domain_xml_to_native_args*);
+extern bool_t xdr_remote_domain_xml_to_native_ret (XDR *, remote_domain_xml_to_native_ret*);
+extern bool_t xdr_remote_num_of_secrets_ret (XDR *, remote_num_of_secrets_ret*);
+extern bool_t xdr_remote_list_secrets_args (XDR *, remote_list_secrets_args*);
+extern bool_t xdr_remote_list_secrets_ret (XDR *, remote_list_secrets_ret*);
+extern bool_t xdr_remote_secret_lookup_by_uuid_args (XDR *, remote_secret_lookup_by_uuid_args*);
+extern bool_t xdr_remote_secret_lookup_by_uuid_ret (XDR *, remote_secret_lookup_by_uuid_ret*);
+extern bool_t xdr_remote_secret_define_xml_args (XDR *, remote_secret_define_xml_args*);
+extern bool_t xdr_remote_secret_define_xml_ret (XDR *, remote_secret_define_xml_ret*);
+extern bool_t xdr_remote_secret_get_xml_desc_args (XDR *, remote_secret_get_xml_desc_args*);
+extern bool_t xdr_remote_secret_get_xml_desc_ret (XDR *, remote_secret_get_xml_desc_ret*);
+extern bool_t xdr_remote_secret_set_value_args (XDR *, remote_secret_set_value_args*);
+extern bool_t xdr_remote_secret_get_value_args (XDR *, remote_secret_get_value_args*);
+extern bool_t xdr_remote_secret_get_value_ret (XDR *, remote_secret_get_value_ret*);
+extern bool_t xdr_remote_secret_undefine_args (XDR *, remote_secret_undefine_args*);
+extern bool_t xdr_remote_secret_lookup_by_usage_args (XDR *, remote_secret_lookup_by_usage_args*);
+extern bool_t xdr_remote_secret_lookup_by_usage_ret (XDR *, remote_secret_lookup_by_usage_ret*);
+extern bool_t xdr_remote_procedure (XDR *, remote_procedure*);
+extern bool_t xdr_remote_message_type (XDR *, remote_message_type*);
+extern bool_t xdr_remote_message_status (XDR *, remote_message_status*);
+extern bool_t xdr_remote_message_header (XDR *, remote_message_header*);
+
+#else /* K&R C */
+extern bool_t xdr_remote_nonnull_string ();
+extern bool_t xdr_remote_string ();
+extern bool_t xdr_remote_uuid ();
+extern bool_t xdr_remote_nonnull_domain ();
+extern bool_t xdr_remote_nonnull_network ();
+extern bool_t xdr_remote_nonnull_interface ();
+extern bool_t xdr_remote_nonnull_storage_pool ();
+extern bool_t xdr_remote_nonnull_storage_vol ();
+extern bool_t xdr_remote_nonnull_node_device ();
+extern bool_t xdr_remote_nonnull_secret ();
+extern bool_t xdr_remote_domain ();
+extern bool_t xdr_remote_network ();
+extern bool_t xdr_remote_storage_pool ();
+extern bool_t xdr_remote_storage_vol ();
+extern bool_t xdr_remote_node_device ();
+extern bool_t xdr_remote_error ();
+extern bool_t xdr_remote_auth_type ();
+extern bool_t xdr_remote_vcpu_info ();
+extern bool_t xdr_remote_sched_param_value ();
+extern bool_t xdr_remote_sched_param ();
+extern bool_t xdr_remote_open_args ();
+extern bool_t xdr_remote_supports_feature_args ();
+extern bool_t xdr_remote_supports_feature_ret ();
+extern bool_t xdr_remote_get_type_ret ();
+extern bool_t xdr_remote_get_version_ret ();
+extern bool_t xdr_remote_get_hostname_ret ();
+extern bool_t xdr_remote_get_uri_ret ();
+extern bool_t xdr_remote_get_max_vcpus_args ();
+extern bool_t xdr_remote_get_max_vcpus_ret ();
+extern bool_t xdr_remote_node_get_info_ret ();
+extern bool_t xdr_remote_get_capabilities_ret ();
+extern bool_t xdr_remote_node_get_cells_free_memory_args ();
+extern bool_t xdr_remote_node_get_cells_free_memory_ret ();
+extern bool_t xdr_remote_node_get_free_memory_ret ();
+extern bool_t xdr_remote_domain_get_scheduler_type_args ();
+extern bool_t xdr_remote_domain_get_scheduler_type_ret ();
+extern bool_t xdr_remote_domain_get_scheduler_parameters_args ();
+extern bool_t xdr_remote_domain_get_scheduler_parameters_ret ();
+extern bool_t xdr_remote_domain_set_scheduler_parameters_args ();
+extern bool_t xdr_remote_domain_block_stats_args ();
+extern bool_t xdr_remote_domain_block_stats_ret ();
+extern bool_t xdr_remote_domain_interface_stats_args ();
+extern bool_t xdr_remote_domain_interface_stats_ret ();
+extern bool_t xdr_remote_domain_block_peek_args ();
+extern bool_t xdr_remote_domain_block_peek_ret ();
+extern bool_t xdr_remote_domain_memory_peek_args ();
+extern bool_t xdr_remote_domain_memory_peek_ret ();
+extern bool_t xdr_remote_list_domains_args ();
+extern bool_t xdr_remote_list_domains_ret ();
+extern bool_t xdr_remote_num_of_domains_ret ();
+extern bool_t xdr_remote_domain_create_xml_args ();
+extern bool_t xdr_remote_domain_create_xml_ret ();
+extern bool_t xdr_remote_domain_lookup_by_id_args ();
+extern bool_t xdr_remote_domain_lookup_by_id_ret ();
+extern bool_t xdr_remote_domain_lookup_by_uuid_args ();
+extern bool_t xdr_remote_domain_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_domain_lookup_by_name_args ();
+extern bool_t xdr_remote_domain_lookup_by_name_ret ();
+extern bool_t xdr_remote_domain_suspend_args ();
+extern bool_t xdr_remote_domain_resume_args ();
+extern bool_t xdr_remote_domain_shutdown_args ();
+extern bool_t xdr_remote_domain_reboot_args ();
+extern bool_t xdr_remote_domain_destroy_args ();
+extern bool_t xdr_remote_domain_get_os_type_args ();
+extern bool_t xdr_remote_domain_get_os_type_ret ();
+extern bool_t xdr_remote_domain_get_max_memory_args ();
+extern bool_t xdr_remote_domain_get_max_memory_ret ();
+extern bool_t xdr_remote_domain_set_max_memory_args ();
+extern bool_t xdr_remote_domain_set_memory_args ();
+extern bool_t xdr_remote_domain_get_info_args ();
+extern bool_t xdr_remote_domain_get_info_ret ();
+extern bool_t xdr_remote_domain_save_args ();
+extern bool_t xdr_remote_domain_restore_args ();
+extern bool_t xdr_remote_domain_core_dump_args ();
+extern bool_t xdr_remote_domain_dump_xml_args ();
+extern bool_t xdr_remote_domain_dump_xml_ret ();
+extern bool_t xdr_remote_domain_migrate_prepare_args ();
+extern bool_t xdr_remote_domain_migrate_prepare_ret ();
+extern bool_t xdr_remote_domain_migrate_perform_args ();
+extern bool_t xdr_remote_domain_migrate_finish_args ();
+extern bool_t xdr_remote_domain_migrate_finish_ret ();
+extern bool_t xdr_remote_domain_migrate_prepare2_args ();
+extern bool_t xdr_remote_domain_migrate_prepare2_ret ();
+extern bool_t xdr_remote_domain_migrate_finish2_args ();
+extern bool_t xdr_remote_domain_migrate_finish2_ret ();
+extern bool_t xdr_remote_list_defined_domains_args ();
+extern bool_t xdr_remote_list_defined_domains_ret ();
+extern bool_t xdr_remote_num_of_defined_domains_ret ();
+extern bool_t xdr_remote_domain_create_args ();
+extern bool_t xdr_remote_domain_define_xml_args ();
+extern bool_t xdr_remote_domain_define_xml_ret ();
+extern bool_t xdr_remote_domain_undefine_args ();
+extern bool_t xdr_remote_domain_set_vcpus_args ();
+extern bool_t xdr_remote_domain_pin_vcpu_args ();
+extern bool_t xdr_remote_domain_get_vcpus_args ();
+extern bool_t xdr_remote_domain_get_vcpus_ret ();
+extern bool_t xdr_remote_domain_get_max_vcpus_args ();
+extern bool_t xdr_remote_domain_get_max_vcpus_ret ();
+extern bool_t xdr_remote_domain_get_security_label_args ();
+extern bool_t xdr_remote_domain_get_security_label_ret ();
+extern bool_t xdr_remote_node_get_security_model_ret ();
+extern bool_t xdr_remote_domain_attach_device_args ();
+extern bool_t xdr_remote_domain_detach_device_args ();
+extern bool_t xdr_remote_domain_get_autostart_args ();
+extern bool_t xdr_remote_domain_get_autostart_ret ();
+extern bool_t xdr_remote_domain_set_autostart_args ();
+extern bool_t xdr_remote_num_of_networks_ret ();
+extern bool_t xdr_remote_list_networks_args ();
+extern bool_t xdr_remote_list_networks_ret ();
+extern bool_t xdr_remote_num_of_defined_networks_ret ();
+extern bool_t xdr_remote_list_defined_networks_args ();
+extern bool_t xdr_remote_list_defined_networks_ret ();
+extern bool_t xdr_remote_network_lookup_by_uuid_args ();
+extern bool_t xdr_remote_network_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_network_lookup_by_name_args ();
+extern bool_t xdr_remote_network_lookup_by_name_ret ();
+extern bool_t xdr_remote_network_create_xml_args ();
+extern bool_t xdr_remote_network_create_xml_ret ();
+extern bool_t xdr_remote_network_define_xml_args ();
+extern bool_t xdr_remote_network_define_xml_ret ();
+extern bool_t xdr_remote_network_undefine_args ();
+extern bool_t xdr_remote_network_create_args ();
+extern bool_t xdr_remote_network_destroy_args ();
+extern bool_t xdr_remote_network_dump_xml_args ();
+extern bool_t xdr_remote_network_dump_xml_ret ();
+extern bool_t xdr_remote_network_get_bridge_name_args ();
+extern bool_t xdr_remote_network_get_bridge_name_ret ();
+extern bool_t xdr_remote_network_get_autostart_args ();
+extern bool_t xdr_remote_network_get_autostart_ret ();
+extern bool_t xdr_remote_network_set_autostart_args ();
+extern bool_t xdr_remote_num_of_interfaces_ret ();
+extern bool_t xdr_remote_list_interfaces_args ();
+extern bool_t xdr_remote_list_interfaces_ret ();
+extern bool_t xdr_remote_num_of_defined_interfaces_ret ();
+extern bool_t xdr_remote_list_defined_interfaces_args ();
+extern bool_t xdr_remote_list_defined_interfaces_ret ();
+extern bool_t xdr_remote_interface_lookup_by_name_args ();
+extern bool_t xdr_remote_interface_lookup_by_name_ret ();
+extern bool_t xdr_remote_interface_lookup_by_mac_string_args ();
+extern bool_t xdr_remote_interface_lookup_by_mac_string_ret ();
+extern bool_t xdr_remote_interface_get_xml_desc_args ();
+extern bool_t xdr_remote_interface_get_xml_desc_ret ();
+extern bool_t xdr_remote_interface_define_xml_args ();
+extern bool_t xdr_remote_interface_define_xml_ret ();
+extern bool_t xdr_remote_interface_undefine_args ();
+extern bool_t xdr_remote_interface_create_args ();
+extern bool_t xdr_remote_interface_destroy_args ();
+extern bool_t xdr_remote_auth_list_ret ();
+extern bool_t xdr_remote_auth_sasl_init_ret ();
+extern bool_t xdr_remote_auth_sasl_start_args ();
+extern bool_t xdr_remote_auth_sasl_start_ret ();
+extern bool_t xdr_remote_auth_sasl_step_args ();
+extern bool_t xdr_remote_auth_sasl_step_ret ();
+extern bool_t xdr_remote_auth_polkit_ret ();
+extern bool_t xdr_remote_num_of_storage_pools_ret ();
+extern bool_t xdr_remote_list_storage_pools_args ();
+extern bool_t xdr_remote_list_storage_pools_ret ();
+extern bool_t xdr_remote_num_of_defined_storage_pools_ret ();
+extern bool_t xdr_remote_list_defined_storage_pools_args ();
+extern bool_t xdr_remote_list_defined_storage_pools_ret ();
+extern bool_t xdr_remote_find_storage_pool_sources_args ();
+extern bool_t xdr_remote_find_storage_pool_sources_ret ();
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_args ();
+extern bool_t xdr_remote_storage_pool_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_storage_pool_lookup_by_name_args ();
+extern bool_t xdr_remote_storage_pool_lookup_by_name_ret ();
+extern bool_t xdr_remote_storage_pool_lookup_by_volume_args ();
+extern bool_t xdr_remote_storage_pool_lookup_by_volume_ret ();
+extern bool_t xdr_remote_storage_pool_create_xml_args ();
+extern bool_t xdr_remote_storage_pool_create_xml_ret ();
+extern bool_t xdr_remote_storage_pool_define_xml_args ();
+extern bool_t xdr_remote_storage_pool_define_xml_ret ();
+extern bool_t xdr_remote_storage_pool_build_args ();
+extern bool_t xdr_remote_storage_pool_undefine_args ();
+extern bool_t xdr_remote_storage_pool_create_args ();
+extern bool_t xdr_remote_storage_pool_destroy_args ();
+extern bool_t xdr_remote_storage_pool_delete_args ();
+extern bool_t xdr_remote_storage_pool_refresh_args ();
+extern bool_t xdr_remote_storage_pool_dump_xml_args ();
+extern bool_t xdr_remote_storage_pool_dump_xml_ret ();
+extern bool_t xdr_remote_storage_pool_get_info_args ();
+extern bool_t xdr_remote_storage_pool_get_info_ret ();
+extern bool_t xdr_remote_storage_pool_get_autostart_args ();
+extern bool_t xdr_remote_storage_pool_get_autostart_ret ();
+extern bool_t xdr_remote_storage_pool_set_autostart_args ();
+extern bool_t xdr_remote_storage_pool_num_of_volumes_args ();
+extern bool_t xdr_remote_storage_pool_num_of_volumes_ret ();
+extern bool_t xdr_remote_storage_pool_list_volumes_args ();
+extern bool_t xdr_remote_storage_pool_list_volumes_ret ();
+extern bool_t xdr_remote_storage_vol_lookup_by_name_args ();
+extern bool_t xdr_remote_storage_vol_lookup_by_name_ret ();
+extern bool_t xdr_remote_storage_vol_lookup_by_key_args ();
+extern bool_t xdr_remote_storage_vol_lookup_by_key_ret ();
+extern bool_t xdr_remote_storage_vol_lookup_by_path_args ();
+extern bool_t xdr_remote_storage_vol_lookup_by_path_ret ();
+extern bool_t xdr_remote_storage_vol_create_xml_args ();
+extern bool_t xdr_remote_storage_vol_create_xml_ret ();
+extern bool_t xdr_remote_storage_vol_create_xml_from_args ();
+extern bool_t xdr_remote_storage_vol_create_xml_from_ret ();
+extern bool_t xdr_remote_storage_vol_delete_args ();
+extern bool_t xdr_remote_storage_vol_dump_xml_args ();
+extern bool_t xdr_remote_storage_vol_dump_xml_ret ();
+extern bool_t xdr_remote_storage_vol_get_info_args ();
+extern bool_t xdr_remote_storage_vol_get_info_ret ();
+extern bool_t xdr_remote_storage_vol_get_path_args ();
+extern bool_t xdr_remote_storage_vol_get_path_ret ();
+extern bool_t xdr_remote_node_num_of_devices_args ();
+extern bool_t xdr_remote_node_num_of_devices_ret ();
+extern bool_t xdr_remote_node_list_devices_args ();
+extern bool_t xdr_remote_node_list_devices_ret ();
+extern bool_t xdr_remote_node_device_lookup_by_name_args ();
+extern bool_t xdr_remote_node_device_lookup_by_name_ret ();
+extern bool_t xdr_remote_node_device_dump_xml_args ();
+extern bool_t xdr_remote_node_device_dump_xml_ret ();
+extern bool_t xdr_remote_node_device_get_parent_args ();
+extern bool_t xdr_remote_node_device_get_parent_ret ();
+extern bool_t xdr_remote_node_device_num_of_caps_args ();
+extern bool_t xdr_remote_node_device_num_of_caps_ret ();
+extern bool_t xdr_remote_node_device_list_caps_args ();
+extern bool_t xdr_remote_node_device_list_caps_ret ();
+extern bool_t xdr_remote_node_device_dettach_args ();
+extern bool_t xdr_remote_node_device_re_attach_args ();
+extern bool_t xdr_remote_node_device_reset_args ();
+extern bool_t xdr_remote_node_device_create_xml_args ();
+extern bool_t xdr_remote_node_device_create_xml_ret ();
+extern bool_t xdr_remote_node_device_destroy_args ();
+extern bool_t xdr_remote_domain_events_register_ret ();
+extern bool_t xdr_remote_domain_events_deregister_ret ();
+extern bool_t xdr_remote_domain_event_msg ();
+extern bool_t xdr_remote_domain_xml_from_native_args ();
+extern bool_t xdr_remote_domain_xml_from_native_ret ();
+extern bool_t xdr_remote_domain_xml_to_native_args ();
+extern bool_t xdr_remote_domain_xml_to_native_ret ();
+extern bool_t xdr_remote_num_of_secrets_ret ();
+extern bool_t xdr_remote_list_secrets_args ();
+extern bool_t xdr_remote_list_secrets_ret ();
+extern bool_t xdr_remote_secret_lookup_by_uuid_args ();
+extern bool_t xdr_remote_secret_lookup_by_uuid_ret ();
+extern bool_t xdr_remote_secret_define_xml_args ();
+extern bool_t xdr_remote_secret_define_xml_ret ();
+extern bool_t xdr_remote_secret_get_xml_desc_args ();
+extern bool_t xdr_remote_secret_get_xml_desc_ret ();
+extern bool_t xdr_remote_secret_set_value_args ();
+extern bool_t xdr_remote_secret_get_value_args ();
+extern bool_t xdr_remote_secret_get_value_ret ();
+extern bool_t xdr_remote_secret_undefine_args ();
+extern bool_t xdr_remote_secret_lookup_by_usage_args ();
+extern bool_t xdr_remote_secret_lookup_by_usage_ret ();
+extern bool_t xdr_remote_procedure ();
+extern bool_t xdr_remote_message_type ();
+extern bool_t xdr_remote_message_status ();
+extern bool_t xdr_remote_message_header ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_RP_H_RPCGEN */
--- /dev/null
+/* -*- c -*-
+ * remote_protocol.x: private protocol for communicating between
+ * remote_internal driver and libvirtd. This protocol is
+ * internal and may change at any time.
+ *
+ * Copyright (C) 2006-2008 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 Jones <rjones@redhat.com>
+ */
+
+/* Notes:
+ *
+ * (1) The protocol is internal and may change at any time, without
+ * notice. Do not use it. Instead link to libvirt and use the remote
+ * driver.
+ *
+ * (2) See bottom of this file for a description of the home-brew RPC.
+ *
+ * (3) Authentication/encryption is done outside this protocol.
+ *
+ * (4) For namespace reasons, all exported names begin 'remote_' or
+ * 'REMOTE_'. This makes names quite long.
+ */
+
+%#include "internal.h"
+%#include <arpa/inet.h>
+
+/*----- Data types. -----*/
+
+/* Maximum total message size (serialised). */
+const REMOTE_MESSAGE_MAX = 262144;
+
+/* Length of long, but not unbounded, strings.
+ * This is an arbitrary limit designed to stop the decoder from trying
+ * to allocate unbounded amounts of memory when fed with a bad message.
+ */
+const REMOTE_STRING_MAX = 65536;
+
+/* A long string, which may NOT be NULL. */
+typedef string remote_nonnull_string<REMOTE_STRING_MAX>;
+
+/* A long string, which may be NULL. */
+typedef remote_nonnull_string *remote_string;
+
+/* This just places an upper limit on the length of lists of
+ * domain IDs which may be sent via the protocol.
+ */
+const REMOTE_DOMAIN_ID_LIST_MAX = 16384;
+
+/* Upper limit on lists of domain names. */
+const REMOTE_DOMAIN_NAME_LIST_MAX = 1024;
+
+/* Upper limit on cpumap (bytes) passed to virDomainPinVcpu. */
+const REMOTE_CPUMAP_MAX = 256;
+
+/* Upper limit on number of info fields returned by virDomainGetVcpus. */
+const REMOTE_VCPUINFO_MAX = 2048;
+
+/* Upper limit on cpumaps (bytes) passed to virDomainGetVcpus. */
+const REMOTE_CPUMAPS_MAX = 16384;
+
+/* Upper limit on migrate cookie. */
+const REMOTE_MIGRATE_COOKIE_MAX = 256;
+
+/* Upper limit on lists of network names. */
+const REMOTE_NETWORK_NAME_LIST_MAX = 256;
+
+/* Upper limit on lists of interface names. */
+const REMOTE_INTERFACE_NAME_LIST_MAX = 256;
+
+/* Upper limit on lists of defined interface names. */
+const REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX = 256;
+
+/* Upper limit on lists of storage pool names. */
+const REMOTE_STORAGE_POOL_NAME_LIST_MAX = 256;
+
+/* Upper limit on lists of storage vol names. */
+const REMOTE_STORAGE_VOL_NAME_LIST_MAX = 1024;
+
+/* Upper limit on lists of node device names. */
+const REMOTE_NODE_DEVICE_NAME_LIST_MAX = 16384;
+
+/* Upper limit on lists of node device capabilities. */
+const REMOTE_NODE_DEVICE_CAPS_LIST_MAX = 16384;
+
+/* Upper limit on list of scheduler parameters. */
+const REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX = 16;
+
+/* Upper limit on number of NUMA cells */
+const REMOTE_NODE_MAX_CELLS = 1024;
+
+/* Upper limit on SASL auth negotiation packet */
+const REMOTE_AUTH_SASL_DATA_MAX = 65536;
+
+/* Maximum number of auth types */
+const REMOTE_AUTH_TYPE_LIST_MAX = 20;
+
+/* Maximum length of a block peek buffer message.
+ * Note applications need to be aware of this limit and issue multiple
+ * requests for large amounts of data.
+ */
+const REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX = 65536;
+
+/* Maximum length of a memory peek buffer message.
+ * Note applications need to be aware of this limit and issue multiple
+ * requests for large amounts of data.
+ */
+const REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX = 65536;
+
+/*
+ * Maximum length of a security model field.
+ */
+const REMOTE_SECURITY_MODEL_MAX = VIR_SECURITY_MODEL_BUFLEN;
+
+/*
+ * Maximum length of a security label field.
+ */
+const REMOTE_SECURITY_LABEL_MAX = VIR_SECURITY_LABEL_BUFLEN;
+
+/*
+ * Maximum length of a security DOI field.
+ */
+const REMOTE_SECURITY_DOI_MAX = VIR_SECURITY_DOI_BUFLEN;
+
+/*
+ * Maximum size of a secret value.
+ */
+const REMOTE_SECRET_VALUE_MAX = 65536;
+
+/*
+ * Upper limit on list of secrets.
+ */
+const REMOTE_SECRET_UUID_LIST_MAX = 16384;
+
+/* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */
+typedef opaque remote_uuid[VIR_UUID_BUFLEN];
+
+/* A domain which may not be NULL. */
+struct remote_nonnull_domain {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+ int id;
+};
+
+/* A network which may not be NULL. */
+struct remote_nonnull_network {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+};
+
+/* An interface which may not be NULL. */
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_nonnull_string mac;
+};
+
+/* A storage pool which may not be NULL. */
+struct remote_nonnull_storage_pool {
+ remote_nonnull_string name;
+ remote_uuid uuid;
+};
+
+/* A storage vol which may not be NULL. */
+struct remote_nonnull_storage_vol {
+ remote_nonnull_string pool;
+ remote_nonnull_string name;
+ remote_nonnull_string key;
+};
+
+/* A node device which may not be NULL. */
+struct remote_nonnull_node_device {
+ remote_nonnull_string name;
+};
+
+/* A secret which may not be null. */
+struct remote_nonnull_secret {
+ remote_uuid uuid;
+ int usageType;
+ remote_nonnull_string usageID;
+};
+
+/* A domain or network which may be NULL. */
+typedef remote_nonnull_domain *remote_domain;
+typedef remote_nonnull_network *remote_network;
+typedef remote_nonnull_storage_pool *remote_storage_pool;
+typedef remote_nonnull_storage_vol *remote_storage_vol;
+typedef remote_nonnull_node_device *remote_node_device;
+
+/* Error message. See <virterror.h> for explanation of fields. */
+
+/* NB. Fields "code", "domain" and "level" are really enums. The
+ * numeric value should remain compatible between libvirt and
+ * libvirtd. This means, no changing or reordering the enums as
+ * defined in <virterror.h> (but we don't do that anyway, for separate
+ * ABI reasons).
+ */
+struct remote_error {
+ int code;
+ int domain;
+ remote_string message;
+ int level;
+ remote_domain dom;
+ remote_string str1;
+ remote_string str2;
+ remote_string str3;
+ int int1;
+ int int2;
+ remote_network net;
+};
+
+/* Authentication types available thus far.... */
+enum remote_auth_type {
+ REMOTE_AUTH_NONE = 0,
+ REMOTE_AUTH_SASL = 1,
+ REMOTE_AUTH_POLKIT = 2
+};
+
+
+/* Wire encoding of virVcpuInfo. */
+struct remote_vcpu_info {
+ unsigned int number;
+ int state;
+ unsigned hyper cpu_time;
+ int cpu;
+};
+
+/* Wire encoding of virDomainSchedParameter.
+ * Note the enum (type) which must remain binary compatible.
+ */
+union remote_sched_param_value switch (int type) {
+ case VIR_DOMAIN_SCHED_FIELD_INT:
+ int i;
+ case VIR_DOMAIN_SCHED_FIELD_UINT:
+ unsigned int ui;
+ case VIR_DOMAIN_SCHED_FIELD_LLONG:
+ hyper l;
+ case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+ unsigned hyper ul;
+ case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+ double d;
+ case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+ int b;
+};
+
+struct remote_sched_param {
+ remote_nonnull_string field;
+ remote_sched_param_value value;
+};
+
+/*----- Calls. -----*/
+
+/* For each call we may have a 'remote_CALL_args' and 'remote_CALL_ret'
+ * type. These are omitted when they are void. The virConnectPtr
+ * is not passed at all (it is inferred on the remote server from the
+ * connection). Errors are returned implicitly in the RPC protocol.
+ *
+ * Please follow the naming convention carefully - this file is
+ * parsed by 'remote_generate_stubs.pl'.
+ */
+
+struct remote_open_args {
+ /* NB. "name" might be NULL although in practice you can't
+ * yet do that using the remote_internal driver.
+ */
+ remote_string name;
+ int flags;
+};
+
+struct remote_supports_feature_args {
+ int feature;
+};
+
+struct remote_supports_feature_ret {
+ int supported;
+};
+
+struct remote_get_type_ret {
+ remote_nonnull_string type;
+};
+
+struct remote_get_version_ret {
+ hyper hv_ver;
+};
+
+struct remote_get_hostname_ret {
+ remote_nonnull_string hostname;
+};
+
+struct remote_get_uri_ret {
+ remote_nonnull_string uri;
+};
+
+struct remote_get_max_vcpus_args {
+ /* The only backend which supports this call is Xen HV, and
+ * there the type is ignored so it could be NULL.
+ */
+ remote_string type;
+};
+
+struct remote_get_max_vcpus_ret {
+ int max_vcpus;
+};
+
+struct remote_node_get_info_ret {
+ char model[32];
+ hyper memory;
+ int cpus;
+ int mhz;
+ int nodes;
+ int sockets;
+ int cores;
+ int threads;
+};
+
+struct remote_get_capabilities_ret {
+ remote_nonnull_string capabilities;
+};
+
+struct remote_node_get_cells_free_memory_args {
+ int startCell;
+ int maxCells;
+};
+
+struct remote_node_get_cells_free_memory_ret {
+ hyper freeMems<REMOTE_NODE_MAX_CELLS>;
+};
+
+struct remote_node_get_free_memory_ret {
+ hyper freeMem;
+};
+
+struct remote_domain_get_scheduler_type_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_scheduler_type_ret {
+ remote_nonnull_string type;
+ int nparams;
+};
+
+struct remote_domain_get_scheduler_parameters_args {
+ remote_nonnull_domain dom;
+ int nparams;
+};
+
+struct remote_domain_get_scheduler_parameters_ret {
+ remote_sched_param params<REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX>;
+};
+
+struct remote_domain_set_scheduler_parameters_args {
+ remote_nonnull_domain dom;
+ remote_sched_param params<REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX>;
+};
+
+struct remote_domain_block_stats_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+};
+
+struct remote_domain_block_stats_ret {
+ hyper rd_req;
+ hyper rd_bytes;
+ hyper wr_req;
+ hyper wr_bytes;
+ hyper errs;
+};
+
+struct remote_domain_interface_stats_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+};
+
+struct remote_domain_interface_stats_ret {
+ hyper rx_bytes;
+ hyper rx_packets;
+ hyper rx_errs;
+ hyper rx_drop;
+ hyper tx_bytes;
+ hyper tx_packets;
+ hyper tx_errs;
+ hyper tx_drop;
+};
+
+struct remote_domain_block_peek_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string path;
+ unsigned hyper offset;
+ unsigned size;
+ unsigned flags;
+};
+
+struct remote_domain_block_peek_ret {
+ opaque buffer<REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX>;
+};
+
+struct remote_domain_memory_peek_args {
+ remote_nonnull_domain dom;
+ unsigned hyper offset;
+ unsigned size;
+ unsigned flags;
+};
+
+struct remote_domain_memory_peek_ret {
+ opaque buffer<REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX>;
+};
+
+struct remote_list_domains_args {
+ int maxids;
+};
+
+struct remote_list_domains_ret {
+ int ids<REMOTE_DOMAIN_ID_LIST_MAX>;
+};
+
+struct remote_num_of_domains_ret {
+ int num;
+};
+
+struct remote_domain_create_xml_args {
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+
+struct remote_domain_create_xml_ret {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_lookup_by_id_args {
+ int id;
+};
+
+struct remote_domain_lookup_by_id_ret {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+
+struct remote_domain_lookup_by_uuid_ret {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_domain_lookup_by_name_ret {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_suspend_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_resume_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_shutdown_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_reboot_args {
+ remote_nonnull_domain dom;
+ int flags;
+};
+
+struct remote_domain_destroy_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_os_type_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_os_type_ret {
+ remote_nonnull_string type;
+};
+
+struct remote_domain_get_max_memory_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_max_memory_ret {
+ unsigned hyper memory;
+};
+
+struct remote_domain_set_max_memory_args {
+ remote_nonnull_domain dom;
+ unsigned hyper memory;
+};
+
+struct remote_domain_set_memory_args {
+ remote_nonnull_domain dom;
+ unsigned hyper memory;
+};
+
+struct remote_domain_get_info_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_info_ret {
+ unsigned char state;
+ unsigned hyper max_mem;
+ unsigned hyper memory;
+ unsigned short nr_virt_cpu;
+ unsigned hyper cpu_time;
+};
+
+struct remote_domain_save_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string to;
+};
+
+struct remote_domain_restore_args {
+ remote_nonnull_string from;
+};
+
+struct remote_domain_core_dump_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string to;
+ int flags;
+};
+
+struct remote_domain_dump_xml_args {
+ remote_nonnull_domain dom;
+ int flags;
+};
+
+struct remote_domain_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_domain_migrate_prepare_args {
+ remote_string uri_in;
+ unsigned hyper flags;
+ remote_string dname;
+ unsigned hyper resource;
+};
+
+struct remote_domain_migrate_prepare_ret {
+ opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
+ remote_string uri_out;
+};
+
+struct remote_domain_migrate_perform_args {
+ remote_nonnull_domain dom;
+ opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
+ remote_nonnull_string uri;
+ unsigned hyper flags;
+ remote_string dname;
+ unsigned hyper resource;
+};
+
+struct remote_domain_migrate_finish_args {
+ remote_nonnull_string dname;
+ opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
+ remote_nonnull_string uri;
+ unsigned hyper flags;
+};
+
+struct remote_domain_migrate_finish_ret {
+ remote_nonnull_domain ddom;
+};
+
+struct remote_domain_migrate_prepare2_args {
+ remote_string uri_in;
+ unsigned hyper flags;
+ remote_string dname;
+ unsigned hyper resource;
+ remote_nonnull_string dom_xml;
+};
+
+struct remote_domain_migrate_prepare2_ret {
+ opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
+ remote_string uri_out;
+};
+
+struct remote_domain_migrate_finish2_args {
+ remote_nonnull_string dname;
+ opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
+ remote_nonnull_string uri;
+ unsigned hyper flags;
+ int retcode;
+};
+
+struct remote_domain_migrate_finish2_ret {
+ remote_nonnull_domain ddom;
+};
+
+struct remote_list_defined_domains_args {
+ int maxnames;
+};
+
+struct remote_list_defined_domains_ret {
+ remote_nonnull_string names<REMOTE_DOMAIN_NAME_LIST_MAX>;
+};
+
+struct remote_num_of_defined_domains_ret {
+ int num;
+};
+
+struct remote_domain_create_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_define_xml_args {
+ remote_nonnull_string xml;
+};
+
+struct remote_domain_define_xml_ret {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_undefine_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_set_vcpus_args {
+ remote_nonnull_domain dom;
+ int nvcpus;
+};
+
+struct remote_domain_pin_vcpu_args {
+ remote_nonnull_domain dom;
+ int vcpu;
+ opaque cpumap<REMOTE_CPUMAP_MAX>;
+};
+
+struct remote_domain_get_vcpus_args {
+ remote_nonnull_domain dom;
+ int maxinfo;
+ int maplen;
+};
+
+struct remote_domain_get_vcpus_ret {
+ remote_vcpu_info info<REMOTE_VCPUINFO_MAX>;
+ opaque cpumaps<REMOTE_CPUMAPS_MAX>;
+};
+
+struct remote_domain_get_max_vcpus_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_max_vcpus_ret {
+ int num;
+};
+
+struct remote_domain_get_security_label_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_security_label_ret {
+ char label<REMOTE_SECURITY_LABEL_MAX>;
+ int enforcing;
+};
+
+struct remote_node_get_security_model_ret {
+ char model<REMOTE_SECURITY_MODEL_MAX>;
+ char doi<REMOTE_SECURITY_DOI_MAX>;
+};
+
+struct remote_domain_attach_device_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string xml;
+};
+
+struct remote_domain_detach_device_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string xml;
+};
+
+struct remote_domain_get_autostart_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_get_autostart_ret {
+ int autostart;
+};
+
+struct remote_domain_set_autostart_args {
+ remote_nonnull_domain dom;
+ int autostart;
+};
+
+/* Network calls: */
+
+struct remote_num_of_networks_ret {
+ int num;
+};
+
+struct remote_list_networks_args {
+ int maxnames;
+};
+
+struct remote_list_networks_ret {
+ remote_nonnull_string names<REMOTE_NETWORK_NAME_LIST_MAX>;
+};
+
+struct remote_num_of_defined_networks_ret {
+ int num;
+};
+
+struct remote_list_defined_networks_args {
+ int maxnames;
+};
+
+struct remote_list_defined_networks_ret {
+ remote_nonnull_string names<REMOTE_NETWORK_NAME_LIST_MAX>;
+};
+
+struct remote_network_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+
+struct remote_network_lookup_by_uuid_ret {
+ remote_nonnull_network net;
+};
+
+struct remote_network_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_network_lookup_by_name_ret {
+ remote_nonnull_network net;
+};
+
+struct remote_network_create_xml_args {
+ remote_nonnull_string xml;
+};
+
+struct remote_network_create_xml_ret {
+ remote_nonnull_network net;
+};
+
+struct remote_network_define_xml_args {
+ remote_nonnull_string xml;
+};
+
+struct remote_network_define_xml_ret {
+ remote_nonnull_network net;
+};
+
+struct remote_network_undefine_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_create_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_destroy_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_dump_xml_args {
+ remote_nonnull_network net;
+ int flags;
+};
+
+struct remote_network_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_network_get_bridge_name_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_get_bridge_name_ret {
+ remote_nonnull_string name;
+};
+
+struct remote_network_get_autostart_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_get_autostart_ret {
+ int autostart;
+};
+
+struct remote_network_set_autostart_args {
+ remote_nonnull_network net;
+ int autostart;
+};
+
+
+/* Interface calls: */
+
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+
+struct remote_list_interfaces_ret {
+ remote_nonnull_string names<REMOTE_INTERFACE_NAME_LIST_MAX>;
+};
+
+struct remote_num_of_defined_interfaces_ret {
+ int num;
+};
+
+struct remote_list_defined_interfaces_args {
+ int maxnames;
+};
+
+struct remote_list_defined_interfaces_ret {
+ remote_nonnull_string names<REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX>;
+};
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface iface;
+};
+
+struct remote_interface_lookup_by_mac_string_args {
+ remote_nonnull_string mac;
+};
+
+struct remote_interface_lookup_by_mac_string_ret {
+ remote_nonnull_interface iface;
+};
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface iface;
+ unsigned int flags;
+};
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ unsigned int flags;
+};
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface iface;
+};
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface iface;
+};
+
+struct remote_interface_create_args {
+ remote_nonnull_interface iface;
+ unsigned int flags;
+};
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface iface;
+ unsigned int flags;
+};
+
+
+/* Auth calls: */
+
+struct remote_auth_list_ret {
+ remote_auth_type types<REMOTE_AUTH_TYPE_LIST_MAX>;
+};
+
+struct remote_auth_sasl_init_ret {
+ remote_nonnull_string mechlist;
+};
+
+struct remote_auth_sasl_start_args {
+ remote_nonnull_string mech;
+ int nil;
+ char data<REMOTE_AUTH_SASL_DATA_MAX>;
+};
+
+struct remote_auth_sasl_start_ret {
+ int complete;
+ int nil;
+ char data<REMOTE_AUTH_SASL_DATA_MAX>;
+};
+
+struct remote_auth_sasl_step_args {
+ int nil;
+ char data<REMOTE_AUTH_SASL_DATA_MAX>;
+};
+
+struct remote_auth_sasl_step_ret {
+ int complete;
+ int nil;
+ char data<REMOTE_AUTH_SASL_DATA_MAX>;
+};
+
+struct remote_auth_polkit_ret {
+ int complete;
+};
+
+
+
+/* Storage pool calls: */
+
+struct remote_num_of_storage_pools_ret {
+ int num;
+};
+
+struct remote_list_storage_pools_args {
+ int maxnames;
+};
+
+struct remote_list_storage_pools_ret {
+ remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
+};
+
+struct remote_num_of_defined_storage_pools_ret {
+ int num;
+};
+
+struct remote_list_defined_storage_pools_args {
+ int maxnames;
+};
+
+struct remote_list_defined_storage_pools_ret {
+ remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
+};
+
+struct remote_find_storage_pool_sources_args {
+ remote_nonnull_string type;
+ remote_string srcSpec;
+ unsigned flags;
+};
+
+struct remote_find_storage_pool_sources_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_storage_pool_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+
+struct remote_storage_pool_lookup_by_uuid_ret {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_storage_pool_lookup_by_name_ret {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_lookup_by_volume_args {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_pool_lookup_by_volume_ret {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_create_xml_args {
+ remote_nonnull_string xml;
+ unsigned flags;
+};
+
+struct remote_storage_pool_create_xml_ret {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_define_xml_args {
+ remote_nonnull_string xml;
+ unsigned flags;
+};
+
+struct remote_storage_pool_define_xml_ret {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_build_args {
+ remote_nonnull_storage_pool pool;
+ unsigned flags;
+};
+
+struct remote_storage_pool_undefine_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_create_args {
+ remote_nonnull_storage_pool pool;
+ unsigned flags;
+};
+
+struct remote_storage_pool_destroy_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_delete_args {
+ remote_nonnull_storage_pool pool;
+ unsigned flags;
+};
+
+struct remote_storage_pool_refresh_args {
+ remote_nonnull_storage_pool pool;
+ unsigned flags;
+};
+
+struct remote_storage_pool_dump_xml_args {
+ remote_nonnull_storage_pool pool;
+ unsigned flags;
+};
+
+struct remote_storage_pool_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_storage_pool_get_info_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_get_info_ret {
+ unsigned char state;
+ unsigned hyper capacity;
+ unsigned hyper allocation;
+ unsigned hyper available;
+};
+
+struct remote_storage_pool_get_autostart_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_get_autostart_ret {
+ int autostart;
+};
+
+struct remote_storage_pool_set_autostart_args {
+ remote_nonnull_storage_pool pool;
+ int autostart;
+};
+
+struct remote_storage_pool_num_of_volumes_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_num_of_volumes_ret {
+ int num;
+};
+
+struct remote_storage_pool_list_volumes_args {
+ remote_nonnull_storage_pool pool;
+ int maxnames;
+};
+
+struct remote_storage_pool_list_volumes_ret {
+ remote_nonnull_string names<REMOTE_STORAGE_VOL_NAME_LIST_MAX>;
+};
+
+
+
+/* Storage vol calls: */
+
+struct remote_storage_vol_lookup_by_name_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string name;
+};
+
+struct remote_storage_vol_lookup_by_name_ret {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_lookup_by_key_args {
+ remote_nonnull_string key;
+};
+
+struct remote_storage_vol_lookup_by_key_ret {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_lookup_by_path_args {
+ remote_nonnull_string path;
+};
+
+struct remote_storage_vol_lookup_by_path_ret {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_create_xml_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string xml;
+ unsigned flags;
+};
+
+struct remote_storage_vol_create_xml_ret {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_create_xml_from_args {
+ remote_nonnull_storage_pool pool;
+ remote_nonnull_string xml;
+ remote_nonnull_storage_vol clonevol;
+ unsigned flags;
+};
+
+struct remote_storage_vol_create_xml_from_ret {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_delete_args {
+ remote_nonnull_storage_vol vol;
+ unsigned flags;
+};
+
+struct remote_storage_vol_dump_xml_args {
+ remote_nonnull_storage_vol vol;
+ unsigned flags;
+};
+
+struct remote_storage_vol_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_storage_vol_get_info_args {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_get_info_ret {
+ char type;
+ unsigned hyper capacity;
+ unsigned hyper allocation;
+};
+
+struct remote_storage_vol_get_path_args {
+ remote_nonnull_storage_vol vol;
+};
+
+struct remote_storage_vol_get_path_ret {
+ remote_nonnull_string name;
+};
+
+/* Node driver calls: */
+
+struct remote_node_num_of_devices_args {
+ remote_string cap;
+ unsigned flags;
+};
+
+struct remote_node_num_of_devices_ret {
+ int num;
+};
+
+struct remote_node_list_devices_args {
+ remote_string cap;
+ int maxnames;
+ unsigned flags;
+};
+
+struct remote_node_list_devices_ret {
+ remote_nonnull_string names<REMOTE_NODE_DEVICE_NAME_LIST_MAX>;
+};
+
+struct remote_node_device_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_lookup_by_name_ret {
+ remote_nonnull_node_device dev;
+};
+
+struct remote_node_device_dump_xml_args {
+ remote_nonnull_string name;
+ unsigned flags;
+};
+
+struct remote_node_device_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_node_device_get_parent_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_get_parent_ret {
+ remote_string parent;
+};
+
+struct remote_node_device_num_of_caps_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_num_of_caps_ret {
+ int num;
+};
+
+struct remote_node_device_list_caps_args {
+ remote_nonnull_string name;
+ int maxnames;
+};
+
+struct remote_node_device_list_caps_ret {
+ remote_nonnull_string names<REMOTE_NODE_DEVICE_CAPS_LIST_MAX>;
+};
+
+struct remote_node_device_dettach_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_re_attach_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_reset_args {
+ remote_nonnull_string name;
+};
+
+struct remote_node_device_create_xml_args {
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+
+struct remote_node_device_create_xml_ret {
+ remote_nonnull_node_device dev;
+};
+
+struct remote_node_device_destroy_args {
+ remote_nonnull_string name;
+};
+
+
+/**
+ * Events Register/Deregister:
+ * It would seem rpcgen does not like both args, and ret
+ * to be null. It will not generate the prototype otherwise.
+ * Pass back a redundant boolean to force prototype generation.
+ */
+struct remote_domain_events_register_ret {
+ int cb_registered;
+};
+
+struct remote_domain_events_deregister_ret {
+ int cb_registered;
+};
+
+struct remote_domain_event_msg {
+ remote_nonnull_domain dom;
+ int event;
+ int detail;
+};
+
+
+struct remote_domain_xml_from_native_args {
+ remote_nonnull_string nativeFormat;
+ remote_nonnull_string nativeConfig;
+ unsigned flags;
+};
+
+struct remote_domain_xml_from_native_ret {
+ remote_nonnull_string domainXml;
+};
+
+
+struct remote_domain_xml_to_native_args {
+ remote_nonnull_string nativeFormat;
+ remote_nonnull_string domainXml;
+ unsigned flags;
+};
+
+struct remote_domain_xml_to_native_ret {
+ remote_nonnull_string nativeConfig;
+};
+
+
+struct remote_num_of_secrets_ret {
+ int num;
+};
+
+struct remote_list_secrets_args {
+ int maxuuids;
+};
+
+struct remote_list_secrets_ret {
+ remote_nonnull_string uuids<REMOTE_SECRET_UUID_LIST_MAX>;
+};
+
+struct remote_secret_lookup_by_uuid_args {
+ remote_uuid uuid;
+};
+
+struct remote_secret_lookup_by_uuid_ret {
+ remote_nonnull_secret secret;
+};
+
+struct remote_secret_define_xml_args {
+ remote_nonnull_string xml;
+ unsigned flags;
+};
+
+struct remote_secret_define_xml_ret {
+ remote_nonnull_secret secret;
+};
+
+struct remote_secret_get_xml_desc_args {
+ remote_nonnull_secret secret;
+ unsigned flags;
+};
+
+struct remote_secret_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_secret_set_value_args {
+ remote_nonnull_secret secret;
+ opaque value<REMOTE_SECRET_VALUE_MAX>;
+ unsigned flags;
+};
+
+struct remote_secret_get_value_args {
+ remote_nonnull_secret secret;
+ unsigned flags;
+};
+
+struct remote_secret_get_value_ret {
+ opaque value<REMOTE_SECRET_VALUE_MAX>;
+};
+
+struct remote_secret_undefine_args {
+ remote_nonnull_secret secret;
+};
+
+struct remote_secret_lookup_by_usage_args {
+ int usageType;
+ remote_nonnull_string usageID;
+};
+
+struct remote_secret_lookup_by_usage_ret {
+ remote_nonnull_secret secret;
+};
+
+/*----- Protocol. -----*/
+
+/* Define the program number, protocol version and procedure numbers here. */
+const REMOTE_PROGRAM = 0x20008086;
+const REMOTE_PROTOCOL_VERSION = 1;
+
+enum remote_procedure {
+ REMOTE_PROC_OPEN = 1,
+ REMOTE_PROC_CLOSE = 2,
+ REMOTE_PROC_GET_TYPE = 3,
+ REMOTE_PROC_GET_VERSION = 4,
+ REMOTE_PROC_GET_MAX_VCPUS = 5,
+ REMOTE_PROC_NODE_GET_INFO = 6,
+ REMOTE_PROC_GET_CAPABILITIES = 7,
+ REMOTE_PROC_DOMAIN_ATTACH_DEVICE = 8,
+ REMOTE_PROC_DOMAIN_CREATE = 9,
+ REMOTE_PROC_DOMAIN_CREATE_XML = 10,
+
+ REMOTE_PROC_DOMAIN_DEFINE_XML = 11,
+ REMOTE_PROC_DOMAIN_DESTROY = 12,
+ REMOTE_PROC_DOMAIN_DETACH_DEVICE = 13,
+ REMOTE_PROC_DOMAIN_DUMP_XML = 14,
+ REMOTE_PROC_DOMAIN_GET_AUTOSTART = 15,
+ REMOTE_PROC_DOMAIN_GET_INFO = 16,
+ REMOTE_PROC_DOMAIN_GET_MAX_MEMORY = 17,
+ REMOTE_PROC_DOMAIN_GET_MAX_VCPUS = 18,
+ REMOTE_PROC_DOMAIN_GET_OS_TYPE = 19,
+ REMOTE_PROC_DOMAIN_GET_VCPUS = 20,
+
+ REMOTE_PROC_LIST_DEFINED_DOMAINS = 21,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_ID = 22,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME = 23,
+ REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID = 24,
+ REMOTE_PROC_NUM_OF_DEFINED_DOMAINS = 25,
+ REMOTE_PROC_DOMAIN_PIN_VCPU = 26,
+ REMOTE_PROC_DOMAIN_REBOOT = 27,
+ REMOTE_PROC_DOMAIN_RESUME = 28,
+ REMOTE_PROC_DOMAIN_SET_AUTOSTART = 29,
+ REMOTE_PROC_DOMAIN_SET_MAX_MEMORY = 30,
+
+ REMOTE_PROC_DOMAIN_SET_MEMORY = 31,
+ REMOTE_PROC_DOMAIN_SET_VCPUS = 32,
+ REMOTE_PROC_DOMAIN_SHUTDOWN = 33,
+ REMOTE_PROC_DOMAIN_SUSPEND = 34,
+ REMOTE_PROC_DOMAIN_UNDEFINE = 35,
+ REMOTE_PROC_LIST_DEFINED_NETWORKS = 36,
+ REMOTE_PROC_LIST_DOMAINS = 37,
+ REMOTE_PROC_LIST_NETWORKS = 38,
+ REMOTE_PROC_NETWORK_CREATE = 39,
+ REMOTE_PROC_NETWORK_CREATE_XML = 40,
+
+ REMOTE_PROC_NETWORK_DEFINE_XML = 41,
+ REMOTE_PROC_NETWORK_DESTROY = 42,
+ REMOTE_PROC_NETWORK_DUMP_XML = 43,
+ REMOTE_PROC_NETWORK_GET_AUTOSTART = 44,
+ REMOTE_PROC_NETWORK_GET_BRIDGE_NAME = 45,
+ REMOTE_PROC_NETWORK_LOOKUP_BY_NAME = 46,
+ REMOTE_PROC_NETWORK_LOOKUP_BY_UUID = 47,
+ REMOTE_PROC_NETWORK_SET_AUTOSTART = 48,
+ REMOTE_PROC_NETWORK_UNDEFINE = 49,
+ REMOTE_PROC_NUM_OF_DEFINED_NETWORKS = 50,
+
+ REMOTE_PROC_NUM_OF_DOMAINS = 51,
+ REMOTE_PROC_NUM_OF_NETWORKS = 52,
+ REMOTE_PROC_DOMAIN_CORE_DUMP = 53,
+ REMOTE_PROC_DOMAIN_RESTORE = 54,
+ REMOTE_PROC_DOMAIN_SAVE = 55,
+ REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE = 56,
+ REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS = 57,
+ REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS = 58,
+ REMOTE_PROC_GET_HOSTNAME = 59,
+ REMOTE_PROC_SUPPORTS_FEATURE = 60,
+
+ REMOTE_PROC_DOMAIN_MIGRATE_PREPARE = 61,
+ REMOTE_PROC_DOMAIN_MIGRATE_PERFORM = 62,
+ REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
+ REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
+ REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
+ REMOTE_PROC_AUTH_LIST = 66,
+ REMOTE_PROC_AUTH_SASL_INIT = 67,
+ REMOTE_PROC_AUTH_SASL_START = 68,
+ REMOTE_PROC_AUTH_SASL_STEP = 69,
+ REMOTE_PROC_AUTH_POLKIT = 70,
+
+ REMOTE_PROC_NUM_OF_STORAGE_POOLS = 71,
+ REMOTE_PROC_LIST_STORAGE_POOLS = 72,
+ REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 73,
+ REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 74,
+ REMOTE_PROC_FIND_STORAGE_POOL_SOURCES = 75,
+ REMOTE_PROC_STORAGE_POOL_CREATE_XML = 76,
+ REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 77,
+ REMOTE_PROC_STORAGE_POOL_CREATE = 78,
+ REMOTE_PROC_STORAGE_POOL_BUILD = 79,
+ REMOTE_PROC_STORAGE_POOL_DESTROY = 80,
+
+ REMOTE_PROC_STORAGE_POOL_DELETE = 81,
+ REMOTE_PROC_STORAGE_POOL_UNDEFINE = 82,
+ REMOTE_PROC_STORAGE_POOL_REFRESH = 83,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 84,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 85,
+ REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME = 86,
+ REMOTE_PROC_STORAGE_POOL_GET_INFO = 87,
+ REMOTE_PROC_STORAGE_POOL_DUMP_XML = 88,
+ REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 89,
+ REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 90,
+
+ REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 91,
+ REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 92,
+ REMOTE_PROC_STORAGE_VOL_CREATE_XML = 93,
+ REMOTE_PROC_STORAGE_VOL_DELETE = 94,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 95,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY = 96,
+ REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH = 97,
+ REMOTE_PROC_STORAGE_VOL_GET_INFO = 98,
+ REMOTE_PROC_STORAGE_VOL_DUMP_XML = 99,
+ REMOTE_PROC_STORAGE_VOL_GET_PATH = 100,
+
+ REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY = 101,
+ REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
+ REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
+ REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
+ REMOTE_PROC_DOMAIN_EVENTS_REGISTER = 105,
+ REMOTE_PROC_DOMAIN_EVENTS_DEREGISTER = 106,
+ REMOTE_PROC_DOMAIN_EVENT = 107,
+ REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2 = 108,
+ REMOTE_PROC_DOMAIN_MIGRATE_FINISH2 = 109,
+ REMOTE_PROC_GET_URI = 110,
+
+ REMOTE_PROC_NODE_NUM_OF_DEVICES = 111,
+ REMOTE_PROC_NODE_LIST_DEVICES = 112,
+ REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME = 113,
+ REMOTE_PROC_NODE_DEVICE_DUMP_XML = 114,
+ REMOTE_PROC_NODE_DEVICE_GET_PARENT = 115,
+ REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS = 116,
+ REMOTE_PROC_NODE_DEVICE_LIST_CAPS = 117,
+ REMOTE_PROC_NODE_DEVICE_DETTACH = 118,
+ REMOTE_PROC_NODE_DEVICE_RE_ATTACH = 119,
+ REMOTE_PROC_NODE_DEVICE_RESET = 120,
+
+ REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL = 121,
+ REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
+ REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
+ REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+ REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM = 125,
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134,
+ REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
+ REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
+
+ REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
+ REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
+
+ REMOTE_PROC_NUM_OF_SECRETS = 139,
+ REMOTE_PROC_LIST_SECRETS = 140,
+ REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
+ REMOTE_PROC_SECRET_DEFINE_XML = 142,
+ REMOTE_PROC_SECRET_GET_XML_DESC = 143,
+ REMOTE_PROC_SECRET_SET_VALUE = 144,
+ REMOTE_PROC_SECRET_GET_VALUE = 145,
+ REMOTE_PROC_SECRET_UNDEFINE = 146,
+ REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147
+};
+
+
+/*
+ * RPC wire format
+ *
+ * Each message consists of:
+ *
+ * Name | Type | Description
+ * -----------+-----------------------+------------------
+ * Length | int | Total number of bytes in message _including_ length.
+ * Header | remote_message_header | Control information about procedure call
+ * Payload | - | Variable payload data per procedure
+ *
+ * In header, the 'serial' field varies according to:
+ *
+ * - type == REMOTE_CALL
+ * * serial is set by client, incrementing by 1 each time
+ *
+ * - type == REMOTE_REPLY
+ * * serial matches that from the corresponding REMOTE_CALL
+ *
+ * - type == REMOTE_MESSAGE
+ * * serial matches that from the corresponding REMOTE_CALL, or zero
+ *
+ *
+ * Payload varies according to type and status:
+ *
+ * - type == REMOTE_CALL
+ * XXX_args for procedure
+ *
+ * - type == REMOTE_REPLY
+ * * status == REMOTE_OK
+ * XXX_ret for procedure
+ * * status == REMOTE_ERROR
+ * remote_error Error information
+ *
+ * - type == REMOTE_MESSAGE
+ * * status == REMOTE_OK
+ * XXX_args for procedure
+ * * status == REMOTE_ERROR
+ * remote_error Error information
+ *
+ */
+enum remote_message_type {
+ /* client -> server. args from a method call */
+ REMOTE_CALL = 0,
+ /* server -> client. reply/error from a method call */
+ REMOTE_REPLY = 1,
+ /* either direction. async notification */
+ REMOTE_MESSAGE = 2
+};
+
+enum remote_message_status {
+ /* Status is always REMOTE_OK for calls.
+ * For replies, indicates no error.
+ */
+ REMOTE_OK = 0,
+
+ /* For replies, indicates that an error happened, and a struct
+ * remote_error follows.
+ */
+ REMOTE_ERROR = 1
+};
+
+/* 4 byte length word per header */
+const REMOTE_MESSAGE_HEADER_XDR_LEN = 4;
+
+struct remote_message_header {
+ unsigned prog; /* REMOTE_PROGRAM */
+ unsigned vers; /* REMOTE_PROTOCOL_VERSION */
+ remote_procedure proc; /* REMOTE_PROC_x */
+ remote_message_type type;
+ unsigned serial; /* Serial number of message. */
+ remote_message_status status;
+};
--- /dev/null
+# 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, $_;
+ }
+}
--- /dev/null
+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" }
--- /dev/null
+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" }
\ No newline at end of file
+++ /dev/null
-*.gcda
-*.gcno
-*.la
-*.lo
-.deps
-.libs
-Makefile
-Makefile.in
-libvirt_qemud
-libvirtd
-libvirtd.init
-libvirtd.logrotate
+++ /dev/null
-## 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
+++ /dev/null
-
- 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.
+++ /dev/null
-<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>
+++ /dev/null
-/*
- * 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;
-}
+++ /dev/null
-/*
- * 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__ */
+++ /dev/null
-/*
- * 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;
-}
+++ /dev/null
-/*
- * 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__ */
+++ /dev/null
-(* /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
+++ /dev/null
-# 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
+++ /dev/null
-#!/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
+++ /dev/null
-@localstatedir@/log/libvirt/qemu/*.log {
- daily
- missingok
- rotate 7
- compress
- delaycompress
- copytruncate
-}
+++ /dev/null
-<!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>
+++ /dev/null
-<!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>
+++ /dev/null
-# 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
+++ /dev/null
-# 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
+++ /dev/null
-(* /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
+++ /dev/null
-/*
- * 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;
-}
+++ /dev/null
-/*
- * 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__ */
+++ /dev/null
-/*
- * qemud.c: daemon start of day, guest process & i/o management
- *
- * Copyright (C) 2006, 2007, 2008, 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>
- */
-
-#include <config.h>
-
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/poll.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-#include <stdlib.h>
-#include <pwd.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <syslog.h>
-#include <string.h>
-#include <errno.h>
-#include <getopt.h>
-#include <fnmatch.h>
-#include <grp.h>
-#include <signal.h>
-#include <netdb.h>
-
-#include "libvirt_internal.h"
-#include "virterror_internal.h"
-
-#define VIR_FROM_THIS VIR_FROM_QEMU
-
-#include "qemud.h"
-#include "dispatch.h"
-
-#include "util.h"
-#include "remote_internal.h"
-#include "conf.h"
-#include "event.h"
-#include "memory.h"
-#ifdef HAVE_AVAHI
-#include "mdns.h"
-#endif
-
-#ifdef WITH_DRIVER_MODULES
-#include "driver.h"
-#else
-#ifdef WITH_QEMU
-#include "qemu_driver.h"
-#endif
-#ifdef WITH_LXC
-#include "lxc_driver.h"
-#endif
-#ifdef WITH_UML
-#include "uml_driver.h"
-#endif
-#ifdef WITH_ONE
-#include "opennebula/one_driver.h"
-#endif
-#ifdef WITH_NETWORK
-#include "network_driver.h"
-#endif
-#ifdef WITH_NETCF
-#include "interface_driver.h"
-#endif
-#ifdef WITH_STORAGE_DIR
-#include "storage_driver.h"
-#endif
-#ifdef WITH_NODE_DEVICES
-#include "node_device.h"
-#endif
-#include "secret_driver.h"
-#endif
-
-
-#ifdef __sun
-#include <ucred.h>
-#include <priv.h>
-
-#ifndef PRIV_VIRT_MANAGE
-#define PRIV_VIRT_MANAGE ((const char *)"virt_manage")
-#endif
-
-#ifndef PRIV_XVM_CONTROL
-#define PRIV_XVM_CONTROL ((const char *)"xvm_control")
-#endif
-
-#define PU_RESETGROUPS 0x0001 /* Remove supplemental groups */
-#define PU_CLEARLIMITSET 0x0008 /* L=0 */
-
-extern int __init_daemon_priv(int, uid_t, gid_t, ...);
-
-#define SYSTEM_UID 60
-
-static gid_t unix_sock_gid = 60; /* Not used */
-static int unix_sock_rw_mask = 0666;
-static int unix_sock_ro_mask = 0666;
-
-#else
-
-static gid_t unix_sock_gid = 0; /* Only root by default */
-static int unix_sock_rw_mask = 0700; /* Allow user only */
-static int unix_sock_ro_mask = 0777; /* Allow world */
-
-#endif /* __sun */
-
-static int godaemon = 0; /* -d: Be a daemon */
-static int verbose = 0; /* -v: Verbose mode */
-static int timeout = -1; /* -t: Shutdown timeout */
-static int sigwrite = -1; /* Signal handler pipe */
-static int ipsock = 0; /* -l Listen for TCP/IP */
-
-/* Defaults for configuration file elements */
-static int listen_tls = 1;
-static int listen_tcp = 0;
-static char *listen_addr = (char *) LIBVIRTD_LISTEN_ADDR;
-static char *tls_port = (char *) LIBVIRTD_TLS_PORT;
-static char *tcp_port = (char *) LIBVIRTD_TCP_PORT;
-
-static char *unix_sock_dir = NULL;
-
-#if HAVE_POLKIT
-static int auth_unix_rw = REMOTE_AUTH_POLKIT;
-static int auth_unix_ro = REMOTE_AUTH_POLKIT;
-#else
-static int auth_unix_rw = REMOTE_AUTH_NONE;
-static int auth_unix_ro = REMOTE_AUTH_NONE;
-#endif /* HAVE_POLKIT */
-#if HAVE_SASL
-static int auth_tcp = REMOTE_AUTH_SASL;
-#else
-static int auth_tcp = REMOTE_AUTH_NONE;
-#endif
-static int auth_tls = REMOTE_AUTH_NONE;
-
-static int mdns_adv = 1;
-static char *mdns_name = NULL;
-
-static int tls_no_verify_certificate = 0;
-static char **tls_allowed_dn_list = NULL;
-
-static char *key_file = (char *) LIBVIRT_SERVERKEY;
-static char *cert_file = (char *) LIBVIRT_SERVERCERT;
-static char *ca_file = (char *) LIBVIRT_CACERT;
-static char *crl_file = (char *) "";
-
-static gnutls_certificate_credentials_t x509_cred;
-static gnutls_dh_params_t dh_params;
-
-static int min_workers = 5;
-static int max_workers = 20;
-static int max_clients = 20;
-
-/* Total number of 'in-process' RPC calls allowed across all clients */
-static int max_requests = 20;
-/* Total number of 'in-process' RPC calls allowed by a single client*/
-static int max_client_requests = 5;
-
-#define DH_BITS 1024
-
-static sig_atomic_t sig_errors = 0;
-static int sig_lasterrno = 0;
-
-static void sig_handler(int sig, siginfo_t * siginfo,
- void* context ATTRIBUTE_UNUSED) {
- int origerrno;
- int r;
-
- /* set the sig num in the struct */
- siginfo->si_signo = sig;
-
- origerrno = errno;
- r = safewrite(sigwrite, siginfo, sizeof(*siginfo));
- if (r == -1) {
- sig_errors++;
- sig_lasterrno = errno;
- }
- errno = origerrno;
-}
-
-static void qemudDispatchClientEvent(int watch, int fd, int events, void *opaque);
-static void qemudDispatchServerEvent(int watch, int fd, int events, void *opaque);
-static int qemudStartWorker(struct qemud_server *server, struct qemud_worker *worker);
-
-void
-qemudClientMessageQueuePush(struct qemud_client_message **queue,
- struct qemud_client_message *msg)
-{
- struct qemud_client_message *tmp = *queue;
-
- if (tmp) {
- while (tmp->next)
- tmp = tmp->next;
- tmp->next = msg;
- } else {
- *queue = msg;
- }
-}
-
-struct qemud_client_message *
-qemudClientMessageQueueServe(struct qemud_client_message **queue)
-{
- struct qemud_client_message *tmp = *queue;
-
- if (tmp) {
- *queue = tmp->next;
- tmp->next = NULL;
- }
-
- return tmp;
-}
-
-static int
-remoteCheckCertFile(const char *type, const char *file)
-{
- struct stat sb;
- if (stat(file, &sb) < 0) {
- char ebuf[1024];
- VIR_ERROR(_("Cannot access %s '%s': %s"),
- type, file, virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
- return 0;
-}
-
-static int
-remoteInitializeGnuTLS (void)
-{
- int err;
-
- /* Initialise GnuTLS. */
- gnutls_global_init ();
-
- err = gnutls_certificate_allocate_credentials (&x509_cred);
- if (err) {
- VIR_ERROR(_("gnutls_certificate_allocate_credentials: %s"),
- gnutls_strerror (err));
- return -1;
- }
-
- if (ca_file && ca_file[0] != '\0') {
- if (remoteCheckCertFile("CA certificate", ca_file) < 0)
- return -1;
-
- qemudDebug ("loading CA cert from %s", ca_file);
- err = gnutls_certificate_set_x509_trust_file (x509_cred, ca_file,
- GNUTLS_X509_FMT_PEM);
- if (err < 0) {
- VIR_ERROR(_("gnutls_certificate_set_x509_trust_file: %s"),
- gnutls_strerror (err));
- return -1;
- }
- }
-
- if (crl_file && crl_file[0] != '\0') {
- if (remoteCheckCertFile("CA revocation list", crl_file) < 0)
- return -1;
-
- DEBUG("loading CRL from %s", crl_file);
- err = gnutls_certificate_set_x509_crl_file (x509_cred, crl_file,
- GNUTLS_X509_FMT_PEM);
- if (err < 0) {
- VIR_ERROR(_("gnutls_certificate_set_x509_crl_file: %s"),
- gnutls_strerror (err));
- return -1;
- }
- }
-
- if (cert_file && cert_file[0] != '\0' && key_file && key_file[0] != '\0') {
- if (remoteCheckCertFile("server certificate", cert_file) < 0)
- return -1;
- if (remoteCheckCertFile("server key", key_file) < 0)
- return -1;
- DEBUG("loading cert and key from %s and %s", cert_file, key_file);
- err =
- gnutls_certificate_set_x509_key_file (x509_cred,
- cert_file, key_file,
- GNUTLS_X509_FMT_PEM);
- if (err < 0) {
- VIR_ERROR(_("gnutls_certificate_set_x509_key_file: %s"),
- gnutls_strerror (err));
- return -1;
- }
- }
-
- /* Generate Diffie Hellman parameters - for use with DHE
- * kx algorithms. These should be discarded and regenerated
- * once a day, once a week or once a month. Depending on the
- * security requirements.
- */
- err = gnutls_dh_params_init (&dh_params);
- if (err < 0) {
- VIR_ERROR(_("gnutls_dh_params_init: %s"), gnutls_strerror (err));
- return -1;
- }
- err = gnutls_dh_params_generate2 (dh_params, DH_BITS);
- if (err < 0) {
- VIR_ERROR(_("gnutls_dh_params_generate2: %s"), gnutls_strerror (err));
- return -1;
- }
-
- gnutls_certificate_set_dh_params (x509_cred, dh_params);
-
- return 0;
-}
-
-static void
-qemudDispatchSignalEvent(int watch ATTRIBUTE_UNUSED,
- int fd ATTRIBUTE_UNUSED,
- int events ATTRIBUTE_UNUSED,
- void *opaque) {
- struct qemud_server *server = (struct qemud_server *)opaque;
- siginfo_t siginfo;
- int ret;
-
- virMutexLock(&server->lock);
-
- if (saferead(server->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
- char ebuf[1024];
- VIR_ERROR(_("Failed to read from signal pipe: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- virMutexUnlock(&server->lock);
- return;
- }
-
- ret = 0;
-
- switch (siginfo.si_signo) {
- case SIGHUP:
- VIR_INFO0(_("Reloading configuration on SIGHUP"));
- if (virStateReload() < 0)
- VIR_WARN0(_("Error while reloading drivers"));
- break;
-
- case SIGINT:
- case SIGQUIT:
- case SIGTERM:
- VIR_WARN(_("Shutting down on signal %d"), siginfo.si_signo);
- server->shutdown = 1;
- break;
-
- default:
- VIR_INFO(_("Received unexpected signal %d"), siginfo.si_signo);
- break;
- }
-
- if (ret != 0)
- server->shutdown = 1;
-
- virMutexUnlock(&server->lock);
-}
-
-
-static int qemudGoDaemon(void) {
- int pid = fork();
- switch (pid) {
- case 0:
- {
- int stdinfd = -1;
- int stdoutfd = -1;
- int nextpid;
-
- if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
- goto cleanup;
- if ((stdoutfd = open("/dev/null", O_WRONLY)) < 0)
- goto cleanup;
- if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
- goto cleanup;
- if (dup2(stdoutfd, STDOUT_FILENO) != STDOUT_FILENO)
- goto cleanup;
- if (dup2(stdoutfd, STDERR_FILENO) != STDERR_FILENO)
- goto cleanup;
- if (close(stdinfd) < 0)
- goto cleanup;
- stdinfd = -1;
- if (close(stdoutfd) < 0)
- goto cleanup;
- stdoutfd = -1;
-
- if (setsid() < 0)
- goto cleanup;
-
- nextpid = fork();
- switch (nextpid) {
- case 0:
- return 0;
- case -1:
- return -1;
- default:
- _exit(0);
- }
-
- cleanup:
- if (stdoutfd != -1)
- close(stdoutfd);
- if (stdinfd != -1)
- close(stdinfd);
- return -1;
-
- }
-
- case -1:
- return -1;
-
- default:
- {
- int got, status = 0;
- /* We wait to make sure the next child forked
- successfully */
- if ((got = waitpid(pid, &status, 0)) < 0 ||
- got != pid ||
- status != 0) {
- return -1;
- }
- _exit(0);
- }
- }
-}
-
-static int qemudWritePidFile(const char *pidFile) {
- int fd;
- FILE *fh;
- char ebuf[1024];
-
- if (pidFile[0] == '\0')
- return 0;
-
- if ((fd = open(pidFile, O_WRONLY|O_CREAT|O_EXCL, 0644)) < 0) {
- VIR_ERROR(_("Failed to open pid file '%s' : %s"),
- pidFile, virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- if (!(fh = fdopen(fd, "w"))) {
- VIR_ERROR(_("Failed to fdopen pid file '%s' : %s"),
- pidFile, virStrerror(errno, ebuf, sizeof ebuf));
- close(fd);
- return -1;
- }
-
- if (fprintf(fh, "%lu\n", (unsigned long)getpid()) < 0) {
- VIR_ERROR(_("Failed to write to pid file '%s' : %s"),
- pidFile, virStrerror(errno, ebuf, sizeof ebuf));
- fclose(fh);
- return -1;
- }
-
- if (fclose(fh) == EOF) {
- VIR_ERROR(_("Failed to close pid file '%s' : %s"),
- pidFile, virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- return 0;
-}
-
-static int qemudListenUnix(struct qemud_server *server,
- const char *path, int readonly, int auth) {
- struct qemud_socket *sock;
- struct sockaddr_un addr;
- mode_t oldmask;
- gid_t oldgrp;
- char ebuf[1024];
-
- if (VIR_ALLOC(sock) < 0) {
- VIR_ERROR("%s", _("Failed to allocate memory for struct qemud_socket"));
- return -1;
- }
-
- sock->readonly = readonly;
- sock->port = -1;
- sock->type = QEMUD_SOCK_TYPE_UNIX;
- sock->auth = auth;
-
- if ((sock->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
- VIR_ERROR(_("Failed to create socket: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- goto cleanup;
- }
-
- if (virSetCloseExec(sock->fd) < 0 ||
- virSetNonBlock(sock->fd) < 0)
- goto cleanup;
-
- memset(&addr, 0, sizeof(addr));
- addr.sun_family = AF_UNIX;
- strncpy(addr.sun_path, path, sizeof(addr.sun_path)-1);
- if (addr.sun_path[0] == '@')
- addr.sun_path[0] = '\0';
-
-
- oldgrp = getgid();
- oldmask = umask(readonly ? ~unix_sock_ro_mask : ~unix_sock_rw_mask);
- if (server->privileged)
- setgid(unix_sock_gid);
-
- if (bind(sock->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
- VIR_ERROR(_("Failed to bind socket to '%s': %s"),
- path, virStrerror(errno, ebuf, sizeof ebuf));
- goto cleanup;
- }
- umask(oldmask);
- if (server->privileged)
- setgid(oldgrp);
-
- if (listen(sock->fd, 30) < 0) {
- VIR_ERROR(_("Failed to listen for connections on '%s': %s"),
- path, virStrerror(errno, ebuf, sizeof ebuf));
- goto cleanup;
- }
-
- if ((sock->watch = virEventAddHandleImpl(sock->fd,
- VIR_EVENT_HANDLE_READABLE |
- VIR_EVENT_HANDLE_ERROR |
- VIR_EVENT_HANDLE_HANGUP,
- qemudDispatchServerEvent,
- server, NULL)) < 0) {
- VIR_ERROR0(_("Failed to add server event callback"));
- goto cleanup;
- }
-
- sock->next = server->sockets;
- server->sockets = sock;
- server->nsockets++;
-
- return 0;
-
- cleanup:
- if (sock->fd)
- close(sock->fd);
- free(sock);
- return -1;
-}
-
-// See: http://people.redhat.com/drepper/userapi-ipv6.html
-static int
-remoteMakeSockets (int *fds, int max_fds, int *nfds_r, const char *node, const char *service)
-{
- struct addrinfo *ai;
- struct addrinfo hints;
- memset (&hints, 0, sizeof hints);
- hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
- hints.ai_socktype = SOCK_STREAM;
-
- int e = getaddrinfo (node, service, &hints, &ai);
- if (e != 0) {
- VIR_ERROR(_("getaddrinfo: %s\n"), gai_strerror (e));
- return -1;
- }
-
- struct addrinfo *runp = ai;
- while (runp && *nfds_r < max_fds) {
- char ebuf[1024];
- fds[*nfds_r] = socket (runp->ai_family, runp->ai_socktype,
- runp->ai_protocol);
- if (fds[*nfds_r] == -1) {
- VIR_ERROR(_("socket: %s"), virStrerror (errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- int opt = 1;
- setsockopt (fds[*nfds_r], SOL_SOCKET, SO_REUSEADDR, &opt, sizeof opt);
-
- if (bind (fds[*nfds_r], runp->ai_addr, runp->ai_addrlen) == -1) {
- if (errno != EADDRINUSE) {
- VIR_ERROR(_("bind: %s"), virStrerror (errno, ebuf, sizeof ebuf));
- return -1;
- }
- close (fds[*nfds_r]);
- }
- else {
- if (listen (fds[*nfds_r], SOMAXCONN) == -1) {
- VIR_ERROR(_("listen: %s"),
- virStrerror (errno, ebuf, sizeof ebuf));
- return -1;
- }
- ++*nfds_r;
- }
- runp = runp->ai_next;
- }
-
- freeaddrinfo (ai);
- return 0;
-}
-
-/* Listen on the named/numbered TCP port. On a machine with IPv4 and
- * IPv6 interfaces this may generate several sockets.
- */
-static int
-remoteListenTCP (struct qemud_server *server,
- const char *addr,
- const char *port,
- int type,
- int auth)
-{
- int fds[2];
- int nfds = 0;
- int i;
- struct qemud_socket *sock;
-
- if (remoteMakeSockets (fds, 2, &nfds, addr, port) == -1)
- return -1;
-
- for (i = 0; i < nfds; ++i) {
- union {
- struct sockaddr_storage sa_stor;
- struct sockaddr sa;
- struct sockaddr_in sa_in;
-#ifdef AF_INET6
- struct sockaddr_in6 sa_in6;
-#endif
- } s;
- char ebuf[1024];
- socklen_t salen = sizeof(s);
-
- if (VIR_ALLOC(sock) < 0) {
- VIR_ERROR(_("remoteListenTCP: calloc: %s"),
- virStrerror (errno, ebuf, sizeof ebuf));
- goto cleanup;
- }
-
- sock->readonly = 0;
- sock->next = server->sockets;
- server->sockets = sock;
- server->nsockets++;
-
- sock->fd = fds[i];
- sock->type = type;
- sock->auth = auth;
-
- if (getsockname(sock->fd, &s.sa, &salen) < 0)
- goto cleanup;
-
- if (s.sa.sa_family == AF_INET) {
- sock->port = htons(s.sa_in.sin_port);
-#ifdef AF_INET6
- } else if (s.sa.sa_family == AF_INET6)
- sock->port = htons(s.sa_in6.sin6_port);
-#endif
- else
- sock->port = -1;
-
- if (virSetCloseExec(sock->fd) < 0 ||
- virSetNonBlock(sock->fd) < 0)
- goto cleanup;
-
- if (listen (sock->fd, 30) < 0) {
- VIR_ERROR(_("remoteListenTCP: listen: %s"),
- virStrerror (errno, ebuf, sizeof ebuf));
- goto cleanup;
- }
-
- if ((sock->watch = virEventAddHandleImpl(sock->fd,
- VIR_EVENT_HANDLE_READABLE |
- VIR_EVENT_HANDLE_ERROR |
- VIR_EVENT_HANDLE_HANGUP,
- qemudDispatchServerEvent,
- server, NULL)) < 0) {
- VIR_ERROR0(_("Failed to add server event callback"));
- goto cleanup;
- }
-
- }
-
- return 0;
-
-cleanup:
- for (i = 0; i < nfds; ++i)
- close(fds[i]);
- return -1;
-}
-
-static int qemudInitPaths(struct qemud_server *server,
- char *sockname,
- char *roSockname,
- int maxlen)
-{
- char *sock_dir;
- char *dir_prefix = NULL;
- int ret = -1;
- char *sock_dir_prefix = NULL;
-
- if (unix_sock_dir)
- sock_dir = unix_sock_dir;
- else {
- sock_dir = sockname;
- if (server->privileged) {
- dir_prefix = strdup (LOCAL_STATE_DIR);
- if (dir_prefix == NULL) {
- virReportOOMError(NULL);
- goto cleanup;
- }
- if (snprintf (sock_dir, maxlen, "%s/run/libvirt",
- dir_prefix) >= maxlen)
- goto snprintf_error;
- } else {
- uid_t uid = geteuid();
- dir_prefix = virGetUserDirectory(NULL, uid);
- if (dir_prefix == NULL) {
- /* Do not diagnose here; virGetUserDirectory does that. */
- goto snprintf_error;
- }
-
- if (snprintf(sock_dir, maxlen, "%s/.libvirt", dir_prefix) >= maxlen)
- goto snprintf_error;
- }
- }
-
- sock_dir_prefix = strdup (sock_dir);
- if (!sock_dir_prefix) {
- virReportOOMError(NULL);
- goto cleanup;
- }
-
- if (server->privileged) {
- if (snprintf (sockname, maxlen, "%s/libvirt-sock",
- sock_dir_prefix) >= maxlen
- || (snprintf (roSockname, maxlen, "%s/libvirt-sock-ro",
- sock_dir_prefix) >= maxlen))
- goto snprintf_error;
- unlink(sockname);
- unlink(roSockname);
- } else {
- if (snprintf(sockname, maxlen, "@%s/libvirt-sock",
- sock_dir_prefix) >= maxlen)
- goto snprintf_error;
- }
-
- if (server->privileged)
- server->logDir = strdup (LOCAL_STATE_DIR "/log/libvirt");
- else
- virAsprintf(&server->logDir, "%s/.libvirt/log", dir_prefix);
-
- if (server->logDir == NULL)
- virReportOOMError(NULL);
-
- ret = 0;
-
- snprintf_error:
- if (ret)
- VIR_ERROR("%s",
- _("Resulting path too long for buffer in qemudInitPaths()"));
-
- cleanup:
- free (dir_prefix);
- free (sock_dir_prefix);
- return ret;
-}
-
-static struct qemud_server *qemudInitialize(int sigread) {
- struct qemud_server *server;
-
- if (VIR_ALLOC(server) < 0) {
- VIR_ERROR0(_("Failed to allocate struct qemud_server"));
- return NULL;
- }
-
- if (virMutexInit(&server->lock) < 0) {
- VIR_ERROR("%s", _("cannot initialize mutex"));
- VIR_FREE(server);
- }
- if (virCondInit(&server->job) < 0) {
- VIR_ERROR("%s", _("cannot initialize condition variable"));
- virMutexDestroy(&server->lock);
- VIR_FREE(server);
- }
-
- server->privileged = geteuid() == 0 ? 1 : 0;
- server->sigread = sigread;
-
- if (virEventInit() < 0) {
- VIR_ERROR0(_("Failed to initialize event system"));
- VIR_FREE(server);
- return NULL;
- }
-
- virInitialize();
-
- /*
- * Note that the order is important: the first ones have a higher
- * priority when calling virStateInitialize. We must register
- * the network, storage and nodedev drivers before any domain
- * drivers, since their resources must be auto-started before
- * any domains can be auto-started.
- */
-#ifdef WITH_DRIVER_MODULES
- /* We don't care if any of these fail, because the whole point
- * is to allow users to only install modules they want to use.
- * If they try to use a open a connection for a module that
- * is not loaded they'll get a suitable error at that point
- */
- virDriverLoadModule("network");
- virDriverLoadModule("storage");
- virDriverLoadModule("nodedev");
- virDriverLoadModule("secret");
- virDriverLoadModule("qemu");
- virDriverLoadModule("lxc");
- virDriverLoadModule("uml");
- virDriverLoadModule("one");
-#else
-#ifdef WITH_NETWORK
- networkRegister();
-#endif
-#ifdef WITH_NETCF
- interfaceRegister();
-#endif
-#ifdef WITH_STORAGE_DIR
- storageRegister();
-#endif
-#if defined(WITH_NODE_DEVICES) && \
- (defined(HAVE_HAL) || defined(HAVE_DEVKIT))
- nodedevRegister();
-#endif
- secretRegister();
-#ifdef WITH_QEMU
- qemuRegister();
-#endif
-#ifdef WITH_LXC
- lxcRegister();
-#endif
-#ifdef WITH_UML
- umlRegister();
-#endif
-#ifdef WITH_ONE
- oneRegister();
-#endif
-#endif
-
- virEventRegisterImpl(virEventAddHandleImpl,
- virEventUpdateHandleImpl,
- virEventRemoveHandleImpl,
- virEventAddTimeoutImpl,
- virEventUpdateTimeoutImpl,
- virEventRemoveTimeoutImpl);
-
- virStateInitialize(server->privileged);
-
- return server;
-}
-
-static struct qemud_server *qemudNetworkInit(struct qemud_server *server) {
- struct qemud_socket *sock;
- char sockname[PATH_MAX];
- char roSockname[PATH_MAX];
-#if HAVE_SASL
- int err;
-#endif /* HAVE_SASL */
-
- roSockname[0] = '\0';
-
- if (qemudInitPaths(server, sockname, roSockname, PATH_MAX) < 0)
- goto cleanup;
-
- if (qemudListenUnix(server, sockname, 0, auth_unix_rw) < 0)
- goto cleanup;
-
- if (roSockname[0] != '\0' && qemudListenUnix(server, roSockname, 1, auth_unix_ro) < 0)
- goto cleanup;
-
-#if HAVE_SASL
- if (auth_unix_rw == REMOTE_AUTH_SASL ||
- auth_unix_ro == REMOTE_AUTH_SASL ||
- auth_tcp == REMOTE_AUTH_SASL ||
- auth_tls == REMOTE_AUTH_SASL) {
- if ((err = sasl_server_init(NULL, "libvirt")) != SASL_OK) {
- VIR_ERROR(_("Failed to initialize SASL authentication %s"),
- sasl_errstring(err, NULL, NULL));
- goto cleanup;
- }
- }
-#endif
-
-#if HAVE_POLKIT0
- if (auth_unix_rw == REMOTE_AUTH_POLKIT ||
- auth_unix_ro == REMOTE_AUTH_POLKIT) {
- DBusError derr;
-
- dbus_connection_set_change_sigpipe(FALSE);
- dbus_threads_init_default();
-
- dbus_error_init(&derr);
- server->sysbus = dbus_bus_get(DBUS_BUS_SYSTEM, &derr);
- if (!(server->sysbus)) {
- VIR_ERROR(_("Failed to connect to system bus for PolicyKit auth: %s"),
- derr.message);
- dbus_error_free(&derr);
- goto cleanup;
- }
- dbus_connection_set_exit_on_disconnect(server->sysbus, FALSE);
- }
-#endif
-
- if (ipsock) {
- if (listen_tcp && remoteListenTCP (server, listen_addr, tcp_port, QEMUD_SOCK_TYPE_TCP, auth_tcp) < 0)
- goto cleanup;
-
- if (listen_tls) {
- if (remoteInitializeGnuTLS () < 0)
- goto cleanup;
-
- if (remoteListenTCP (server, listen_addr, tls_port, QEMUD_SOCK_TYPE_TLS, auth_tls) < 0)
- goto cleanup;
- }
- }
-
-#ifdef HAVE_AVAHI
- if (server->privileged && mdns_adv) {
- struct libvirtd_mdns_group *group;
- int port = 0;
-
- server->mdns = libvirtd_mdns_new();
-
- if (!mdns_name) {
- char groupname[64], localhost[HOST_NAME_MAX+1], *tmp;
- /* Extract the host part of the potentially FQDN */
- gethostname(localhost, HOST_NAME_MAX);
- localhost[HOST_NAME_MAX] = '\0';
- if ((tmp = strchr(localhost, '.')))
- *tmp = '\0';
- snprintf(groupname, sizeof(groupname)-1, "Virtualization Host %s", localhost);
- groupname[sizeof(groupname)-1] = '\0';
- group = libvirtd_mdns_add_group(server->mdns, groupname);
- } else {
- group = libvirtd_mdns_add_group(server->mdns, mdns_name);
- }
-
- /*
- * See if there's a TLS enabled port we can advertise. Cowardly
- * don't bother to advertise TCP since we don't want people using
- * them for real world apps
- */
- sock = server->sockets;
- while (sock) {
- if (sock->port != -1 && sock->type == QEMUD_SOCK_TYPE_TLS) {
- port = sock->port;
- break;
- }
- sock = sock->next;
- }
-
- /*
- * Add the primary entry - we choose SSH because its most likely to always
- * be available
- */
- libvirtd_mdns_add_entry(group, "_libvirt._tcp", port);
- libvirtd_mdns_start(server->mdns);
- }
-#endif
-
- return server;
-
- cleanup:
- if (server) {
- sock = server->sockets;
- while (sock) {
- close(sock->fd);
- sock = sock->next;
- }
-
-#if HAVE_POLKIT0
- if (server->sysbus)
- dbus_connection_unref(server->sysbus);
-#endif
- free(server);
- }
- return NULL;
-}
-
-static gnutls_session_t
-remoteInitializeTLSSession (void)
-{
- gnutls_session_t session;
- int err;
-
- err = gnutls_init (&session, GNUTLS_SERVER);
- if (err != 0) goto failed;
-
- /* avoid calling all the priority functions, since the defaults
- * are adequate.
- */
- err = gnutls_set_default_priority (session);
- if (err != 0) goto failed;
-
- err = gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
- if (err != 0) goto failed;
-
- /* request client certificate if any.
- */
- gnutls_certificate_server_set_request (session, GNUTLS_CERT_REQUEST);
-
- gnutls_dh_set_prime_bits (session, DH_BITS);
-
- return session;
-
- failed:
- VIR_ERROR(_("remoteInitializeTLSSession: %s"),
- gnutls_strerror (err));
- return NULL;
-}
-
-/* Check DN is on tls_allowed_dn_list. */
-static int
-remoteCheckDN (gnutls_x509_crt_t cert)
-{
- char name[256];
- size_t namesize = sizeof name;
- char **wildcards;
- int err;
-
- err = gnutls_x509_crt_get_dn (cert, name, &namesize);
- if (err != 0) {
- VIR_ERROR(_("remoteCheckDN: gnutls_x509_cert_get_dn: %s"),
- gnutls_strerror (err));
- return 0;
- }
-
- /* If the list is not set, allow any DN. */
- wildcards = tls_allowed_dn_list;
- if (!wildcards)
- return 1;
-
- while (*wildcards) {
- if (fnmatch (*wildcards, name, 0) == 0)
- return 1;
- wildcards++;
- }
-
- /* Print the client's DN. */
- DEBUG(_("remoteCheckDN: failed: client DN is %s"), name);
-
- return 0; // Not found.
-}
-
-static int
-remoteCheckCertificate (gnutls_session_t session)
-{
- int ret;
- unsigned int status;
- const gnutls_datum_t *certs;
- unsigned int nCerts, i;
- time_t now;
-
- if ((ret = gnutls_certificate_verify_peers2 (session, &status)) < 0){
- VIR_ERROR(_("remoteCheckCertificate: verify failed: %s"),
- gnutls_strerror (ret));
- return -1;
- }
-
- if (status != 0) {
- if (status & GNUTLS_CERT_INVALID)
- VIR_ERROR0(_("remoteCheckCertificate: "
- "the client certificate is not trusted."));
-
- if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
- VIR_ERROR0(_("remoteCheckCertificate: the client "
- "certificate has unknown issuer."));
-
- if (status & GNUTLS_CERT_REVOKED)
- VIR_ERROR0(_("remoteCheckCertificate: "
- "the client certificate has been revoked."));
-
-#ifndef GNUTLS_1_0_COMPAT
- if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
- VIR_ERROR0(_("remoteCheckCertificate: the client certificate"
- " uses an insecure algorithm."));
-#endif
-
- return -1;
- }
-
- if (gnutls_certificate_type_get (session) != GNUTLS_CRT_X509) {
- VIR_ERROR0(_("remoteCheckCertificate: certificate is not X.509"));
- return -1;
- }
-
- if (!(certs = gnutls_certificate_get_peers(session, &nCerts))) {
- VIR_ERROR0(_("remoteCheckCertificate: no peers"));
- return -1;
- }
-
- now = time (NULL);
-
- for (i = 0; i < nCerts; i++) {
- gnutls_x509_crt_t cert;
-
- if (gnutls_x509_crt_init (&cert) < 0) {
- VIR_ERROR0(_("remoteCheckCertificate: gnutls_x509_crt_init failed"));
- return -1;
- }
-
- if (gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER) < 0) {
- gnutls_x509_crt_deinit (cert);
- return -1;
- }
-
- if (gnutls_x509_crt_get_expiration_time (cert) < now) {
- VIR_ERROR0(_("remoteCheckCertificate: "
- "the client certificate has expired"));
- gnutls_x509_crt_deinit (cert);
- return -1;
- }
-
- if (gnutls_x509_crt_get_activation_time (cert) > now) {
- VIR_ERROR0(_("remoteCheckCertificate: the client "
- "certificate is not yet activated"));
- gnutls_x509_crt_deinit (cert);
- return -1;
- }
-
- if (i == 0) {
- if (!remoteCheckDN (cert)) {
- /* This is the most common error: make it informative. */
- VIR_ERROR0(_("remoteCheckCertificate: client's Distinguished Name is not on the list of allowed clients (tls_allowed_dn_list). Use 'openssl x509 -in clientcert.pem -text' to view the Distinguished Name field in the client certificate, or run this daemon with --verbose option."));
- gnutls_x509_crt_deinit (cert);
- return -1;
- }
- }
- }
-
- return 0;
-}
-
-/* Check the client's access. */
-static int
-remoteCheckAccess (struct qemud_client *client)
-{
- struct qemud_client_message *confirm;
-
- /* Verify client certificate. */
- if (remoteCheckCertificate (client->tlssession) == -1) {
- VIR_ERROR0(_("remoteCheckCertificate: "
- "failed to verify client's certificate"));
- if (!tls_no_verify_certificate) return -1;
- else VIR_INFO0(_("remoteCheckCertificate: tls_no_verify_certificate "
- "is set so the bad certificate is ignored"));
- }
-
- if (client->tx) {
- VIR_INFO("%s",
- _("client had unexpected data pending tx after access check"));
- return -1;
- }
-
- if (VIR_ALLOC(confirm) < 0)
- return -1;
-
- /* Checks have succeeded. Write a '\1' byte back to the client to
- * indicate this (otherwise the socket is abruptly closed).
- * (NB. The '\1' byte is sent in an encrypted record).
- */
- confirm->async = 1;
- confirm->bufferLength = 1;
- confirm->bufferOffset = 0;
- confirm->buffer[0] = '\1';
-
- client->tx = confirm;
- return 0;
-}
-
-#if HAVE_POLKIT
-int qemudGetSocketIdentity(int fd, uid_t *uid, pid_t *pid) {
-#ifdef SO_PEERCRED
- struct ucred cr;
- unsigned int cr_len = sizeof (cr);
-
- if (getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) < 0) {
- char ebuf[1024];
- VIR_ERROR(_("Failed to verify client credentials: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- *pid = cr.pid;
- *uid = cr.uid;
-#else
- /* XXX Many more OS support UNIX socket credentials we could port to. See dbus ....*/
-#error "UNIX socket credentials not supported/implemented on this platform yet..."
-#endif
- return 0;
-}
-#endif
-
-
-static int qemudDispatchServer(struct qemud_server *server, struct qemud_socket *sock) {
- int fd;
- struct sockaddr_storage addr;
- socklen_t addrlen = (socklen_t) (sizeof addr);
- struct qemud_client *client;
- int no_slow_start = 1;
-
- if ((fd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen)) < 0) {
- char ebuf[1024];
- if (errno == EAGAIN)
- return 0;
- VIR_ERROR(_("Failed to accept connection: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- if (server->nclients >= max_clients) {
- VIR_ERROR(_("Too many active clients (%d), dropping connection"), max_clients);
- close(fd);
- return -1;
- }
-
- if (VIR_REALLOC_N(server->clients, server->nclients+1) < 0) {
- VIR_ERROR0(_("Out of memory allocating clients"));
- close(fd);
- return -1;
- }
-
-#ifdef __sun
- {
- ucred_t *ucred = NULL;
- const priv_set_t *privs;
-
- if (getpeerucred (fd, &ucred) == -1 ||
- (privs = ucred_getprivset (ucred, PRIV_EFFECTIVE)) == NULL) {
- if (ucred != NULL)
- ucred_free (ucred);
- close (fd);
- return -1;
- }
-
- if (!priv_ismember (privs, PRIV_VIRT_MANAGE)) {
- ucred_free (ucred);
- close (fd);
- return -1;
- }
-
- ucred_free (ucred);
- }
-#endif /* __sun */
-
- /* Disable Nagle. Unix sockets will ignore this. */
- setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&no_slow_start,
- sizeof no_slow_start);
-
- if (virSetCloseExec(fd) < 0 ||
- virSetNonBlock(fd) < 0) {
- close(fd);
- return -1;
- }
-
- if (VIR_ALLOC(client) < 0)
- goto cleanup;
- if (virMutexInit(&client->lock) < 0) {
- VIR_ERROR("%s", _("cannot initialize mutex"));
- VIR_FREE(client);
- goto cleanup;
- }
-
- client->magic = QEMUD_CLIENT_MAGIC;
- client->fd = fd;
- client->readonly = sock->readonly;
- client->type = sock->type;
- client->auth = sock->auth;
- memcpy (&client->addr, &addr, sizeof addr);
- client->addrlen = addrlen;
-
- /* Prepare one for packet receive */
- if (VIR_ALLOC(client->rx) < 0)
- goto cleanup;
- client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
-
-
-#if HAVE_POLKIT
- /* Only do policy checks for non-root - allow root user
- through with no checks, as a fail-safe - root can easily
- change policykit policy anyway, so its pointless trying
- to restrict root */
- if (client->auth == REMOTE_AUTH_POLKIT) {
- uid_t uid;
- pid_t pid;
-
- if (qemudGetSocketIdentity(client->fd, &uid, &pid) < 0)
- goto cleanup;
-
- /* Client is running as root, so disable auth */
- if (uid == 0) {
- VIR_INFO(_("Turn off polkit auth for privileged client %d"), pid);
- client->auth = REMOTE_AUTH_NONE;
- }
- }
-#endif
-
- if (client->type != QEMUD_SOCK_TYPE_TLS) {
- /* Plain socket, so prepare to read first message */
- if (qemudRegisterClientEvent (server, client) < 0)
- goto cleanup;
- } else {
- int ret;
-
- client->tlssession = remoteInitializeTLSSession ();
- if (client->tlssession == NULL)
- goto cleanup;
-
- gnutls_transport_set_ptr (client->tlssession,
- (gnutls_transport_ptr_t) (long) fd);
-
- /* Begin the TLS handshake. */
- ret = gnutls_handshake (client->tlssession);
- if (ret == 0) {
- client->handshake = 0;
-
- /* Unlikely, but ... Next step is to check the certificate. */
- if (remoteCheckAccess (client) == -1)
- goto cleanup;
-
- /* Handshake & cert check OK, so prepare to read first message */
- if (qemudRegisterClientEvent(server, client) < 0)
- goto cleanup;
- } else if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
- /* Most likely, need to do more handshake data */
- client->handshake = 1;
-
- if (qemudRegisterClientEvent (server, client) < 0)
- goto cleanup;
- } else {
- VIR_ERROR(_("TLS handshake failed: %s"),
- gnutls_strerror (ret));
- goto cleanup;
- }
- }
-
- server->clients[server->nclients++] = client;
-
- if (server->nclients > server->nactiveworkers &&
- server->nactiveworkers < server->nworkers) {
- int i;
- for (i = 0 ; i < server->nworkers ; i++) {
- if (!server->workers[i].hasThread) {
- if (qemudStartWorker(server, &server->workers[i]) < 0)
- return -1;
- server->nactiveworkers++;
- break;
- }
- }
- }
-
-
- return 0;
-
- cleanup:
- if (client &&
- client->tlssession) gnutls_deinit (client->tlssession);
- close (fd);
- VIR_FREE(client->rx);
- VIR_FREE(client);
- return -1;
-}
-
-
-/*
- * You must hold lock for at least the client
- * We don't free stuff here, merely disconnect the client's
- * network socket & resources.
- * We keep the libvirt connection open until any async
- * jobs have finished, then clean it up elsehwere
- */
-void qemudDispatchClientFailure(struct qemud_client *client) {
- if (client->watch != -1) {
- virEventRemoveHandleImpl(client->watch);
- client->watch = -1;
- }
-
- /* Deregister event delivery callback */
- if(client->conn) {
- DEBUG0("Deregistering to relay remote events");
- virConnectDomainEventDeregister(client->conn, remoteRelayDomainEvent);
- }
-
-#if HAVE_SASL
- if (client->saslconn) {
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- }
- free(client->saslUsername);
- client->saslUsername = NULL;
-#endif
- if (client->tlssession) {
- gnutls_deinit (client->tlssession);
- client->tlssession = NULL;
- }
- if (client->fd != -1) {
- close(client->fd);
- client->fd = -1;
- }
-}
-
-
-/* Caller must hold server lock */
-static struct qemud_client *qemudPendingJob(struct qemud_server *server)
-{
- int i;
- for (i = 0 ; i < server->nclients ; i++) {
- virMutexLock(&server->clients[i]->lock);
- if (server->clients[i]->dx) {
- /* Delibrately don't unlock client - caller wants the lock */
- return server->clients[i];
- }
- virMutexUnlock(&server->clients[i]->lock);
- }
- return NULL;
-}
-
-static void *qemudWorker(void *data)
-{
- struct qemud_worker *worker = data;
- struct qemud_server *server = worker->server;
-
- while (1) {
- struct qemud_client *client = NULL;
- struct qemud_client_message *msg;
-
- virMutexLock(&server->lock);
- while (((client = qemudPendingJob(server)) == NULL) &&
- !worker->quitRequest) {
- if (virCondWait(&server->job, &server->lock) < 0) {
- virMutexUnlock(&server->lock);
- return NULL;
- }
- }
- if (worker->quitRequest) {
- if (client)
- virMutexUnlock(&client->lock);
- virMutexUnlock(&server->lock);
- return NULL;
- }
- worker->processingCall = 1;
- virMutexUnlock(&server->lock);
-
- /* We own a locked client now... */
- client->refs++;
-
- /* Remove our message from dispatch queue while we use it */
- msg = qemudClientMessageQueueServe(&client->dx);
-
- /* This function drops the lock during dispatch,
- * and re-acquires it before returning */
- if (remoteDispatchClientRequest (server, client, msg) < 0) {
- VIR_FREE(msg);
- qemudDispatchClientFailure(client);
- client->refs--;
- virMutexUnlock(&client->lock);
- continue;
- }
-
- client->refs--;
- virMutexUnlock(&client->lock);
-
- virMutexLock(&server->lock);
- worker->processingCall = 0;
- virMutexUnlock(&server->lock);
- }
-}
-
-static int qemudStartWorker(struct qemud_server *server,
- struct qemud_worker *worker) {
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- /* We want to join workers, so don't detach them */
- /*pthread_attr_setdetachstate(&attr, 1);*/
-
- if (worker->hasThread)
- return -1;
-
- worker->server = server;
- worker->hasThread = 1;
- worker->quitRequest = 0;
- worker->processingCall = 0;
-
- if (pthread_create(&worker->thread,
- &attr,
- qemudWorker,
- worker) != 0) {
- worker->hasThread = 0;
- worker->server = NULL;
- return -1;
- }
-
- return 0;
-}
-
-
-/*
- * Read data into buffer using wire decoding (plain or TLS)
- *
- * Returns:
- * -1 on error or EOF
- * 0 on EAGAIN
- * n number of bytes
- */
-static ssize_t qemudClientReadBuf(struct qemud_client *client,
- char *data, ssize_t len) {
- ssize_t ret;
-
- if (len < 0) {
- VIR_ERROR(_("unexpected negative length request %lld"),
- (long long int) len);
- qemudDispatchClientFailure(client);
- return -1;
- }
-
- /*qemudDebug ("qemudClientRead: len = %d", len);*/
-
- if (!client->tlssession) {
- char ebuf[1024];
- ret = read (client->fd, data, len);
- if (ret == -1 && (errno == EAGAIN ||
- errno == EINTR))
- return 0;
- if (ret <= 0) {
- if (ret != 0)
- VIR_ERROR(_("read: %s"),
- virStrerror (errno, ebuf, sizeof ebuf));
- qemudDispatchClientFailure(client);
- return -1;
- }
- } else {
- ret = gnutls_record_recv (client->tlssession, data, len);
-
- if (ret < 0 && (ret == GNUTLS_E_AGAIN ||
- ret == GNUTLS_E_INTERRUPTED))
- return 0;
- if (ret <= 0) {
- if (ret != 0)
- VIR_ERROR(_("gnutls_record_recv: %s"),
- gnutls_strerror (ret));
- qemudDispatchClientFailure(client);
- return -1;
- }
- }
-
- return ret;
-}
-
-/*
- * Read data into buffer without decoding
- *
- * Returns:
- * -1 on error or EOF
- * 0 on EAGAIN
- * n number of bytes
- */
-static ssize_t qemudClientReadPlain(struct qemud_client *client) {
- ssize_t ret;
- ret = qemudClientReadBuf(client,
- client->rx->buffer + client->rx->bufferOffset,
- client->rx->bufferLength - client->rx->bufferOffset);
- if (ret <= 0)
- return ret; /* -1 error, 0 eagain */
-
- client->rx->bufferOffset += ret;
- return ret;
-}
-
-#if HAVE_SASL
-/*
- * Read data into buffer decoding with SASL
- *
- * Returns:
- * -1 on error or EOF
- * 0 on EAGAIN
- * n number of bytes
- */
-static ssize_t qemudClientReadSASL(struct qemud_client *client) {
- ssize_t got, want;
-
- /* We're doing a SSF data read, so now its times to ensure
- * future writes are under SSF too.
- *
- * cf remoteSASLCheckSSF in remote.c
- */
- client->saslSSF |= QEMUD_SASL_SSF_WRITE;
-
- /* Need to read some more data off the wire */
- if (client->saslDecoded == NULL) {
- int ret;
- char encoded[8192];
- ssize_t encodedLen = sizeof(encoded);
- encodedLen = qemudClientReadBuf(client, encoded, encodedLen);
-
- if (encodedLen <= 0)
- return encodedLen;
-
- ret = sasl_decode(client->saslconn, encoded, encodedLen,
- &client->saslDecoded, &client->saslDecodedLength);
- if (ret != SASL_OK) {
- VIR_ERROR(_("failed to decode SASL data %s"),
- sasl_errstring(ret, NULL, NULL));
- qemudDispatchClientFailure(client);
- return -1;
- }
-
- client->saslDecodedOffset = 0;
- }
-
- /* Some buffered decoded data to return now */
- got = client->saslDecodedLength - client->saslDecodedOffset;
- want = client->rx->bufferLength - client->rx->bufferOffset;
-
- if (want > got)
- want = got;
-
- memcpy(client->rx->buffer + client->rx->bufferOffset,
- client->saslDecoded + client->saslDecodedOffset, want);
- client->saslDecodedOffset += want;
- client->rx->bufferOffset += want;
-
- if (client->saslDecodedOffset == client->saslDecodedLength) {
- client->saslDecoded = NULL;
- client->saslDecodedOffset = client->saslDecodedLength = 0;
- }
-
- return want;
-}
-#endif
-
-/*
- * Read as much data off wire as possible till we fill our
- * buffer, or would block on I/O
- */
-static ssize_t qemudClientRead(struct qemud_client *client) {
-#if HAVE_SASL
- if (client->saslSSF & QEMUD_SASL_SSF_READ)
- return qemudClientReadSASL(client);
- else
-#endif
- return qemudClientReadPlain(client);
-}
-
-
-/*
- * Read data until we get a complete message to process
- */
-static void qemudDispatchClientRead(struct qemud_server *server,
- struct qemud_client *client) {
- /*qemudDebug ("qemudDispatchClientRead: mode = %d", client->mode);*/
-
-readmore:
- if (qemudClientRead(client) < 0)
- return; /* Error */
-
- if (client->rx->bufferOffset < client->rx->bufferLength)
- return; /* Still not read enough */
-
- /* Either done with length word header */
- if (client->rx->bufferLength == REMOTE_MESSAGE_HEADER_XDR_LEN) {
- unsigned int len;
- XDR x;
-
- xdrmem_create(&x, client->rx->buffer, client->rx->bufferLength, XDR_DECODE);
-
- if (!xdr_u_int(&x, &len)) {
- xdr_destroy (&x);
- DEBUG0("Failed to decode packet length");
- qemudDispatchClientFailure(client);
- return;
- }
- xdr_destroy (&x);
-
- if (len < REMOTE_MESSAGE_HEADER_XDR_LEN) {
- DEBUG("Packet length %u too small", len);
- qemudDispatchClientFailure(client);
- return;
- }
-
- /* Length includes the size of the length word itself */
- len -= REMOTE_MESSAGE_HEADER_XDR_LEN;
-
- if (len > REMOTE_MESSAGE_MAX) {
- DEBUG("Packet length %u too large", len);
- qemudDispatchClientFailure(client);
- return;
- }
-
- /* Prepare to read rest of message */
- client->rx->bufferLength += len;
-
- qemudUpdateClientEvent(client);
-
- /* Try and read payload immediately instead of going back
- into poll() because chances are the data is already
- waiting for us */
- goto readmore;
- } else {
- /* Grab the completed message */
- struct qemud_client_message *msg = qemudClientMessageQueueServe(&client->rx);
- struct qemud_client_filter *filter;
-
- /* Decode the header so we can use it for routing decisions */
- if (remoteDecodeClientMessageHeader(msg) < 0) {
- VIR_FREE(msg);
- qemudDispatchClientFailure(client);
- }
-
- /* Check if any filters match this message */
- filter = client->filters;
- while (filter) {
- if ((filter->query)(msg, filter->opaque)) {
- qemudClientMessageQueuePush(&filter->dx, msg);
- msg = NULL;
- break;
- }
- filter = filter->next;
- }
-
- /* Move completed message to the end of the dispatch queue */
- if (msg)
- qemudClientMessageQueuePush(&client->dx, msg);
- client->nrequests++;
-
- /* Possibly need to create another receive buffer */
- if ((client->nrequests < max_client_requests &&
- VIR_ALLOC(client->rx) < 0)) {
- qemudDispatchClientFailure(client);
- } else {
- if (client->rx)
- client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
-
- qemudUpdateClientEvent(client);
-
- /* Tell one of the workers to get on with it... */
- virCondSignal(&server->job);
- }
- }
-}
-
-
-/*
- * Send a chunk of data using wire encoding (plain or TLS)
- *
- * Returns:
- * -1 on error
- * 0 on EAGAIN
- * n number of bytes
- */
-static ssize_t qemudClientWriteBuf(struct qemud_client *client,
- const char *data, ssize_t len) {
- ssize_t ret;
-
- if (len < 0) {
- VIR_ERROR(_("unexpected negative length request %lld"),
- (long long int) len);
- qemudDispatchClientFailure(client);
- return -1;
- }
-
- if (!client->tlssession) {
- char ebuf[1024];
- if ((ret = write(client->fd, data, len)) == -1) {
- if (errno == EAGAIN || errno == EINTR)
- return 0;
- VIR_ERROR(_("write: %s"), virStrerror (errno, ebuf, sizeof ebuf));
- qemudDispatchClientFailure(client);
- return -1;
- }
- } else {
- ret = gnutls_record_send (client->tlssession, data, len);
- if (ret < 0) {
- if (ret == GNUTLS_E_INTERRUPTED ||
- ret == GNUTLS_E_AGAIN)
- return 0;
-
- VIR_ERROR(_("gnutls_record_send: %s"), gnutls_strerror (ret));
- qemudDispatchClientFailure(client);
- return -1;
- }
- }
- return ret;
-}
-
-
-/*
- * Send client->tx using no encoding
- *
- * Returns:
- * -1 on error or EOF
- * 0 on EAGAIN
- * n number of bytes
- */
-static int qemudClientWritePlain(struct qemud_client *client) {
- int ret = qemudClientWriteBuf(client,
- client->tx->buffer + client->tx->bufferOffset,
- client->tx->bufferLength - client->tx->bufferOffset);
- if (ret <= 0)
- return ret; /* -1 error, 0 = egain */
- client->tx->bufferOffset += ret;
- return ret;
-}
-
-
-#if HAVE_SASL
-/*
- * Send client->tx using SASL encoding
- *
- * Returns:
- * -1 on error
- * 0 on EAGAIN
- * n number of bytes
- */
-static int qemudClientWriteSASL(struct qemud_client *client) {
- int ret;
-
- /* Not got any pending encoded data, so we need to encode raw stuff */
- if (client->saslEncoded == NULL) {
- ret = sasl_encode(client->saslconn,
- client->tx->buffer + client->tx->bufferOffset,
- client->tx->bufferLength - client->tx->bufferOffset,
- &client->saslEncoded,
- &client->saslEncodedLength);
-
- if (ret != SASL_OK) {
- VIR_ERROR(_("failed to encode SASL data %s"),
- sasl_errstring(ret, NULL, NULL));
- qemudDispatchClientFailure(client);
- return -1;
- }
-
- client->saslEncodedOffset = 0;
- }
-
- /* Send some of the encoded stuff out on the wire */
- ret = qemudClientWriteBuf(client,
- client->saslEncoded + client->saslEncodedOffset,
- client->saslEncodedLength - client->saslEncodedOffset);
-
- if (ret <= 0)
- return ret; /* -1 error, 0 == egain */
-
- /* Note how much we sent */
- client->saslEncodedOffset += ret;
-
- /* Sent all encoded, so update raw buffer to indicate completion */
- if (client->saslEncodedOffset == client->saslEncodedLength) {
- client->saslEncoded = NULL;
- client->saslEncodedOffset = client->saslEncodedLength = 0;
-
- /* Mark as complete, so caller detects completion */
- client->tx->bufferOffset = client->tx->bufferLength;
- }
-
- return ret;
-}
-#endif
-
-/*
- * Send as much data in the client->tx as possible
- *
- * Returns:
- * -1 on error or EOF
- * 0 on EAGAIN
- * n number of bytes
- */
-static ssize_t qemudClientWrite(struct qemud_client *client) {
-#if HAVE_SASL
- if (client->saslSSF & QEMUD_SASL_SSF_WRITE)
- return qemudClientWriteSASL(client);
- else
-#endif
- return qemudClientWritePlain(client);
-}
-
-
-/*
- * Process all queued client->tx messages until
- * we would block on I/O
- */
-static void
-qemudDispatchClientWrite(struct qemud_client *client) {
- while (client->tx) {
- ssize_t ret;
-
- ret = qemudClientWrite(client);
- if (ret < 0) {
- qemudDispatchClientFailure(client);
- return;
- }
- if (ret == 0)
- return; /* Would block on write EAGAIN */
-
- if (client->tx->bufferOffset == client->tx->bufferLength) {
- struct qemud_client_message *reply;
-
- /* Get finished reply from head of tx queue */
- reply = qemudClientMessageQueueServe(&client->tx);
-
- /* If its not an async message, then we have
- * just completed an RPC request */
- if (!reply->async)
- client->nrequests--;
-
- /* Move record to end of 'rx' ist */
- if (!client->rx &&
- client->nrequests < max_client_requests) {
- /* Reset message record for next RX attempt */
- client->rx = reply;
- client->rx->bufferOffset = 0;
- client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
- } else {
- VIR_FREE(reply);
- }
-
- if (client->closing)
- qemudDispatchClientFailure(client);
- else
- qemudUpdateClientEvent(client);
- }
- }
-}
-
-static void
-qemudDispatchClientHandshake(struct qemud_client *client) {
- int ret;
- /* Continue the handshake. */
- ret = gnutls_handshake (client->tlssession);
- if (ret == 0) {
- client->handshake = 0;
-
- /* Finished. Next step is to check the certificate. */
- if (remoteCheckAccess (client) == -1)
- qemudDispatchClientFailure(client);
- else
- qemudUpdateClientEvent(client);
- } else if (ret == GNUTLS_E_AGAIN ||
- ret == GNUTLS_E_INTERRUPTED) {
- /* Carry on waiting for more handshake. Update
- the events just in case handshake data flow
- direction has changed */
- qemudUpdateClientEvent (client);
- } else {
- /* Fatal error in handshake */
- VIR_ERROR(_("TLS handshake failed: %s"),
- gnutls_strerror (ret));
- qemudDispatchClientFailure(client);
- }
-}
-
-static void
-qemudDispatchClientEvent(int watch, int fd, int events, void *opaque) {
- struct qemud_server *server = (struct qemud_server *)opaque;
- struct qemud_client *client = NULL;
- int i;
-
- virMutexLock(&server->lock);
-
- for (i = 0 ; i < server->nclients ; i++) {
- virMutexLock(&server->clients[i]->lock);
- if (server->clients[i]->watch == watch) {
- client = server->clients[i];
- break;
- }
- virMutexUnlock(&server->clients[i]->lock);
- }
-
- virMutexUnlock(&server->lock);
-
- if (!client) {
- return;
- }
-
- if (client->fd != fd) {
- virMutexUnlock(&client->lock);
- return;
- }
-
- if (events & (VIR_EVENT_HANDLE_WRITABLE |
- VIR_EVENT_HANDLE_READABLE)) {
- if (client->handshake) {
- qemudDispatchClientHandshake(client);
- } else {
- if (events & VIR_EVENT_HANDLE_WRITABLE)
- qemudDispatchClientWrite(client);
- if (events & VIR_EVENT_HANDLE_READABLE)
- qemudDispatchClientRead(server, client);
- }
- }
-
- /* NB, will get HANGUP + READABLE at same time upon
- * disconnect */
- if (events & (VIR_EVENT_HANDLE_ERROR |
- VIR_EVENT_HANDLE_HANGUP))
- qemudDispatchClientFailure(client);
-
- virMutexUnlock(&client->lock);
-}
-
-
-/*
- * @client: a locked client object
- */
-static int
-qemudCalculateHandleMode(struct qemud_client *client) {
- int mode = 0;
-
- if (client->handshake) {
- if (gnutls_record_get_direction (client->tlssession) == 0)
- mode |= VIR_EVENT_HANDLE_READABLE;
- else
- mode |= VIR_EVENT_HANDLE_WRITABLE;
- } else {
- /* If there is a message on the rx queue then
- * we're wanting more input */
- if (client->rx)
- mode |= VIR_EVENT_HANDLE_READABLE;
-
- /* If there are one or more messages to send back to client,
- then monitor for writability on socket */
- if (client->tx)
- mode |= VIR_EVENT_HANDLE_WRITABLE;
- }
-
- return mode;
-}
-
-/*
- * @server: a locked or unlocked server object
- * @client: a locked client object
- */
-int qemudRegisterClientEvent(struct qemud_server *server,
- struct qemud_client *client) {
- int mode;
-
- mode = qemudCalculateHandleMode(client);
-
- if ((client->watch = virEventAddHandleImpl(client->fd,
- mode,
- qemudDispatchClientEvent,
- server, NULL)) < 0)
- return -1;
-
- return 0;
-}
-
-/*
- * @client: a locked client object
- */
-void qemudUpdateClientEvent(struct qemud_client *client) {
- int mode;
-
- mode = qemudCalculateHandleMode(client);
-
- virEventUpdateHandleImpl(client->watch, mode);
-}
-
-
-static void
-qemudDispatchServerEvent(int watch, int fd, int events, void *opaque) {
- struct qemud_server *server = (struct qemud_server *)opaque;
- struct qemud_socket *sock;
-
- virMutexLock(&server->lock);
-
- sock = server->sockets;
-
- while (sock) {
- if (sock->watch == watch)
- break;
-
- sock = sock->next;
- }
-
- if (sock && sock->fd == fd && events)
- qemudDispatchServer(server, sock);
-
- virMutexUnlock(&server->lock);
-}
-
-
-static int qemudOneLoop(void) {
- sig_atomic_t errors;
-
- if (virEventRunOnce() < 0)
- return -1;
-
- /* Check for any signal handling errors and log them. */
- errors = sig_errors;
- if (errors) {
- char ebuf[1024];
- sig_errors -= errors;
- VIR_ERROR(_("Signal handler reported %d errors: last error: %s"),
- errors, virStrerror (sig_lasterrno, ebuf, sizeof ebuf));
- return -1;
- }
-
- return 0;
-}
-
-static void qemudInactiveTimer(int timerid, void *data) {
- struct qemud_server *server = (struct qemud_server *)data;
-
- if (virStateActive() ||
- server->clients) {
- DEBUG0("Timer expired but still active, not shutting down");
- virEventUpdateTimeoutImpl(timerid, -1);
- } else {
- DEBUG0("Timer expired and inactive, shutting down");
- server->shutdown = 1;
- }
-}
-
-static void qemudFreeClient(struct qemud_client *client) {
- while (client->rx) {
- struct qemud_client_message *msg
- = qemudClientMessageQueueServe(&client->rx);
- VIR_FREE(msg);
- }
- while (client->dx) {
- struct qemud_client_message *msg
- = qemudClientMessageQueueServe(&client->dx);
- VIR_FREE(msg);
- }
- while (client->tx) {
- struct qemud_client_message *msg
- = qemudClientMessageQueueServe(&client->tx);
- VIR_FREE(msg);
- }
-
- if (client->conn)
- virConnectClose(client->conn);
- virMutexDestroy(&client->lock);
- VIR_FREE(client);
-}
-
-static int qemudRunLoop(struct qemud_server *server) {
- int timerid = -1;
- int ret = -1, i;
- int timerActive = 0;
-
- virMutexLock(&server->lock);
-
- if (timeout > 0 &&
- (timerid = virEventAddTimeoutImpl(-1,
- qemudInactiveTimer,
- server, NULL)) < 0) {
- VIR_ERROR0(_("Failed to register shutdown timeout"));
- return -1;
- }
-
- if (min_workers > max_workers)
- max_workers = min_workers;
-
- server->nworkers = max_workers;
- if (VIR_ALLOC_N(server->workers, server->nworkers) < 0) {
- VIR_ERROR0(_("Failed to allocate workers"));
- return -1;
- }
-
- for (i = 0 ; i < min_workers ; i++) {
- if (qemudStartWorker(server, &server->workers[i]) < 0)
- goto cleanup;
- server->nactiveworkers++;
- }
-
- for (;;) {
- /* A shutdown timeout is specified, so check
- * if any drivers have active state, if not
- * shutdown after timeout seconds
- */
- if (timeout > 0) {
- if (timerActive) {
- if (server->clients) {
- DEBUG("Deactivating shutdown timer %d", timerid);
- virEventUpdateTimeoutImpl(timerid, -1);
- timerActive = 0;
- }
- } else {
- if (!virStateActive() &&
- !server->clients) {
- DEBUG("Activating shutdown timer %d", timerid);
- virEventUpdateTimeoutImpl(timerid, timeout * 1000);
- timerActive = 1;
- }
- }
- }
-
- virMutexUnlock(&server->lock);
- if (qemudOneLoop() < 0) {
- virMutexLock(&server->lock);
- DEBUG0("Loop iteration error, exiting\n");
- break;
- }
- virMutexLock(&server->lock);
-
- reprocess:
- for (i = 0 ; i < server->nclients ; i++) {
- int inactive;
- virMutexLock(&server->clients[i]->lock);
- inactive = server->clients[i]->fd == -1
- && server->clients[i]->refs == 0;
- virMutexUnlock(&server->clients[i]->lock);
- if (inactive) {
- qemudFreeClient(server->clients[i]);
- server->nclients--;
- if (i < server->nclients)
- memmove(server->clients + i,
- server->clients + i + 1,
- sizeof (*server->clients) * (server->nclients - i));
-
- if (VIR_REALLOC_N(server->clients,
- server->nclients) < 0) {
- ; /* ignore */
- }
- goto reprocess;
- }
- }
-
- /* If number of active workers exceeds both the min_workers
- * threshold and the number of clients, then kill some
- * off */
- for (i = 0 ; (i < server->nworkers &&
- server->nactiveworkers > server->nclients &&
- server->nactiveworkers > min_workers) ; i++) {
-
- if (server->workers[i].hasThread &&
- !server->workers[i].processingCall) {
- server->workers[i].quitRequest = 1;
-
- virCondBroadcast(&server->job);
- virMutexUnlock(&server->lock);
- pthread_join(server->workers[i].thread, NULL);
- virMutexLock(&server->lock);
- server->workers[i].hasThread = 0;
- server->nactiveworkers--;
- }
- }
-
- if (server->shutdown) {
- ret = 0;
- break;
- }
- }
-
-cleanup:
- for (i = 0 ; i < server->nworkers ; i++) {
- if (!server->workers[i].hasThread)
- continue;
-
- server->workers[i].quitRequest = 1;
- virCondBroadcast(&server->job);
-
- virMutexUnlock(&server->lock);
- pthread_join(server->workers[i].thread, NULL);
- virMutexLock(&server->lock);
- server->workers[i].hasThread = 0;
- }
- VIR_FREE(server->workers);
-
- free(server->workers);
- virMutexUnlock(&server->lock);
- return ret;
-}
-
-static void qemudCleanup(struct qemud_server *server) {
- struct qemud_socket *sock;
-
- close(server->sigread);
-
- sock = server->sockets;
- while (sock) {
- struct qemud_socket *next = sock->next;
- close(sock->fd);
- free(sock);
- sock = next;
- }
- free(server->logDir);
-
-#ifdef HAVE_SASL
- if (server->saslUsernameWhitelist) {
- char **list = server->saslUsernameWhitelist;
- while (*list) {
- free(*list);
- list++;
- }
- free(server->saslUsernameWhitelist);
- }
-#endif
-
- virStateCleanup();
-
- if (virCondDestroy(&server->job) < 0) {
- ;
- }
- virMutexDestroy(&server->lock);
-
- VIR_FREE(server);
-}
-
-/* Allocate an array of malloc'd strings from the config file, filename
- * (used only in diagnostics), using handle "conf". Upon error, return -1
- * and free any allocated memory. Otherwise, save the array in *list_arg
- * and return 0.
- */
-static int
-remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
- const char *filename)
-{
- char **list;
- virConfValuePtr p = virConfGetValue (conf, key);
- if (!p)
- return 0;
-
- switch (p->type) {
- case VIR_CONF_STRING:
- if (VIR_ALLOC_N(list, 2) < 0) {
- VIR_ERROR(_("failed to allocate memory for %s config list"), key);
- return -1;
- }
- list[0] = strdup (p->str);
- list[1] = NULL;
- if (list[0] == NULL) {
- VIR_ERROR(_("failed to allocate memory for %s config list value"),
- key);
- VIR_FREE(list);
- return -1;
- }
- break;
-
- case VIR_CONF_LIST: {
- int i, len = 0;
- virConfValuePtr pp;
- for (pp = p->list; pp; pp = pp->next)
- len++;
- if (VIR_ALLOC_N(list, 1+len) < 0) {
- VIR_ERROR(_("failed to allocate memory for %s config list"), key);
- return -1;
- }
- for (i = 0, pp = p->list; pp; ++i, pp = pp->next) {
- if (pp->type != VIR_CONF_STRING) {
- VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
- " must be a string or list of strings\n"),
- filename, key);
- VIR_FREE(list);
- return -1;
- }
- list[i] = strdup (pp->str);
- if (list[i] == NULL) {
- int j;
- for (j = 0 ; j < i ; j++)
- VIR_FREE(list[j]);
- VIR_FREE(list);
- VIR_ERROR(_("failed to allocate memory for %s config list value"),
- key);
- return -1;
- }
-
- }
- list[i] = NULL;
- break;
- }
-
- default:
- VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
- " must be a string or list of strings\n"),
- filename, key);
- return -1;
- }
-
- *list_arg = list;
- return 0;
-}
-
-/* A helper function used by each of the following macros. */
-static int
-checkType (virConfValuePtr p, const char *filename,
- const char *key, virConfType required_type)
-{
- if (p->type != required_type) {
- VIR_ERROR(_("remoteReadConfigFile: %s: %s: invalid type:"
- " got %s; expected %s\n"), filename, key,
- virConfTypeName (p->type),
- virConfTypeName (required_type));
- return -1;
- }
- return 0;
-}
-
-/* If there is no config data for the key, #var_name, then do nothing.
- If there is valid data of type VIR_CONF_STRING, and strdup succeeds,
- store the result in var_name. Otherwise, (i.e. invalid type, or strdup
- failure), give a diagnostic and "goto" the cleanup-and-fail label. */
-#define GET_CONF_STR(conf, filename, var_name) \
- do { \
- virConfValuePtr p = virConfGetValue (conf, #var_name); \
- if (p) { \
- if (checkType (p, filename, #var_name, VIR_CONF_STRING) < 0) \
- goto free_and_fail; \
- (var_name) = strdup (p->str); \
- if ((var_name) == NULL) { \
- char ebuf[1024]; \
- VIR_ERROR(_("remoteReadConfigFile: %s\n"), \
- virStrerror(errno, ebuf, sizeof ebuf)); \
- goto free_and_fail; \
- } \
- } \
- } while (0)
-
-/* Like GET_CONF_STR, but for integral values. */
-#define GET_CONF_INT(conf, filename, var_name) \
- do { \
- virConfValuePtr p = virConfGetValue (conf, #var_name); \
- if (p) { \
- if (checkType (p, filename, #var_name, VIR_CONF_LONG) < 0) \
- goto free_and_fail; \
- (var_name) = p->l; \
- } \
- } while (0)
-
-
-static int remoteConfigGetAuth(virConfPtr conf, const char *key, int *auth, const char *filename) {
- virConfValuePtr p;
-
- p = virConfGetValue (conf, key);
- if (!p)
- return 0;
-
- if (checkType (p, filename, key, VIR_CONF_STRING) < 0)
- return -1;
-
- if (!p->str)
- return 0;
-
- if (STREQ(p->str, "none")) {
- *auth = REMOTE_AUTH_NONE;
-#if HAVE_SASL
- } else if (STREQ(p->str, "sasl")) {
- *auth = REMOTE_AUTH_SASL;
-#endif
-#if HAVE_POLKIT
- } else if (STREQ(p->str, "polkit")) {
- *auth = REMOTE_AUTH_POLKIT;
-#endif
- } else {
- VIR_ERROR(_("remoteReadConfigFile: %s: %s: unsupported auth %s\n"),
- filename, key, p->str);
- return -1;
- }
-
- return 0;
-}
-
-#ifdef HAVE_SASL
-static inline int
-remoteReadSaslAllowedUsernameList (virConfPtr conf,
- struct qemud_server *server,
- const char *filename)
-{
- return
- remoteConfigGetStringList (conf, "sasl_allowed_username_list",
- &server->saslUsernameWhitelist, filename);
-}
-#else
-static inline int
-remoteReadSaslAllowedUsernameList (virConfPtr conf ATTRIBUTE_UNUSED,
- struct qemud_server *server ATTRIBUTE_UNUSED,
- const char *filename ATTRIBUTE_UNUSED)
-{
- return 0;
-}
-#endif
-
-/*
- * Set up the logging environment
- * By default if daemonized all errors go to syslog and the logging
- * is also saved onto the logfile libvird.log, but if verbose or error
- * debugging is asked for then output informations or debug.
- */
-static int
-qemudSetLogging(virConfPtr conf, const char *filename) {
- int log_level;
- char *log_filters = NULL;
- char *log_outputs = NULL;
- int ret = -1;
-
- virLogReset();
-
- /*
- * Libvirtd's order of precedence is:
- * cmdline > environment > config
- *
- * In order to achieve this, we must process configuration in
- * different order for the log level versus the filters and
- * outputs. Because filters and outputs append, we have to look at
- * the environment first and then only check the config file if
- * there was no result from the environment. The default output is
- * then applied only if there was no setting from either of the
- * first two. Because we don't have a way to determine if the log
- * level has been set, we must process variables in the opposite
- * order, each one overriding the previous.
- */
- /*
- * GET_CONF_INT returns 0 when there is no log_level setting in
- * the config file. The conditional below eliminates a false
- * warning in that case, but also has the side effect of missing
- * a warning if the user actually does say log_level=0.
- */
- GET_CONF_INT (conf, filename, log_level);
- if (log_level != 0)
- virLogSetDefaultPriority(log_level);
-
- virLogSetFromEnv();
-
- if (virLogGetNbFilters() == 0) {
- GET_CONF_STR (conf, filename, log_filters);
- virLogParseFilters(log_filters);
- }
-
- if (virLogGetNbOutputs() == 0) {
- GET_CONF_STR (conf, filename, log_outputs);
- virLogParseOutputs(log_outputs);
- }
-
- /*
- * If no defined outputs, then direct to syslog when running
- * as daemon. Otherwise the default output is stderr.
- */
- if (virLogGetNbOutputs() == 0) {
- char *tmp = NULL;
- if (godaemon) {
- if (virAsprintf (&tmp, "%d:syslog:libvirtd",
- virLogGetDefaultPriority()) < 0)
- goto free_and_fail;
- } else {
- if (virAsprintf (&tmp, "%d:stderr",
- virLogGetDefaultPriority()) < 0)
- goto free_and_fail;
- }
- virLogParseOutputs(tmp);
- VIR_FREE(tmp);
- }
-
- /*
- * Command line override for --verbose
- */
- if ((verbose) && (virLogGetDefaultPriority() > VIR_LOG_INFO))
- virLogSetDefaultPriority(VIR_LOG_INFO);
-
- ret = 0;
-
-free_and_fail:
- VIR_FREE(log_filters);
- VIR_FREE(log_outputs);
- return(ret);
-}
-
-/* Read the config file if it exists.
- * Only used in the remote case, hence the name.
- */
-static int
-remoteReadConfigFile (struct qemud_server *server, const char *filename)
-{
- virConfPtr conf;
-
- /* The following variable names must match the corresponding
- configuration strings. */
- char *unix_sock_ro_perms = NULL;
- char *unix_sock_rw_perms = NULL;
- char *unix_sock_group = NULL;
- char *buf = NULL;
-
-#if HAVE_POLKIT
- /* Change the default back to no auth for non-root */
- if (!server->privileged && auth_unix_rw == REMOTE_AUTH_POLKIT)
- auth_unix_rw = REMOTE_AUTH_NONE;
- if (!server->privileged && auth_unix_ro == REMOTE_AUTH_POLKIT)
- auth_unix_ro = REMOTE_AUTH_NONE;
-#endif
-
- conf = virConfReadFile (filename, 0);
- if (!conf) return -1;
-
- /*
- * First get all the logging settings and activate them
- */
- if (qemudSetLogging(conf, filename) < 0)
- goto free_and_fail;
-
- GET_CONF_INT (conf, filename, listen_tcp);
- GET_CONF_INT (conf, filename, listen_tls);
- GET_CONF_STR (conf, filename, tls_port);
- GET_CONF_STR (conf, filename, tcp_port);
- GET_CONF_STR (conf, filename, listen_addr);
-
- if (remoteConfigGetAuth(conf, "auth_unix_rw", &auth_unix_rw, filename) < 0)
- goto free_and_fail;
-#if HAVE_POLKIT
- /* Change default perms to be wide-open if PolicyKit is enabled.
- * Admin can always override in config file
- */
- if (auth_unix_rw == REMOTE_AUTH_POLKIT)
- unix_sock_rw_mask = 0777;
-#endif
- if (remoteConfigGetAuth(conf, "auth_unix_ro", &auth_unix_ro, filename) < 0)
- goto free_and_fail;
- if (remoteConfigGetAuth(conf, "auth_tcp", &auth_tcp, filename) < 0)
- goto free_and_fail;
- if (remoteConfigGetAuth(conf, "auth_tls", &auth_tls, filename) < 0)
- goto free_and_fail;
-
- GET_CONF_STR (conf, filename, unix_sock_group);
- if (unix_sock_group) {
- if (!server->privileged) {
- VIR_WARN0(_("Cannot set group when not running as root"));
- } else {
- int ret;
- struct group grpdata, *grp;
- size_t maxbuf = sysconf(_SC_GETGR_R_SIZE_MAX);
-
- if (maxbuf == -1)
- maxbuf = 1024;
-
- if (VIR_ALLOC_N(buf, maxbuf) < 0) {
- VIR_ERROR("%s", _("Failed to allocate memory for buffer"));
- goto free_and_fail;
- }
-
- while ((ret = getgrnam_r(unix_sock_group, &grpdata,
- buf, maxbuf,
- &grp)) == ERANGE) {
- maxbuf *= 2;
- if (maxbuf > 65536 || VIR_REALLOC_N(buf, maxbuf) < 0) {
- VIR_ERROR("%s", _("Failed to reallocate enough memory for buffer"));
- goto free_and_fail;
- }
- }
-
- if (ret != 0 || !grp) {
- VIR_ERROR(_("Failed to lookup group '%s'"), unix_sock_group);
- goto free_and_fail;
- }
- unix_sock_gid = grp->gr_gid;
- VIR_FREE (buf);
- }
- free (unix_sock_group);
- unix_sock_group = NULL;
- }
-
- GET_CONF_STR (conf, filename, unix_sock_ro_perms);
- if (unix_sock_ro_perms) {
- if (virStrToLong_i (unix_sock_ro_perms, NULL, 8, &unix_sock_ro_mask) != 0) {
- VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_ro_perms);
- goto free_and_fail;
- }
- free (unix_sock_ro_perms);
- unix_sock_ro_perms = NULL;
- }
-
- GET_CONF_STR (conf, filename, unix_sock_rw_perms);
- if (unix_sock_rw_perms) {
- if (virStrToLong_i (unix_sock_rw_perms, NULL, 8, &unix_sock_rw_mask) != 0) {
- VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_rw_perms);
- goto free_and_fail;
- }
- free (unix_sock_rw_perms);
- unix_sock_rw_perms = NULL;
- }
-
- GET_CONF_STR (conf, filename, unix_sock_dir);
-
- GET_CONF_INT (conf, filename, mdns_adv);
- GET_CONF_STR (conf, filename, mdns_name);
-
- GET_CONF_INT (conf, filename, tls_no_verify_certificate);
-
- GET_CONF_STR (conf, filename, key_file);
- GET_CONF_STR (conf, filename, cert_file);
- GET_CONF_STR (conf, filename, ca_file);
- GET_CONF_STR (conf, filename, crl_file);
-
- if (remoteConfigGetStringList (conf, "tls_allowed_dn_list",
- &tls_allowed_dn_list, filename) < 0)
- goto free_and_fail;
-
- if (remoteReadSaslAllowedUsernameList (conf, server, filename) < 0)
- goto free_and_fail;
-
-
- GET_CONF_INT (conf, filename, min_workers);
- GET_CONF_INT (conf, filename, max_workers);
- GET_CONF_INT (conf, filename, max_clients);
-
- GET_CONF_INT (conf, filename, max_requests);
- GET_CONF_INT (conf, filename, max_client_requests);
-
- virConfFree (conf);
- return 0;
-
- free_and_fail:
- virConfFree (conf);
- free (mdns_name);
- mdns_name = NULL;
- free (unix_sock_ro_perms);
- free (unix_sock_rw_perms);
- free (unix_sock_group);
- VIR_FREE (buf);
-
- /* Don't bother trying to free listen_addr, tcp_port, tls_port, key_file,
- cert_file, ca_file, or crl_file, since they are initialized to
- non-malloc'd strings. Besides, these are static variables, and callers
- are unlikely to call this function more than once, so there wouldn't
- even be a real leak. */
-
- if (tls_allowed_dn_list) {
- int i;
- for (i = 0; tls_allowed_dn_list[i]; i++)
- free (tls_allowed_dn_list[i]);
- free (tls_allowed_dn_list);
- tls_allowed_dn_list = NULL;
- }
-
- return -1;
-}
-
-/* Display version information. */
-static void
-version (const char *argv0)
-{
- printf ("%s (%s) %s\n", argv0, PACKAGE_NAME, PACKAGE_VERSION);
-}
-
-#ifdef __sun
-static int
-qemudSetupPrivs (void)
-{
- chown ("/var/run/libvirt", SYSTEM_UID, SYSTEM_UID);
-
- if (__init_daemon_priv (PU_RESETGROUPS | PU_CLEARLIMITSET,
- SYSTEM_UID, SYSTEM_UID, PRIV_XVM_CONTROL, NULL)) {
- VIR_ERROR0(_("additional privileges are required\n"));
- return -1;
- }
-
- if (priv_set (PRIV_OFF, PRIV_ALLSETS, PRIV_FILE_LINK_ANY, PRIV_PROC_INFO,
- PRIV_PROC_SESSION, PRIV_PROC_EXEC, PRIV_PROC_FORK, NULL)) {
- VIR_ERROR0(_("failed to set reduced privileges\n"));
- return -1;
- }
-
- return 0;
-}
-#else
-#define qemudSetupPrivs() 0
-#endif
-
-/* Print command-line usage. */
-static void
-usage (const char *argv0)
-{
- fprintf (stderr,
- "\n\
-Usage:\n\
- %s [options]\n\
-\n\
-Options:\n\
- -v | --verbose Verbose messages.\n\
- -d | --daemon Run as a daemon & write PID file.\n\
- -l | --listen Listen for TCP/IP connections.\n\
- -t | --timeout <secs> Exit after timeout period.\n\
- -f | --config <file> Configuration file.\n\
- | --version Display version information.\n\
- -p | --pid-file <file> Change name of PID file.\n\
-\n\
-libvirt management daemon:\n\
-\n\
- Default paths:\n\
-\n\
- Configuration file (unless overridden by -c):\n\
- " SYSCONF_DIR "/libvirt/libvirtd.conf\n\
-\n\
- Sockets (as root):\n\
- " LOCAL_STATE_DIR "/run/libvirt/libvirt-sock\n\
- " LOCAL_STATE_DIR "/run/libvirt/libvirt-sock-ro\n\
-\n\
- Sockets (as non-root):\n\
- $HOME/.libvirt/libvirt-sock (in UNIX abstract namespace)\n\
-\n\
- TLS:\n\
- CA certificate: " LIBVIRT_CACERT "\n\
- Server certificate: " LIBVIRT_SERVERCERT "\n\
- Server private key: " LIBVIRT_SERVERKEY "\n\
-\n\
- PID file (unless overridden by --pid-file):\n\
- %s\n\
-\n",
- argv0,
- REMOTE_PID_FILE[0] != '\0'
- ? REMOTE_PID_FILE
- : "(disabled in ./configure)");
-}
-
-enum {
- OPT_VERSION = 129
-};
-
-#define MAX_LISTEN 5
-int main(int argc, char **argv) {
- struct qemud_server *server = NULL;
- struct sigaction sig_action;
- int sigpipe[2];
- const char *pid_file = NULL;
- const char *remote_config_file = NULL;
- int ret = 1;
-
- struct option opts[] = {
- { "verbose", no_argument, &verbose, 1},
- { "daemon", no_argument, &godaemon, 1},
- { "listen", no_argument, &ipsock, 1},
- { "config", required_argument, NULL, 'f'},
- { "timeout", required_argument, NULL, 't'},
- { "pid-file", required_argument, NULL, 'p'},
- { "version", no_argument, NULL, OPT_VERSION },
- { "help", no_argument, NULL, '?' },
- {0, 0, 0, 0}
- };
-
- while (1) {
- int optidx = 0;
- int c;
- char *tmp;
-
- c = getopt_long(argc, argv, "ldf:p:t:v", opts, &optidx);
-
- if (c == -1) {
- break;
- }
-
- switch (c) {
- case 0:
- /* Got one of the flags */
- break;
- case 'v':
- verbose = 1;
- break;
- case 'd':
- godaemon = 1;
- break;
- case 'l':
- ipsock = 1;
- break;
-
- case 't':
- if (virStrToLong_i(optarg, &tmp, 10, &timeout) != 0
- || timeout <= 0
- /* Ensure that we can multiply by 1000 without overflowing. */
- || timeout > INT_MAX / 1000)
- timeout = -1;
- break;
-
- case 'p':
- pid_file = optarg;
- break;
-
- case 'f':
- remote_config_file = optarg;
- break;
-
- case OPT_VERSION:
- version (argv[0]);
- return 0;
-
- case '?':
- usage (argv[0]);
- return 2;
-
- default:
- fprintf (stderr, "libvirtd: internal error: unknown flag: %c\n",
- c);
- exit (1);
- }
- }
-
- if (remote_config_file == NULL) {
- static const char *default_config_file
- = SYSCONF_DIR "/libvirt/libvirtd.conf";
- remote_config_file =
- (access(default_config_file, R_OK) == 0
- ? default_config_file
- : "/dev/null");
- }
-
- if (godaemon) {
- char ebuf[1024];
- if (qemudGoDaemon() < 0) {
- VIR_ERROR(_("Failed to fork as daemon: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- goto error1;
- }
- }
-
- /* If running as root and no PID file is set, use the default */
- if (pid_file == NULL &&
- geteuid() == 0 &&
- REMOTE_PID_FILE[0] != '\0')
- pid_file = REMOTE_PID_FILE;
-
- /* If we have a pidfile set, claim it now, exiting if already taken */
- if (pid_file != NULL &&
- qemudWritePidFile (pid_file) < 0)
- goto error1;
-
- if (pipe(sigpipe) < 0 ||
- virSetNonBlock(sigpipe[0]) < 0 ||
- virSetNonBlock(sigpipe[1]) < 0 ||
- virSetCloseExec(sigpipe[0]) < 0 ||
- virSetCloseExec(sigpipe[1]) < 0) {
- char ebuf[1024];
- VIR_ERROR(_("Failed to create pipe: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- goto error2;
- }
- sigwrite = sigpipe[1];
-
- sig_action.sa_sigaction = sig_handler;
- sig_action.sa_flags = SA_SIGINFO;
- sigemptyset(&sig_action.sa_mask);
-
- sigaction(SIGHUP, &sig_action, NULL);
- sigaction(SIGINT, &sig_action, NULL);
- sigaction(SIGQUIT, &sig_action, NULL);
- sigaction(SIGTERM, &sig_action, NULL);
- sigaction(SIGCHLD, &sig_action, NULL);
-
- sig_action.sa_handler = SIG_IGN;
- sigaction(SIGPIPE, &sig_action, NULL);
-
- /* Ensure the rundir exists (on tmpfs on some systems) */
- if (geteuid() == 0) {
- const char *rundir = LOCAL_STATE_DIR "/run/libvirt";
-
- if (mkdir (rundir, 0755)) {
- if (errno != EEXIST) {
- VIR_ERROR0 (_("unable to create rundir"));
- return -1;
- }
- }
- }
-
- /* Beyond this point, nothing should rely on using
- * getuid/geteuid() == 0, for privilege level checks.
- * It must all use the flag 'server->privileged'
- * which is also passed into all libvirt stateful
- * drivers
- */
- if (qemudSetupPrivs() < 0)
- goto error2;
-
- if (!(server = qemudInitialize(sigpipe[0]))) {
- ret = 2;
- goto error2;
- }
-
- /* Read the config file (if it exists). */
- if (remoteReadConfigFile (server, remote_config_file) < 0)
- goto error2;
-
- /* Change the group ownership of /var/run/libvirt to unix_sock_gid */
- if (unix_sock_dir && server->privileged) {
- if (chown(unix_sock_dir, -1, unix_sock_gid) < 0)
- VIR_ERROR(_("Failed to change group ownership of %s"),
- unix_sock_dir);
- }
-
- if (virEventAddHandleImpl(sigpipe[0],
- VIR_EVENT_HANDLE_READABLE,
- qemudDispatchSignalEvent,
- server, NULL) < 0) {
- VIR_ERROR0(_("Failed to register callback for signal pipe"));
- ret = 3;
- goto error2;
- }
-
- if (!(server = qemudNetworkInit(server))) {
- ret = 2;
- goto error2;
- }
-
- qemudRunLoop(server);
-
- ret = 0;
-
-error2:
- if (server)
- qemudCleanup(server);
- if (pid_file)
- unlink (pid_file);
- close(sigwrite);
-
-error1:
- virLogShutdown();
- return ret;
-}
+++ /dev/null
-/*
- * 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
+++ /dev/null
-/*
- * remote.c: 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>
- */
-
-#include <config.h>
-
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/poll.h>
-#include <netinet/in.h>
-#include <netdb.h>
-#include <stdlib.h>
-#include <pwd.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <syslog.h>
-#include <string.h>
-#include <errno.h>
-#include <fnmatch.h>
-#include "virterror_internal.h"
-
-#if HAVE_POLKIT0
-#include <polkit/polkit.h>
-#include <polkit-dbus/polkit-dbus.h>
-#endif
-
-#include "remote.h"
-#include "dispatch.h"
-
-#include "libvirt_internal.h"
-#include "datatypes.h"
-#include "memory.h"
-#include "util.h"
-
-#define VIR_FROM_THIS VIR_FROM_REMOTE
-#define REMOTE_DEBUG(fmt, ...) DEBUG(fmt, __VA_ARGS__)
-
-static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
-static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
-static virInterfacePtr get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface iface);
-static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
-static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
-static virSecretPtr get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret);
-static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
-static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
-static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
-static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src);
-static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
-static void make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src);
-static void make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
-
-
-#include "remote_dispatch_prototypes.h"
-
-static const dispatch_data const dispatch_table[] = {
-#include "remote_dispatch_table.h"
-};
-
-const dispatch_data const *remoteGetDispatchData(int proc)
-{
- if (proc >= ARRAY_CARDINALITY(dispatch_table) ||
- dispatch_table[proc].fn == NULL) {
- return NULL;
- }
-
- return &(dispatch_table[proc]);
-}
-
-/* Prototypes */
-static void
-remoteDispatchDomainEventSend (struct qemud_client *client,
- remote_domain_event_msg *data);
-
-int remoteRelayDomainEvent (virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int event,
- int detail,
- void *opaque)
-{
- struct qemud_client *client = opaque;
- REMOTE_DEBUG("Relaying domain event %d %d", event, detail);
-
- if (client) {
- remote_domain_event_msg data;
-
- virMutexLock(&client->lock);
-
- /* build return data */
- memset(&data, 0, sizeof data);
- make_nonnull_domain (&data.dom, dom);
- data.event = event;
- data.detail = detail;
-
- remoteDispatchDomainEventSend (client, &data);
-
- virMutexUnlock(&client->lock);
- }
- return 0;
-}
-
-
-/*----- Functions. -----*/
-
-static int
-remoteDispatchOpen (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *rerr,
- struct remote_open_args *args, void *ret ATTRIBUTE_UNUSED)
-{
- const char *name;
- int flags, rc;
-
- /* Already opened? */
- if (conn) {
- remoteDispatchFormatError (rerr, "%s", _("connection already open"));
- return -1;
- }
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- name = args->name ? *args->name : NULL;
-
- /* If this connection arrived on a readonly socket, force
- * the connection to be readonly.
- */
- flags = args->flags;
- if (client->readonly) flags |= VIR_CONNECT_RO;
-
- client->conn =
- flags & VIR_CONNECT_RO
- ? virConnectOpenReadOnly (name)
- : virConnectOpen (name);
-
- if (client->conn == NULL)
- remoteDispatchConnError(rerr, NULL);
-
- rc = client->conn ? 0 : -1;
- virMutexUnlock(&client->lock);
- return rc;
-}
-
-#define CHECK_CONN(client) \
- if (!client->conn) { \
- remoteDispatchFormatError (rerr, "%s", _("connection not open")); \
- return -1; \
- }
-
-static int
-remoteDispatchClose (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr ATTRIBUTE_UNUSED,
- void *args ATTRIBUTE_UNUSED, void *ret ATTRIBUTE_UNUSED)
-{
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- client->closing = 1;
-
- virMutexUnlock(&client->lock);
- return 0;
-}
-
-static int
-remoteDispatchSupportsFeature (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_supports_feature_args *args, remote_supports_feature_ret *ret)
-{
- ret->supported = virDrvSupportsFeature (conn, args->feature);
-
- if (ret->supported == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchGetType (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED, remote_get_type_ret *ret)
-{
- const char *type;
-
- type = virConnectGetType (conn);
- if (type == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* We have to strdup because remoteDispatchClientRequest will
- * free this string after it's been serialised.
- */
- ret->type = strdup (type);
- if (!ret->type) {
- remoteDispatchFormatError (rerr, "%s", _("out of memory in strdup"));
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchGetVersion (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_get_version_ret *ret)
-{
- unsigned long hvVer;
-
- if (virConnectGetVersion (conn, &hvVer) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->hv_ver = hvVer;
- return 0;
-}
-
-static int
-remoteDispatchGetHostname (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_get_hostname_ret *ret)
-{
- char *hostname;
-
- hostname = virConnectGetHostname (conn);
- if (hostname == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->hostname = hostname;
- return 0;
-}
-
-static int
-remoteDispatchGetUri (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_get_uri_ret *ret)
-{
- char *uri;
- CHECK_CONN(client);
-
- uri = virConnectGetURI (conn);
- if (uri == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->uri = uri;
- return 0;
-}
-
-static int
-remoteDispatchGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_get_max_vcpus_args *args,
- remote_get_max_vcpus_ret *ret)
-{
- char *type;
-
- type = args->type ? *args->type : NULL;
- ret->max_vcpus = virConnectGetMaxVcpus (conn, type);
- if (ret->max_vcpus == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNodeGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_node_get_info_ret *ret)
-{
- virNodeInfo info;
-
- if (virNodeGetInfo (conn, &info) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- memcpy (ret->model, info.model, sizeof ret->model);
- ret->memory = info.memory;
- ret->cpus = info.cpus;
- ret->mhz = info.mhz;
- ret->nodes = info.nodes;
- ret->sockets = info.sockets;
- ret->cores = info.cores;
- ret->threads = info.threads;
-
- return 0;
-}
-
-static int
-remoteDispatchGetCapabilities (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_get_capabilities_ret *ret)
-{
- char *caps;
-
- caps = virConnectGetCapabilities (conn);
- if (caps == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->capabilities = caps;
- return 0;
-}
-
-static int
-remoteDispatchNodeGetCellsFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_get_cells_free_memory_args *args,
- remote_node_get_cells_free_memory_ret *ret)
-{
- int err;
-
- if (args->maxCells > REMOTE_NODE_MAX_CELLS) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxCells > REMOTE_NODE_MAX_CELLS"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->freeMems.freeMems_val, args->maxCells) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- err = virNodeGetCellsFreeMemory(conn,
- (unsigned long long *)ret->freeMems.freeMems_val,
- args->startCell,
- args->maxCells);
- if (err <= 0) {
- VIR_FREE(ret->freeMems.freeMems_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- ret->freeMems.freeMems_len = err;
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeGetFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_node_get_free_memory_ret *ret)
-{
- unsigned long long freeMem;
-
- freeMem = virNodeGetFreeMemory(conn);
- if (freeMem == 0) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- ret->freeMem = freeMem;
- return 0;
-}
-
-
-static int
-remoteDispatchDomainGetSchedulerType (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_scheduler_type_args *args,
- remote_domain_get_scheduler_type_ret *ret)
-{
- virDomainPtr dom;
- char *type;
- int nparams;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- type = virDomainGetSchedulerType (dom, &nparams);
- if (type == NULL) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->type = type;
- ret->nparams = nparams;
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_scheduler_parameters_args *args,
- remote_domain_get_scheduler_parameters_ret *ret)
-{
- virDomainPtr dom;
- virSchedParameterPtr params;
- int i, r, nparams;
-
- nparams = args->nparams;
-
- if (nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
- remoteDispatchFormatError (rerr, "%s", _("nparams too large"));
- return -1;
- }
- if (VIR_ALLOC_N(params, nparams) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- VIR_FREE(params);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- r = virDomainGetSchedulerParameters (dom, params, &nparams);
- if (r == -1) {
- virDomainFree(dom);
- VIR_FREE(params);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* Serialise the scheduler parameters. */
- ret->params.params_len = nparams;
- if (VIR_ALLOC_N(ret->params.params_val, nparams) < 0)
- goto oom;
-
- for (i = 0; i < nparams; ++i) {
- // remoteDispatchClientRequest will free this:
- ret->params.params_val[i].field = strdup (params[i].field);
- if (ret->params.params_val[i].field == NULL)
- goto oom;
-
- ret->params.params_val[i].value.type = params[i].type;
- switch (params[i].type) {
- case VIR_DOMAIN_SCHED_FIELD_INT:
- ret->params.params_val[i].value.remote_sched_param_value_u.i = params[i].value.i; break;
- case VIR_DOMAIN_SCHED_FIELD_UINT:
- ret->params.params_val[i].value.remote_sched_param_value_u.ui = params[i].value.ui; break;
- case VIR_DOMAIN_SCHED_FIELD_LLONG:
- ret->params.params_val[i].value.remote_sched_param_value_u.l = params[i].value.l; break;
- case VIR_DOMAIN_SCHED_FIELD_ULLONG:
- ret->params.params_val[i].value.remote_sched_param_value_u.ul = params[i].value.ul; break;
- case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
- ret->params.params_val[i].value.remote_sched_param_value_u.d = params[i].value.d; break;
- case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
- ret->params.params_val[i].value.remote_sched_param_value_u.b = params[i].value.b; break;
- default:
- remoteDispatchFormatError (rerr, "%s", _("unknown type"));
- goto cleanup;
- }
- }
- virDomainFree(dom);
- VIR_FREE(params);
-
- return 0;
-
-oom:
- remoteDispatchOOMError(rerr);
-cleanup:
- virDomainFree(dom);
- for (i = 0 ; i < nparams ; i++)
- VIR_FREE(ret->params.params_val[i].field);
- VIR_FREE(params);
- return -1;
-}
-
-static int
-remoteDispatchDomainSetSchedulerParameters (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_set_scheduler_parameters_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
- int i, r, nparams;
- virSchedParameterPtr params;
-
- nparams = args->params.params_len;
-
- if (nparams > REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX) {
- remoteDispatchFormatError (rerr, "%s", _("nparams too large"));
- return -1;
- }
- if (VIR_ALLOC_N(params, nparams)) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- /* Deserialise parameters. */
- for (i = 0; i < nparams; ++i) {
- strncpy (params[i].field, args->params.params_val[i].field,
- VIR_DOMAIN_SCHED_FIELD_LENGTH);
- params[i].field[VIR_DOMAIN_SCHED_FIELD_LENGTH-1] = '\0';
- params[i].type = args->params.params_val[i].value.type;
- switch (params[i].type) {
- case VIR_DOMAIN_SCHED_FIELD_INT:
- params[i].value.i = args->params.params_val[i].value.remote_sched_param_value_u.i; break;
- case VIR_DOMAIN_SCHED_FIELD_UINT:
- params[i].value.ui = args->params.params_val[i].value.remote_sched_param_value_u.ui; break;
- case VIR_DOMAIN_SCHED_FIELD_LLONG:
- params[i].value.l = args->params.params_val[i].value.remote_sched_param_value_u.l; break;
- case VIR_DOMAIN_SCHED_FIELD_ULLONG:
- params[i].value.ul = args->params.params_val[i].value.remote_sched_param_value_u.ul; break;
- case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
- params[i].value.d = args->params.params_val[i].value.remote_sched_param_value_u.d; break;
- case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
- params[i].value.b = args->params.params_val[i].value.remote_sched_param_value_u.b; break;
- }
- }
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- VIR_FREE(params);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- r = virDomainSetSchedulerParameters (dom, params, nparams);
- virDomainFree(dom);
- VIR_FREE(params);
- if (r == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainBlockStats (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_block_stats_args *args,
- remote_domain_block_stats_ret *ret)
-{
- virDomainPtr dom;
- char *path;
- struct _virDomainBlockStats stats;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- path = args->path;
-
- if (virDomainBlockStats (dom, path, &stats, sizeof stats) == -1) {
- virDomainFree (dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree (dom);
-
- ret->rd_req = stats.rd_req;
- ret->rd_bytes = stats.rd_bytes;
- ret->wr_req = stats.wr_req;
- ret->wr_bytes = stats.wr_bytes;
- ret->errs = stats.errs;
-
- return 0;
-}
-
-static int
-remoteDispatchDomainInterfaceStats (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_interface_stats_args *args,
- remote_domain_interface_stats_ret *ret)
-{
- virDomainPtr dom;
- char *path;
- struct _virDomainInterfaceStats stats;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- path = args->path;
-
- if (virDomainInterfaceStats (dom, path, &stats, sizeof stats) == -1) {
- virDomainFree (dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree (dom);
-
- ret->rx_bytes = stats.rx_bytes;
- ret->rx_packets = stats.rx_packets;
- ret->rx_errs = stats.rx_errs;
- ret->rx_drop = stats.rx_drop;
- ret->tx_bytes = stats.tx_bytes;
- ret->tx_packets = stats.tx_packets;
- ret->tx_errs = stats.tx_errs;
- ret->tx_drop = stats.tx_drop;
-
- return 0;
-}
-
-static int
-remoteDispatchDomainBlockPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_block_peek_args *args,
- remote_domain_block_peek_ret *ret)
-{
- virDomainPtr dom;
- char *path;
- unsigned long long offset;
- size_t size;
- unsigned int flags;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- path = args->path;
- offset = args->offset;
- size = args->size;
- flags = args->flags;
-
- if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
- virDomainFree (dom);
- remoteDispatchFormatError (rerr,
- "%s", _("size > maximum buffer size"));
- return -1;
- }
-
- ret->buffer.buffer_len = size;
- if (VIR_ALLOC_N (ret->buffer.buffer_val, size) < 0) {
- char ebuf[1024];
- virDomainFree (dom);
- remoteDispatchFormatError (rerr, "%s",
- virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- if (virDomainBlockPeek (dom, path, offset, size,
- ret->buffer.buffer_val, flags) == -1) {
- /* free (ret->buffer.buffer_val); - caller frees */
- virDomainFree (dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree (dom);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainMemoryPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_memory_peek_args *args,
- remote_domain_memory_peek_ret *ret)
-{
- virDomainPtr dom;
- unsigned long long offset;
- size_t size;
- unsigned int flags;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- offset = args->offset;
- size = args->size;
- flags = args->flags;
-
- if (size > REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX) {
- virDomainFree (dom);
- remoteDispatchFormatError (rerr,
- "%s", _("size > maximum buffer size"));
- return -1;
- }
-
- ret->buffer.buffer_len = size;
- if (VIR_ALLOC_N (ret->buffer.buffer_val, size) < 0) {
- char ebuf[1024];
- virDomainFree (dom);
- remoteDispatchFormatError (rerr, "%s",
- virStrerror(errno, ebuf, sizeof ebuf));
- return -1;
- }
-
- if (virDomainMemoryPeek (dom, offset, size,
- ret->buffer.buffer_val, flags) == -1) {
- /* free (ret->buffer.buffer_val); - caller frees */
- virDomainFree (dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree (dom);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainAttachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_attach_device_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainAttachDevice (dom, args->xml) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_create_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainCreate (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_create_xml_args *args,
- remote_domain_create_xml_ret *ret)
-{
- virDomainPtr dom;
-
- dom = virDomainCreateXML (conn, args->xml_desc, args->flags);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->dom, dom);
- virDomainFree(dom);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_define_xml_args *args,
- remote_domain_define_xml_ret *ret)
-{
- virDomainPtr dom;
-
- dom = virDomainDefineXML (conn, args->xml);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->dom, dom);
- virDomainFree(dom);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainDestroy (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainDetachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_detach_device_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainDetachDevice (dom, args->xml) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_dump_xml_args *args,
- remote_domain_dump_xml_ret *ret)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virDomainGetXMLDesc (dom, args->flags);
- if (!ret->xml) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainXmlFromNative (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_xml_from_native_args *args,
- remote_domain_xml_from_native_ret *ret)
-{
- /* remoteDispatchClientRequest will free this. */
- ret->domainXml = virConnectDomainXMLFromNative (conn,
- args->nativeFormat,
- args->nativeConfig,
- args->flags);
- if (!ret->domainXml) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- return 0;
-}
-
-static int
-remoteDispatchDomainXmlToNative (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_xml_to_native_args *args,
- remote_domain_xml_to_native_ret *ret)
-{
- /* remoteDispatchClientRequest will free this. */
- ret->nativeConfig = virConnectDomainXMLToNative (conn,
- args->nativeFormat,
- args->domainXml,
- args->flags);
- if (!ret->nativeConfig) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- return 0;
-}
-
-
-static int
-remoteDispatchDomainGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_autostart_args *args,
- remote_domain_get_autostart_ret *ret)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainGetAutostart (dom, &ret->autostart) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_info_args *args,
- remote_domain_get_info_ret *ret)
-{
- virDomainPtr dom;
- virDomainInfo info;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainGetInfo (dom, &info) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->state = info.state;
- ret->max_mem = info.maxMem;
- ret->memory = info.memory;
- ret->nr_virt_cpu = info.nrVirtCpu;
- ret->cpu_time = info.cpuTime;
-
- virDomainFree(dom);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainGetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_max_memory_args *args,
- remote_domain_get_max_memory_ret *ret)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->memory = virDomainGetMaxMemory (dom);
- if (ret->memory == 0) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_max_vcpus_args *args,
- remote_domain_get_max_vcpus_ret *ret)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->num = virDomainGetMaxVcpus (dom);
- if (ret->num == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainGetSecurityLabel(struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_security_label_args *args,
- remote_domain_get_security_label_ret *ret)
-{
- virDomainPtr dom;
- virSecurityLabel seclabel;
-
- dom = get_nonnull_domain(conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- memset(&seclabel, 0, sizeof seclabel);
- if (virDomainGetSecurityLabel(dom, &seclabel) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->label.label_len = strlen(seclabel.label) + 1;
- if (VIR_ALLOC_N(ret->label.label_val, ret->label.label_len) < 0) {
- virDomainFree(dom);
- remoteDispatchOOMError(rerr);
- return -1;
- }
- strcpy(ret->label.label_val, seclabel.label);
- ret->enforcing = seclabel.enforcing;
- virDomainFree(dom);
-
- return 0;
-}
-
-static int
-remoteDispatchNodeGetSecurityModel(struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_node_get_security_model_ret *ret)
-{
- virSecurityModel secmodel;
-
- memset(&secmodel, 0, sizeof secmodel);
- if (virNodeGetSecurityModel(conn, &secmodel) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->model.model_len = strlen(secmodel.model) + 1;
- if (VIR_ALLOC_N(ret->model.model_val, ret->model.model_len) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
- strcpy(ret->model.model_val, secmodel.model);
-
- ret->doi.doi_len = strlen(secmodel.doi) + 1;
- if (VIR_ALLOC_N(ret->doi.doi_val, ret->doi.doi_len) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
- strcpy(ret->doi.doi_val, secmodel.doi);
-
- return 0;
-}
-
-static int
-remoteDispatchDomainGetOsType (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_os_type_args *args,
- remote_domain_get_os_type_ret *ret)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this */
- ret->type = virDomainGetOSType (dom);
- if (ret->type == NULL) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_get_vcpus_args *args,
- remote_domain_get_vcpus_ret *ret)
-{
- virDomainPtr dom = NULL;
- virVcpuInfoPtr info = NULL;
- unsigned char *cpumaps = NULL;
- int info_len, i;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (args->maxinfo > REMOTE_VCPUINFO_MAX) {
- virDomainFree(dom);
- remoteDispatchFormatError (rerr, "%s", _("maxinfo > REMOTE_VCPUINFO_MAX"));
- return -1;
- }
-
- if (args->maxinfo * args->maplen > REMOTE_CPUMAPS_MAX) {
- virDomainFree(dom);
- remoteDispatchFormatError (rerr, "%s", _("maxinfo * maplen > REMOTE_CPUMAPS_MAX"));
- return -1;
- }
-
- /* Allocate buffers to take the results. */
- if (VIR_ALLOC_N(info, args->maxinfo) < 0)
- goto oom;
- if (args->maplen > 0 &&
- VIR_ALLOC_N(cpumaps, args->maxinfo * args->maplen) < 0)
- goto oom;
-
- info_len = virDomainGetVcpus (dom,
- info, args->maxinfo,
- cpumaps, args->maplen);
- if (info_len == -1) {
- VIR_FREE(info);
- VIR_FREE(cpumaps);
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* Allocate the return buffer for info. */
- ret->info.info_len = info_len;
- if (VIR_ALLOC_N(ret->info.info_val, info_len) < 0)
- goto oom;
-
- for (i = 0; i < info_len; ++i) {
- ret->info.info_val[i].number = info[i].number;
- ret->info.info_val[i].state = info[i].state;
- ret->info.info_val[i].cpu_time = info[i].cpuTime;
- ret->info.info_val[i].cpu = info[i].cpu;
- }
-
- /* Don't need to allocate/copy the cpumaps if we make the reasonable
- * assumption that unsigned char and char are the same size.
- * Note that remoteDispatchClientRequest will free.
- */
- ret->cpumaps.cpumaps_len = args->maxinfo * args->maplen;
- ret->cpumaps.cpumaps_val = (char *) cpumaps;
-
- VIR_FREE(info);
- virDomainFree(dom);
- return 0;
-
-oom:
- VIR_FREE(info);
- VIR_FREE(cpumaps);
- virDomainFree(dom);
- remoteDispatchOOMError(rerr);
- return -1;
-}
-
-static int
-remoteDispatchDomainMigratePrepare (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_migrate_prepare_args *args,
- remote_domain_migrate_prepare_ret *ret)
-{
- int r;
- char *cookie = NULL;
- int cookielen = 0;
- char *uri_in;
- char **uri_out;
- char *dname;
-
- uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
- dname = args->dname == NULL ? NULL : *args->dname;
-
- /* Wacky world of XDR ... */
- if (VIR_ALLOC(uri_out) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- r = virDomainMigratePrepare (conn, &cookie, &cookielen,
- uri_in, uri_out,
- args->flags, dname, args->resource);
- if (r == -1) {
- VIR_FREE(uri_out);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free cookie, uri_out and
- * the string if there is one.
- */
- ret->cookie.cookie_len = cookielen;
- ret->cookie.cookie_val = cookie;
- if (*uri_out == NULL) {
- ret->uri_out = NULL;
- VIR_FREE(uri_out);
- } else {
- ret->uri_out = uri_out;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainMigratePerform (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_migrate_perform_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- int r;
- virDomainPtr dom;
- char *dname;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- dname = args->dname == NULL ? NULL : *args->dname;
-
- r = virDomainMigratePerform (dom,
- args->cookie.cookie_val,
- args->cookie.cookie_len,
- args->uri,
- args->flags, dname, args->resource);
- virDomainFree (dom);
- if (r == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainMigrateFinish (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_migrate_finish_args *args,
- remote_domain_migrate_finish_ret *ret)
-{
- virDomainPtr ddom;
- CHECK_CONN (client);
-
- ddom = virDomainMigrateFinish (conn, args->dname,
- args->cookie.cookie_val,
- args->cookie.cookie_len,
- args->uri,
- args->flags);
- if (ddom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->ddom, ddom);
- virDomainFree (ddom);
- return 0;
-}
-
-static int
-remoteDispatchDomainMigratePrepare2 (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_migrate_prepare2_args *args,
- remote_domain_migrate_prepare2_ret *ret)
-{
- int r;
- char *cookie = NULL;
- int cookielen = 0;
- char *uri_in;
- char **uri_out;
- char *dname;
- CHECK_CONN (client);
-
- uri_in = args->uri_in == NULL ? NULL : *args->uri_in;
- dname = args->dname == NULL ? NULL : *args->dname;
-
- /* Wacky world of XDR ... */
- if (VIR_ALLOC(uri_out) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- r = virDomainMigratePrepare2 (conn, &cookie, &cookielen,
- uri_in, uri_out,
- args->flags, dname, args->resource,
- args->dom_xml);
- if (r == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free cookie, uri_out and
- * the string if there is one.
- */
- ret->cookie.cookie_len = cookielen;
- ret->cookie.cookie_val = cookie;
- ret->uri_out = *uri_out == NULL ? NULL : uri_out;
-
- return 0;
-}
-
-static int
-remoteDispatchDomainMigrateFinish2 (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_migrate_finish2_args *args,
- remote_domain_migrate_finish2_ret *ret)
-{
- virDomainPtr ddom;
- CHECK_CONN (client);
-
- ddom = virDomainMigrateFinish2 (conn, args->dname,
- args->cookie.cookie_val,
- args->cookie.cookie_len,
- args->uri,
- args->flags,
- args->retcode);
- if (ddom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->ddom, ddom);
-
- return 0;
-}
-
-static int
-remoteDispatchListDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_defined_domains_args *args,
- remote_list_defined_domains_ret *ret)
-{
-
- if (args->maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_DOMAIN_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListDefinedDomains (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainLookupById (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_lookup_by_id_args *args,
- remote_domain_lookup_by_id_ret *ret)
-{
- virDomainPtr dom;
-
- dom = virDomainLookupByID (conn, args->id);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->dom, dom);
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_lookup_by_name_args *args,
- remote_domain_lookup_by_name_ret *ret)
-{
- virDomainPtr dom;
-
- dom = virDomainLookupByName (conn, args->name);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->dom, dom);
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_lookup_by_uuid_args *args,
- remote_domain_lookup_by_uuid_ret *ret)
-{
- virDomainPtr dom;
-
- dom = virDomainLookupByUUID (conn, (unsigned char *) args->uuid);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_domain (&ret->dom, dom);
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchNumOfDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_defined_domains_ret *ret)
-{
-
- ret->num = virConnectNumOfDefinedDomains (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainPinVcpu (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_pin_vcpu_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
- int rv;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (args->cpumap.cpumap_len > REMOTE_CPUMAP_MAX) {
- virDomainFree(dom);
- remoteDispatchFormatError (rerr, "%s", _("cpumap_len > REMOTE_CPUMAP_MAX"));
- return -1;
- }
-
- rv = virDomainPinVcpu (dom, args->vcpu,
- (unsigned char *) args->cpumap.cpumap_val,
- args->cpumap.cpumap_len);
- if (rv == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainReboot (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_reboot_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainReboot (dom, args->flags) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainRestore (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_restore_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
-
- if (virDomainRestore (conn, args->from) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchDomainResume (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_resume_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainResume (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSave (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_save_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSave (dom, args->to) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainCoreDump (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_core_dump_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainCoreDump (dom, args->to, args->flags) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_set_autostart_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSetAutostart (dom, args->autostart) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_set_max_memory_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSetMaxMemory (dom, args->memory) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSetMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_set_memory_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSetMemory (dom, args->memory) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_set_vcpus_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSetVcpus (dom, args->nvcpus) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainShutdown (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_shutdown_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainShutdown (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainSuspend (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_suspend_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainSuspend (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchDomainUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_domain_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virDomainPtr dom;
-
- dom = get_nonnull_domain (conn, args->dom);
- if (dom == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virDomainUndefine (dom) == -1) {
- virDomainFree(dom);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virDomainFree(dom);
- return 0;
-}
-
-static int
-remoteDispatchListDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_defined_networks_args *args,
- remote_list_defined_networks_ret *ret)
-{
-
- if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListDefinedNetworks (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_domains_args *args,
- remote_list_domains_ret *ret)
-{
-
- if (args->maxids > REMOTE_DOMAIN_ID_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxids > REMOTE_DOMAIN_ID_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->ids.ids_val, args->maxids) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->ids.ids_len = virConnectListDomains (conn,
- ret->ids.ids_val, args->maxids);
- if (ret->ids.ids_len == -1) {
- VIR_FREE(ret->ids.ids_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_networks_args *args,
- remote_list_networks_ret *ret)
-{
-
- if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListNetworks (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_len);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNetworkCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_create_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virNetworkCreate (net) == -1) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_create_xml_args *args,
- remote_network_create_xml_ret *ret)
-{
- virNetworkPtr net;
-
- net = virNetworkCreateXML (conn, args->xml);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_network (&ret->net, net);
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_define_xml_args *args,
- remote_network_define_xml_ret *ret)
-{
- virNetworkPtr net;
-
- net = virNetworkDefineXML (conn, args->xml);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_network (&ret->net, net);
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virNetworkDestroy (net) == -1) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_dump_xml_args *args,
- remote_network_dump_xml_ret *ret)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virNetworkGetXMLDesc (net, args->flags);
- if (!ret->xml) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_get_autostart_args *args,
- remote_network_get_autostart_ret *ret)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virNetworkGetAutostart (net, &ret->autostart) == -1) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkGetBridgeName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_get_bridge_name_args *args,
- remote_network_get_bridge_name_ret *ret)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->name = virNetworkGetBridgeName (net);
- if (!ret->name) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_lookup_by_name_args *args,
- remote_network_lookup_by_name_ret *ret)
-{
- virNetworkPtr net;
-
- net = virNetworkLookupByName (conn, args->name);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_network (&ret->net, net);
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_lookup_by_uuid_args *args,
- remote_network_lookup_by_uuid_ret *ret)
-{
- virNetworkPtr net;
-
- net = virNetworkLookupByUUID (conn, (unsigned char *) args->uuid);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_network (&ret->net, net);
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_set_autostart_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virNetworkSetAutostart (net, args->autostart) == -1) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNetworkUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_network_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNetworkPtr net;
-
- net = get_nonnull_network (conn, args->net);
- if (net == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virNetworkUndefine (net) == -1) {
- virNetworkFree(net);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virNetworkFree(net);
- return 0;
-}
-
-static int
-remoteDispatchNumOfDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_defined_networks_ret *ret)
-{
-
- ret->num = virConnectNumOfDefinedNetworks (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNumOfDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_domains_ret *ret)
-{
-
- ret->num = virConnectNumOfDomains (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNumOfNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_networks_ret *ret)
-{
-
- ret->num = virConnectNumOfNetworks (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-/*-------------------------------------------------------------*/
-static int
-remoteDispatchNumOfInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_interfaces_ret *ret)
-{
-
- ret->num = virConnectNumOfInterfaces (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_interfaces_args *args,
- remote_list_interfaces_ret *ret)
-{
-
- if (args->maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_INTERFACE_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListInterfaces (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_len);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNumOfDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_defined_interfaces_ret *ret)
-{
-
- ret->num = virConnectNumOfDefinedInterfaces (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_defined_interfaces_args *args,
- remote_list_defined_interfaces_ret *ret)
-{
-
- if (args->maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListDefinedInterfaces (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_len);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchInterfaceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_lookup_by_name_args *args,
- remote_interface_lookup_by_name_ret *ret)
-{
- virInterfacePtr iface;
-
- iface = virInterfaceLookupByName (conn, args->name);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_interface (&ret->iface, iface);
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceLookupByMacString (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_lookup_by_mac_string_args *args,
- remote_interface_lookup_by_mac_string_ret *ret)
-{
- virInterfacePtr iface;
-
- iface = virInterfaceLookupByMACString (conn, args->mac);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_interface (&ret->iface, iface);
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_get_xml_desc_args *args,
- remote_interface_get_xml_desc_ret *ret)
-{
- virInterfacePtr iface;
-
- iface = get_nonnull_interface (conn, args->iface);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virInterfaceGetXMLDesc (iface, args->flags);
- if (!ret->xml) {
- virInterfaceFree(iface);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_define_xml_args *args,
- remote_interface_define_xml_ret *ret)
-{
- virInterfacePtr iface;
-
- iface = virInterfaceDefineXML (conn, args->xml, args->flags);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_interface (&ret->iface, iface);
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virInterfacePtr iface;
-
- iface = get_nonnull_interface (conn, args->iface);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virInterfaceUndefine (iface) == -1) {
- virInterfaceFree(iface);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_create_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virInterfacePtr iface;
-
- iface = get_nonnull_interface (conn, args->iface);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virInterfaceCreate (iface, args->flags) == -1) {
- virInterfaceFree(iface);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virInterfaceFree(iface);
- return 0;
-}
-
-static int
-remoteDispatchInterfaceDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virInterfacePtr iface;
-
- iface = get_nonnull_interface (conn, args->iface);
- if (iface == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virInterfaceDestroy (iface, args->flags) == -1) {
- virInterfaceFree(iface);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virInterfaceFree(iface);
- return 0;
-}
-
-/*-------------------------------------------------------------*/
-
-static int
-remoteDispatchAuthList (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_list_ret *ret)
-{
- ret->types.types_len = 1;
- if (VIR_ALLOC_N(ret->types.types_val, ret->types.types_len) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
- ret->types.types_val[0] = client->auth;
- virMutexUnlock(&client->lock);
-
- return 0;
-}
-
-
-#if HAVE_SASL
-/*
- * NB, keep in sync with similar method in src/remote_internal.c
- */
-static char *addrToString(remote_error *rerr,
- struct sockaddr_storage *sa, socklen_t salen) {
- char host[1024], port[20];
- char *addr;
- int err;
-
- if ((err = getnameinfo((struct sockaddr *)sa, salen,
- host, sizeof(host),
- port, sizeof(port),
- NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
- remoteDispatchFormatError(rerr,
- _("Cannot resolve address %d: %s"),
- err, gai_strerror(err));
- return NULL;
- }
-
- if (virAsprintf(&addr, "%s;%s", host, port) == -1) {
- virReportOOMError(NULL);
- return NULL;
- }
-
- return addr;
-}
-
-
-/*
- * Initializes the SASL session in prepare for authentication
- * and gives the client a list of allowed mechanisms to choose
- *
- * XXX callbacks for stuff like password verification ?
- */
-static int
-remoteDispatchAuthSaslInit (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_sasl_init_ret *ret)
-{
- const char *mechlist = NULL;
- sasl_security_properties_t secprops;
- int err;
- struct sockaddr_storage sa;
- socklen_t salen;
- char *localAddr, *remoteAddr;
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- REMOTE_DEBUG("Initialize SASL auth %d", client->fd);
- if (client->auth != REMOTE_AUTH_SASL ||
- client->saslconn != NULL) {
- VIR_ERROR0(_("client tried invalid SASL init request"));
- goto authfail;
- }
-
- /* Get local address in form IPADDR:PORT */
- salen = sizeof(sa);
- if (getsockname(client->fd, (struct sockaddr*)&sa, &salen) < 0) {
- char ebuf[1024];
- remoteDispatchFormatError(rerr,
- _("failed to get sock address: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- goto error;
- }
- if ((localAddr = addrToString(rerr, &sa, salen)) == NULL) {
- goto error;
- }
-
- /* Get remote address in form IPADDR:PORT */
- salen = sizeof(sa);
- if (getpeername(client->fd, (struct sockaddr*)&sa, &salen) < 0) {
- char ebuf[1024];
- remoteDispatchFormatError(rerr, _("failed to get peer address: %s"),
- virStrerror(errno, ebuf, sizeof ebuf));
- VIR_FREE(localAddr);
- goto error;
- }
- if ((remoteAddr = addrToString(rerr, &sa, salen)) == NULL) {
- VIR_FREE(localAddr);
- goto error;
- }
-
- err = sasl_server_new("libvirt",
- NULL, /* FQDN - just delegates to gethostname */
- NULL, /* User realm */
- localAddr,
- remoteAddr,
- NULL, /* XXX Callbacks */
- SASL_SUCCESS_DATA,
- &client->saslconn);
- VIR_FREE(localAddr);
- VIR_FREE(remoteAddr);
- if (err != SASL_OK) {
- VIR_ERROR(_("sasl context setup failed %d (%s)"),
- err, sasl_errstring(err, NULL, NULL));
- client->saslconn = NULL;
- goto authfail;
- }
-
- /* Inform SASL that we've got an external SSF layer from TLS */
- if (client->type == QEMUD_SOCK_TYPE_TLS) {
- gnutls_cipher_algorithm_t cipher;
- sasl_ssf_t ssf;
-
- cipher = gnutls_cipher_get(client->tlssession);
- if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
- VIR_ERROR0(_("cannot get TLS cipher size"));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
- ssf *= 8; /* tls key size is bytes, sasl wants bits */
-
- err = sasl_setprop(client->saslconn, SASL_SSF_EXTERNAL, &ssf);
- if (err != SASL_OK) {
- VIR_ERROR(_("cannot set SASL external SSF %d (%s)"),
- err, sasl_errstring(err, NULL, NULL));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
- }
-
- memset (&secprops, 0, sizeof secprops);
- if (client->type == QEMUD_SOCK_TYPE_TLS ||
- client->type == QEMUD_SOCK_TYPE_UNIX) {
- /* If we've got TLS or UNIX domain sock, we don't care about SSF */
- secprops.min_ssf = 0;
- secprops.max_ssf = 0;
- secprops.maxbufsize = 8192;
- secprops.security_flags = 0;
- } else {
- /* Plain TCP, better get an SSF layer */
- secprops.min_ssf = 56; /* Good enough to require kerberos */
- secprops.max_ssf = 100000; /* Arbitrary big number */
- secprops.maxbufsize = 8192;
- /* Forbid any anonymous or trivially crackable auth */
- secprops.security_flags =
- SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
- }
-
- err = sasl_setprop(client->saslconn, SASL_SEC_PROPS, &secprops);
- if (err != SASL_OK) {
- VIR_ERROR(_("cannot set SASL security props %d (%s)"),
- err, sasl_errstring(err, NULL, NULL));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
-
- err = sasl_listmech(client->saslconn,
- NULL, /* Don't need to set user */
- "", /* Prefix */
- ",", /* Separator */
- "", /* Suffix */
- &mechlist,
- NULL,
- NULL);
- if (err != SASL_OK) {
- VIR_ERROR(_("cannot list SASL mechanisms %d (%s)"),
- err, sasl_errdetail(client->saslconn));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
- REMOTE_DEBUG("Available mechanisms for client: '%s'", mechlist);
- ret->mechlist = strdup(mechlist);
- if (!ret->mechlist) {
- VIR_ERROR0(_("cannot allocate mechlist"));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
-
- virMutexUnlock(&client->lock);
- return 0;
-
-authfail:
- remoteDispatchAuthError(rerr);
-error:
- virMutexUnlock(&client->lock);
- return -1;
-}
-
-
-/* We asked for an SSF layer, so sanity check that we actually
- * got what we asked for */
-static int
-remoteSASLCheckSSF (struct qemud_client *client,
- remote_error *rerr) {
- const void *val;
- int err, ssf;
-
- if (client->type == QEMUD_SOCK_TYPE_TLS ||
- client->type == QEMUD_SOCK_TYPE_UNIX)
- return 0; /* TLS or UNIX domain sockets trivially OK */
-
- err = sasl_getprop(client->saslconn, SASL_SSF, &val);
- if (err != SASL_OK) {
- VIR_ERROR(_("cannot query SASL ssf on connection %d (%s)"),
- err, sasl_errstring(err, NULL, NULL));
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
- }
- ssf = *(const int *)val;
- REMOTE_DEBUG("negotiated an SSF of %d", ssf);
- if (ssf < 56) { /* 56 is good for Kerberos */
- VIR_ERROR(_("negotiated SSF %d was not strong enough"), ssf);
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
- }
-
- /* Only setup for read initially, because we're about to send an RPC
- * reply which must be in plain text. When the next incoming RPC
- * arrives, we'll switch on writes too
- *
- * cf qemudClientReadSASL in qemud.c
- */
- client->saslSSF = QEMUD_SASL_SSF_READ;
-
- /* We have a SSF !*/
- return 0;
-}
-
-static int
-remoteSASLCheckAccess (struct qemud_server *server,
- struct qemud_client *client,
- remote_error *rerr) {
- const void *val;
- int err;
- char **wildcards;
-
- err = sasl_getprop(client->saslconn, SASL_USERNAME, &val);
- if (err != SASL_OK) {
- VIR_ERROR(_("cannot query SASL username on connection %d (%s)"),
- err, sasl_errstring(err, NULL, NULL));
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
- }
- if (val == NULL) {
- VIR_ERROR0(_("no client username was found"));
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
- }
- REMOTE_DEBUG("SASL client username %s", (const char *)val);
-
- client->saslUsername = strdup((const char*)val);
- if (client->saslUsername == NULL) {
- VIR_ERROR0(_("out of memory copying username"));
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
- }
-
- /* If the list is not set, allow any DN. */
- wildcards = server->saslUsernameWhitelist;
- if (!wildcards)
- return 0; /* No ACL, allow all */
-
- while (*wildcards) {
- if (fnmatch (*wildcards, client->saslUsername, 0) == 0)
- return 0; /* Allowed */
- wildcards++;
- }
-
- /* Denied */
- VIR_ERROR(_("SASL client %s not allowed in whitelist"), client->saslUsername);
- remoteDispatchAuthError(rerr);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- return -1;
-}
-
-
-/*
- * This starts the SASL authentication negotiation.
- */
-static int
-remoteDispatchAuthSaslStart (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- remote_auth_sasl_start_args *args,
- remote_auth_sasl_start_ret *ret)
-{
- const char *serverout;
- unsigned int serveroutlen;
- int err;
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- REMOTE_DEBUG("Start SASL auth %d", client->fd);
- if (client->auth != REMOTE_AUTH_SASL ||
- client->saslconn == NULL) {
- VIR_ERROR0(_("client tried invalid SASL start request"));
- goto authfail;
- }
-
- REMOTE_DEBUG("Using SASL mechanism %s. Data %d bytes, nil: %d",
- args->mech, args->data.data_len, args->nil);
- err = sasl_server_start(client->saslconn,
- args->mech,
- /* NB, distinction of NULL vs "" is *critical* in SASL */
- args->nil ? NULL : args->data.data_val,
- args->data.data_len,
- &serverout,
- &serveroutlen);
- if (err != SASL_OK &&
- err != SASL_CONTINUE) {
- VIR_ERROR(_("sasl start failed %d (%s)"),
- err, sasl_errdetail(client->saslconn));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
- if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
- VIR_ERROR(_("sasl start reply data too long %d"), serveroutlen);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
-
- /* NB, distinction of NULL vs "" is *critical* in SASL */
- if (serverout) {
- if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
- remoteDispatchOOMError(rerr);
- goto error;
- }
- memcpy(ret->data.data_val, serverout, serveroutlen);
- } else {
- ret->data.data_val = NULL;
- }
- ret->nil = serverout ? 0 : 1;
- ret->data.data_len = serveroutlen;
-
- REMOTE_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
- if (err == SASL_CONTINUE) {
- ret->complete = 0;
- } else {
- if (remoteSASLCheckSSF(client, rerr) < 0)
- goto error;
-
- /* Check username whitelist ACL */
- if (remoteSASLCheckAccess(server, client, rerr) < 0)
- goto error;
-
- REMOTE_DEBUG("Authentication successful %d", client->fd);
- ret->complete = 1;
- client->auth = REMOTE_AUTH_NONE;
- }
-
- virMutexUnlock(&client->lock);
- return 0;
-
-authfail:
- remoteDispatchAuthError(rerr);
-error:
- virMutexUnlock(&client->lock);
- return -1;
-}
-
-
-static int
-remoteDispatchAuthSaslStep (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- remote_auth_sasl_step_args *args,
- remote_auth_sasl_step_ret *ret)
-{
- const char *serverout;
- unsigned int serveroutlen;
- int err;
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- REMOTE_DEBUG("Step SASL auth %d", client->fd);
- if (client->auth != REMOTE_AUTH_SASL ||
- client->saslconn == NULL) {
- VIR_ERROR0(_("client tried invalid SASL start request"));
- goto authfail;
- }
-
- REMOTE_DEBUG("Using SASL Data %d bytes, nil: %d",
- args->data.data_len, args->nil);
- err = sasl_server_step(client->saslconn,
- /* NB, distinction of NULL vs "" is *critical* in SASL */
- args->nil ? NULL : args->data.data_val,
- args->data.data_len,
- &serverout,
- &serveroutlen);
- if (err != SASL_OK &&
- err != SASL_CONTINUE) {
- VIR_ERROR(_("sasl step failed %d (%s)"),
- err, sasl_errdetail(client->saslconn));
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
-
- if (serveroutlen > REMOTE_AUTH_SASL_DATA_MAX) {
- VIR_ERROR(_("sasl step reply data too long %d"),
- serveroutlen);
- sasl_dispose(&client->saslconn);
- client->saslconn = NULL;
- goto authfail;
- }
-
- /* NB, distinction of NULL vs "" is *critical* in SASL */
- if (serverout) {
- if (VIR_ALLOC_N(ret->data.data_val, serveroutlen) < 0) {
- remoteDispatchOOMError(rerr);
- goto error;
- }
- memcpy(ret->data.data_val, serverout, serveroutlen);
- } else {
- ret->data.data_val = NULL;
- }
- ret->nil = serverout ? 0 : 1;
- ret->data.data_len = serveroutlen;
-
- REMOTE_DEBUG("SASL return data %d bytes, nil; %d", ret->data.data_len, ret->nil);
- if (err == SASL_CONTINUE) {
- ret->complete = 0;
- } else {
- if (remoteSASLCheckSSF(client, rerr) < 0)
- goto error;
-
- /* Check username whitelist ACL */
- if (remoteSASLCheckAccess(server, client, rerr) < 0)
- goto error;
-
- REMOTE_DEBUG("Authentication successful %d", client->fd);
- ret->complete = 1;
- client->auth = REMOTE_AUTH_NONE;
- }
-
- virMutexUnlock(&client->lock);
- return 0;
-
-authfail:
- remoteDispatchAuthError(rerr);
-error:
- virMutexUnlock(&client->lock);
- return -1;
-}
-
-
-#else /* HAVE_SASL */
-static int
-remoteDispatchAuthSaslInit (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_sasl_init_ret *ret ATTRIBUTE_UNUSED)
-{
- VIR_ERROR0(_("client tried unsupported SASL init request"));
- remoteDispatchAuthError(rerr);
- return -1;
-}
-
-static int
-remoteDispatchAuthSaslStart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- remote_auth_sasl_start_args *args ATTRIBUTE_UNUSED,
- remote_auth_sasl_start_ret *ret ATTRIBUTE_UNUSED)
-{
- VIR_ERROR0(_("client tried unsupported SASL start request"));
- remoteDispatchAuthError(rerr);
- return -1;
-}
-
-static int
-remoteDispatchAuthSaslStep (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- remote_auth_sasl_step_args *args ATTRIBUTE_UNUSED,
- remote_auth_sasl_step_ret *ret ATTRIBUTE_UNUSED)
-{
- VIR_ERROR0(_("client tried unsupported SASL step request"));
- remoteDispatchAuthError(rerr);
- return -1;
-}
-#endif /* HAVE_SASL */
-
-
-#if HAVE_POLKIT1
-static int
-remoteDispatchAuthPolkit (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_polkit_ret *ret)
-{
- pid_t callerPid;
- uid_t callerUid;
- const char *action;
- int status = -1;
- char pidbuf[50];
- int rv;
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- action = client->readonly ?
- "org.libvirt.unix.monitor" :
- "org.libvirt.unix.manage";
-
- const char * const pkcheck [] = {
- PKCHECK_PATH,
- "--action-id", action,
- "--process", pidbuf,
- "--allow-user-interaction",
- NULL
- };
-
- REMOTE_DEBUG("Start PolicyKit auth %d", client->fd);
- if (client->auth != REMOTE_AUTH_POLKIT) {
- VIR_ERROR0(_("client tried invalid PolicyKit init request"));
- goto authfail;
- }
-
- if (qemudGetSocketIdentity(client->fd, &callerUid, &callerPid) < 0) {
- VIR_ERROR0(_("cannot get peer socket identity"));
- goto authfail;
- }
-
- VIR_INFO(_("Checking PID %d running as %d"), callerPid, callerUid);
-
- rv = snprintf(pidbuf, sizeof pidbuf, "%d", callerPid);
- if (rv < 0 || rv >= sizeof pidbuf) {
- VIR_ERROR(_("Caller PID was too large %d"), callerPid);
- goto authfail;
- }
-
- if (virRun(NULL, pkcheck, &status) < 0) {
- VIR_ERROR(_("Cannot invoke %s"), PKCHECK_PATH);
- goto authfail;
- }
- if (status != 0) {
- VIR_ERROR(_("Policy kit denied action %s from pid %d, uid %d, result: %d\n"),
- action, callerPid, callerUid, status);
- goto authfail;
- }
- VIR_INFO(_("Policy allowed action %s from pid %d, uid %d"),
- action, callerPid, callerUid);
- ret->complete = 1;
- client->auth = REMOTE_AUTH_NONE;
-
- virMutexUnlock(&client->lock);
- return 0;
-
-authfail:
- remoteDispatchAuthError(rerr);
- virMutexUnlock(&client->lock);
- return -1;
-}
-#elif HAVE_POLKIT0
-static int
-remoteDispatchAuthPolkit (struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_polkit_ret *ret)
-{
- pid_t callerPid;
- uid_t callerUid;
- PolKitCaller *pkcaller = NULL;
- PolKitAction *pkaction = NULL;
- PolKitContext *pkcontext = NULL;
- PolKitError *pkerr = NULL;
- PolKitResult pkresult;
- DBusError err;
- const char *action;
-
- virMutexLock(&server->lock);
- virMutexLock(&client->lock);
- virMutexUnlock(&server->lock);
-
- action = client->readonly ?
- "org.libvirt.unix.monitor" :
- "org.libvirt.unix.manage";
-
- REMOTE_DEBUG("Start PolicyKit auth %d", client->fd);
- if (client->auth != REMOTE_AUTH_POLKIT) {
- VIR_ERROR0(_("client tried invalid PolicyKit init request"));
- goto authfail;
- }
-
- if (qemudGetSocketIdentity(client->fd, &callerUid, &callerPid) < 0) {
- VIR_ERROR0(_("cannot get peer socket identity"));
- goto authfail;
- }
-
- VIR_INFO(_("Checking PID %d running as %d"), callerPid, callerUid);
- dbus_error_init(&err);
- if (!(pkcaller = polkit_caller_new_from_pid(server->sysbus,
- callerPid, &err))) {
- VIR_ERROR(_("Failed to lookup policy kit caller: %s"), err.message);
- dbus_error_free(&err);
- goto authfail;
- }
-
- if (!(pkaction = polkit_action_new())) {
- char ebuf[1024];
- VIR_ERROR(_("Failed to create polkit action %s\n"),
- virStrerror(errno, ebuf, sizeof ebuf));
- polkit_caller_unref(pkcaller);
- goto authfail;
- }
- polkit_action_set_action_id(pkaction, action);
-
- if (!(pkcontext = polkit_context_new()) ||
- !polkit_context_init(pkcontext, &pkerr)) {
- char ebuf[1024];
- VIR_ERROR(_("Failed to create polkit context %s\n"),
- (pkerr ? polkit_error_get_error_message(pkerr)
- : virStrerror(errno, ebuf, sizeof ebuf)));
- if (pkerr)
- polkit_error_free(pkerr);
- polkit_caller_unref(pkcaller);
- polkit_action_unref(pkaction);
- dbus_error_free(&err);
- goto authfail;
- }
-
-#if HAVE_POLKIT_CONTEXT_IS_CALLER_AUTHORIZED
- pkresult = polkit_context_is_caller_authorized(pkcontext,
- pkaction,
- pkcaller,
- 0,
- &pkerr);
- if (pkerr && polkit_error_is_set(pkerr)) {
- VIR_ERROR(_("Policy kit failed to check authorization %d %s"),
- polkit_error_get_error_code(pkerr),
- polkit_error_get_error_message(pkerr));
- goto authfail;
- }
-#else
- pkresult = polkit_context_can_caller_do_action(pkcontext,
- pkaction,
- pkcaller);
-#endif
- polkit_context_unref(pkcontext);
- polkit_caller_unref(pkcaller);
- polkit_action_unref(pkaction);
- if (pkresult != POLKIT_RESULT_YES) {
- VIR_ERROR(_("Policy kit denied action %s from pid %d, uid %d, result: %s\n"),
- action, callerPid, callerUid,
- polkit_result_to_string_representation(pkresult));
- goto authfail;
- }
- VIR_INFO(_("Policy allowed action %s from pid %d, uid %d, result %s"),
- action, callerPid, callerUid,
- polkit_result_to_string_representation(pkresult));
- ret->complete = 1;
- client->auth = REMOTE_AUTH_NONE;
-
- virMutexUnlock(&client->lock);
- return 0;
-
-authfail:
- remoteDispatchAuthError(rerr);
- virMutexUnlock(&client->lock);
- return -1;
-}
-
-#else /* !HAVE_POLKIT0 & !HAVE_POLKIT1*/
-
-static int
-remoteDispatchAuthPolkit (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_auth_polkit_ret *ret ATTRIBUTE_UNUSED)
-{
- VIR_ERROR0(_("client tried unsupported PolicyKit init request"));
- remoteDispatchAuthError(rerr);
- return -1;
-}
-#endif /* HAVE_POLKIT1 */
-
-
-/***************************************************************
- * STORAGE POOL APIS
- ***************************************************************/
-
-
-static int
-remoteDispatchListDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_defined_storage_pools_args *args,
- remote_list_defined_storage_pools_ret *ret)
-{
-
- if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr, "%s",
- _("maxnames > REMOTE_NETWORK_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListDefinedStoragePools (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_list_storage_pools_args *args,
- remote_list_storage_pools_ret *ret)
-{
-
- if (args->maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virConnectListStoragePools (conn,
- ret->names.names_val, args->maxnames);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchFindStoragePoolSources (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_find_storage_pool_sources_args *args,
- remote_find_storage_pool_sources_ret *ret)
-{
- ret->xml =
- virConnectFindStoragePoolSources (conn,
- args->type,
- args->srcSpec ? *args->srcSpec : NULL,
- args->flags);
- if (ret->xml == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchStoragePoolCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_create_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolCreate (pool, args->flags) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_create_xml_args *args,
- remote_storage_pool_create_xml_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = virStoragePoolCreateXML (conn, args->xml, args->flags);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_pool (&ret->pool, pool);
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_define_xml_args *args,
- remote_storage_pool_define_xml_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = virStoragePoolDefineXML (conn, args->xml, args->flags);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_pool (&ret->pool, pool);
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolBuild (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_build_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolBuild (pool, args->flags) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-
-static int
-remoteDispatchStoragePoolDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolDestroy (pool) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_delete_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolDelete (pool, args->flags) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolRefresh (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_refresh_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolRefresh (pool, args->flags) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_get_info_args *args,
- remote_storage_pool_get_info_ret *ret)
-{
- virStoragePoolPtr pool;
- virStoragePoolInfo info;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolGetInfo (pool, &info) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->state = info.state;
- ret->capacity = info.capacity;
- ret->allocation = info.allocation;
- ret->available = info.available;
-
- virStoragePoolFree(pool);
-
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_dump_xml_args *args,
- remote_storage_pool_dump_xml_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virStoragePoolGetXMLDesc (pool, args->flags);
- if (!ret->xml) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_get_autostart_args *args,
- remote_storage_pool_get_autostart_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolGetAutostart (pool, &ret->autostart) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-
-static int
-remoteDispatchStoragePoolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_lookup_by_name_args *args,
- remote_storage_pool_lookup_by_name_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = virStoragePoolLookupByName (conn, args->name);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_pool (&ret->pool, pool);
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_lookup_by_uuid_args *args,
- remote_storage_pool_lookup_by_uuid_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = virStoragePoolLookupByUUID (conn, (unsigned char *) args->uuid);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_pool (&ret->pool, pool);
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolLookupByVolume (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_lookup_by_volume_args *args,
- remote_storage_pool_lookup_by_volume_ret *ret)
-{
- virStoragePoolPtr pool;
- virStorageVolPtr vol;
-
- vol = get_nonnull_storage_vol (conn, args->vol);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- pool = virStoragePoolLookupByVolume (vol);
- virStorageVolFree(vol);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_pool (&ret->pool, pool);
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_set_autostart_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolSetAutostart (pool, args->autostart) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStoragePoolUndefine (pool) == -1) {
- virStoragePoolFree(pool);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStoragePoolFree(pool);
- return 0;
-}
-
-static int
-remoteDispatchNumOfStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_storage_pools_ret *ret)
-{
-
- ret->num = virConnectNumOfStoragePools (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchNumOfDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_defined_storage_pools_ret *ret)
-{
-
- ret->num = virConnectNumOfDefinedStoragePools (conn);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchStoragePoolListVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_list_volumes_args *args,
- remote_storage_pool_list_volumes_ret *ret)
-{
- virStoragePoolPtr pool;
-
- if (args->maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
- remoteDispatchFormatError (rerr,
- "%s", _("maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX"));
- return -1;
- }
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- virStoragePoolFree(pool);
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virStoragePoolListVolumes (pool,
- ret->names.names_val, args->maxnames);
- virStoragePoolFree(pool);
- if (ret->names.names_len == -1) {
- VIR_FREE(ret->names.names_val);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchStoragePoolNumOfVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_pool_num_of_volumes_args *args,
- remote_storage_pool_num_of_volumes_ret *ret)
-{
- virStoragePoolPtr pool;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->num = virStoragePoolNumOfVolumes (pool);
- virStoragePoolFree(pool);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-/***************************************************************
- * STORAGE VOL APIS
- ***************************************************************/
-
-
-
-static int
-remoteDispatchStorageVolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_create_xml_args *args,
- remote_storage_vol_create_xml_ret *ret)
-{
- virStoragePoolPtr pool;
- virStorageVolPtr vol;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- vol = virStorageVolCreateXML (pool, args->xml, args->flags);
- virStoragePoolFree(pool);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_vol (&ret->vol, vol);
- virStorageVolFree(vol);
- return 0;
-}
-
-static int
-remoteDispatchStorageVolCreateXmlFrom (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_create_xml_from_args *args,
- remote_storage_vol_create_xml_from_ret *ret)
-{
- virStoragePoolPtr pool;
- virStorageVolPtr clonevol, newvol;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- clonevol = get_nonnull_storage_vol (conn, args->clonevol);
- if (clonevol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- newvol = virStorageVolCreateXMLFrom (pool, args->xml, clonevol,
- args->flags);
- if (newvol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_vol (&ret->vol, newvol);
- virStorageVolFree(newvol);
- return 0;
-}
-
-static int
-remoteDispatchStorageVolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_delete_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virStorageVolPtr vol;
-
- vol = get_nonnull_storage_vol (conn, args->vol);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStorageVolDelete (vol, args->flags) == -1) {
- virStorageVolFree(vol);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStorageVolFree(vol);
- return 0;
-}
-
-static int
-remoteDispatchStorageVolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_get_info_args *args,
- remote_storage_vol_get_info_ret *ret)
-{
- virStorageVolPtr vol;
- virStorageVolInfo info;
-
- vol = get_nonnull_storage_vol (conn, args->vol);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- if (virStorageVolGetInfo (vol, &info) == -1) {
- virStorageVolFree(vol);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- ret->type = info.type;
- ret->capacity = info.capacity;
- ret->allocation = info.allocation;
-
- virStorageVolFree(vol);
-
- return 0;
-}
-
-static int
-remoteDispatchStorageVolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_dump_xml_args *args,
- remote_storage_vol_dump_xml_ret *ret)
-{
- virStorageVolPtr vol;
-
- vol = get_nonnull_storage_vol (conn, args->vol);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virStorageVolGetXMLDesc (vol, args->flags);
- if (!ret->xml) {
- virStorageVolFree(vol);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStorageVolFree(vol);
- return 0;
-}
-
-
-static int
-remoteDispatchStorageVolGetPath (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_get_path_args *args,
- remote_storage_vol_get_path_ret *ret)
-{
- virStorageVolPtr vol;
-
- vol = get_nonnull_storage_vol (conn, args->vol);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->name = virStorageVolGetPath (vol);
- if (!ret->name) {
- virStorageVolFree(vol);
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
- virStorageVolFree(vol);
- return 0;
-}
-
-
-static int
-remoteDispatchStorageVolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_lookup_by_name_args *args,
- remote_storage_vol_lookup_by_name_ret *ret)
-{
- virStoragePoolPtr pool;
- virStorageVolPtr vol;
-
- pool = get_nonnull_storage_pool (conn, args->pool);
- if (pool == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- vol = virStorageVolLookupByName (pool, args->name);
- virStoragePoolFree(pool);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_vol (&ret->vol, vol);
- virStorageVolFree(vol);
- return 0;
-}
-
-static int
-remoteDispatchStorageVolLookupByKey (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_lookup_by_key_args *args,
- remote_storage_vol_lookup_by_key_ret *ret)
-{
- virStorageVolPtr vol;
-
- vol = virStorageVolLookupByKey (conn, args->key);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_vol (&ret->vol, vol);
- virStorageVolFree(vol);
- return 0;
-}
-
-
-static int
-remoteDispatchStorageVolLookupByPath (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_storage_vol_lookup_by_path_args *args,
- remote_storage_vol_lookup_by_path_ret *ret)
-{
- virStorageVolPtr vol;
-
- vol = virStorageVolLookupByPath (conn, args->path);
- if (vol == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_storage_vol (&ret->vol, vol);
- virStorageVolFree(vol);
- return 0;
-}
-
-
-/***************************************************************
- * NODE INFO APIS
- **************************************************************/
-
-static int
-remoteDispatchNodeNumOfDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_num_of_devices_args *args,
- remote_node_num_of_devices_ret *ret)
-{
- CHECK_CONN(client);
-
- ret->num = virNodeNumOfDevices (conn,
- args->cap ? *args->cap : NULL,
- args->flags);
- if (ret->num == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeListDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_list_devices_args *args,
- remote_node_list_devices_ret *ret)
-{
- CHECK_CONN(client);
-
- if (args->maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
- remoteDispatchFormatError(rerr,
- "%s", _("maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virNodeListDevices (conn,
- args->cap ? *args->cap : NULL,
- ret->names.names_val, args->maxnames, args->flags);
- if (ret->names.names_len == -1) {
- remoteDispatchConnError(rerr, conn);
- VIR_FREE(ret->names.names_val);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_lookup_by_name_args *args,
- remote_node_device_lookup_by_name_ret *ret)
-{
- virNodeDevicePtr dev;
-
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName (conn, args->name);
- if (dev == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_node_device (&ret->dev, dev);
- virNodeDeviceFree(dev);
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_dump_xml_args *args,
- remote_node_device_dump_xml_ret *ret)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- /* remoteDispatchClientRequest will free this. */
- ret->xml = virNodeDeviceGetXMLDesc (dev, args->flags);
- if (!ret->xml) {
- remoteDispatchConnError(rerr, conn);
- virNodeDeviceFree(dev);
- return -1;
- }
- virNodeDeviceFree(dev);
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceGetParent (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_get_parent_args *args,
- remote_node_device_get_parent_ret *ret)
-{
- virNodeDevicePtr dev;
- const char *parent;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- parent = virNodeDeviceGetParent(dev);
-
- if (parent == NULL) {
- ret->parent = NULL;
- } else {
- /* remoteDispatchClientRequest will free this. */
- char **parent_p;
- if (VIR_ALLOC(parent_p) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
- *parent_p = strdup(parent);
- if (*parent_p == NULL) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
- ret->parent = parent_p;
- }
-
- virNodeDeviceFree(dev);
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceNumOfCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_num_of_caps_args *args,
- remote_node_device_num_of_caps_ret *ret)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- ret->num = virNodeDeviceNumOfCaps(dev);
- if (ret->num < 0) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- virNodeDeviceFree(dev);
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceListCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_list_caps_args *args,
- remote_node_device_list_caps_ret *ret)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- if (args->maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
- remoteDispatchFormatError(rerr,
- "%s", _("maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX"));
- return -1;
- }
-
- /* Allocate return buffer. */
- if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
- remoteDispatchOOMError(rerr);
- return -1;
- }
-
- ret->names.names_len =
- virNodeDeviceListCaps (dev, ret->names.names_val,
- args->maxnames);
- if (ret->names.names_len == -1) {
- remoteDispatchConnError(rerr, conn);
- VIR_FREE(ret->names.names_val);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceDettach (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_dettach_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- if (virNodeDeviceDettach(dev) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceReAttach (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_re_attach_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- if (virNodeDeviceReAttach(dev) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceReset (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_reset_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNodeDevicePtr dev;
- CHECK_CONN(client);
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- if (virNodeDeviceReset(dev) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceCreateXml(struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_create_xml_args *args,
- remote_node_device_create_xml_ret *ret)
-{
- virNodeDevicePtr dev;
-
- dev = virNodeDeviceCreateXML (conn, args->xml_desc, args->flags);
- if (dev == NULL) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- make_nonnull_node_device (&ret->dev, dev);
- virNodeDeviceFree(dev);
-
- return 0;
-}
-
-
-static int
-remoteDispatchNodeDeviceDestroy(struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_node_device_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virNodeDevicePtr dev;
-
- dev = virNodeDeviceLookupByName(conn, args->name);
- if (dev == NULL) {
- remoteDispatchFormatError(rerr, "%s", _("node_device not found"));
- return -1;
- }
-
- if (virNodeDeviceDestroy(dev) == -1) {
- remoteDispatchConnError(rerr, conn);
- return -1;
- }
-
- return 0;
-}
-
-
-
-/***************************
- * Register / deregister events
- ***************************/
-static int
-remoteDispatchDomainEventsRegister (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr ATTRIBUTE_UNUSED,
- void *args ATTRIBUTE_UNUSED,
- remote_domain_events_register_ret *ret ATTRIBUTE_UNUSED)
-{
- CHECK_CONN(client);
-
- /* Register event delivery callback */
- REMOTE_DEBUG("%s","Registering to relay remote events");
- virConnectDomainEventRegister(conn, remoteRelayDomainEvent, client, NULL);
-
- if(ret)
- ret->cb_registered = 1;
- return 0;
-}
-
-static int
-remoteDispatchDomainEventsDeregister (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr ATTRIBUTE_UNUSED,
- void *args ATTRIBUTE_UNUSED,
- remote_domain_events_deregister_ret *ret ATTRIBUTE_UNUSED)
-{
- CHECK_CONN(client);
-
- /* Deregister event delivery callback */
- REMOTE_DEBUG("%s","Deregistering to relay remote events");
- virConnectDomainEventDeregister(conn, remoteRelayDomainEvent);
-
- if(ret)
- ret->cb_registered = 0;
- return 0;
-}
-
-static void
-remoteDispatchDomainEventSend (struct qemud_client *client,
- remote_domain_event_msg *data)
-{
- struct qemud_client_message *msg = NULL;
- XDR xdr;
- unsigned int len;
-
- if (VIR_ALLOC(msg) < 0)
- return;
-
- msg->hdr.prog = REMOTE_PROGRAM;
- msg->hdr.vers = REMOTE_PROTOCOL_VERSION;
- msg->hdr.proc = REMOTE_PROC_DOMAIN_EVENT;
- msg->hdr.type = REMOTE_MESSAGE;
- msg->hdr.serial = 1;
- msg->hdr.status = REMOTE_OK;
-
- if (remoteEncodeClientMessageHeader(msg) < 0)
- goto error;
-
- /* Serialise the return header and event. */
- xdrmem_create (&xdr,
- msg->buffer + msg->bufferOffset,
- msg->bufferLength - msg->bufferOffset,
- XDR_ENCODE);
-
- if (!xdr_remote_domain_event_msg(&xdr, data))
- goto xdr_error;
-
-
- /* Update 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;
-
- /* Send it. */
- msg->async = 1;
- msg->bufferLength = len;
- msg->bufferOffset = 0;
- qemudClientMessageQueuePush(&client->tx, msg);
- qemudUpdateClientEvent(client);
-
- xdr_destroy (&xdr);
- return;
-
-xdr_error:
- xdr_destroy(&xdr);
-error:
- VIR_FREE(msg);
-}
-
-static int
-remoteDispatchNumOfSecrets (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- void *args ATTRIBUTE_UNUSED,
- remote_num_of_secrets_ret *ret)
-{
- ret->num = virConnectNumOfSecrets (conn);
- if (ret->num == -1) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchListSecrets (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_list_secrets_args *args,
- remote_list_secrets_ret *ret)
-{
- if (args->maxuuids > REMOTE_SECRET_UUID_LIST_MAX) {
- remoteDispatchFormatError (err, "%s",
- _("maxuuids > REMOTE_SECRET_UUID_LIST_MAX"));
- return -1;
- }
-
- if (VIR_ALLOC_N (ret->uuids.uuids_val, args->maxuuids) < 0) {
- remoteDispatchOOMError (err);
- return -1;
- }
-
- ret->uuids.uuids_len = virConnectListSecrets (conn, ret->uuids.uuids_val,
- args->maxuuids);
- if (ret->uuids.uuids_len == -1) {
- VIR_FREE (ret->uuids.uuids_val);
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- return 0;
-}
-
-static int
-remoteDispatchSecretDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_define_xml_args *args,
- remote_secret_define_xml_ret *ret)
-{
- virSecretPtr secret;
-
- secret = virSecretDefineXML (conn, args->xml, args->flags);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- make_nonnull_secret (&ret->secret, secret);
- virSecretFree (secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretGetValue (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_get_value_args *args,
- remote_secret_get_value_ret *ret)
-{
- virSecretPtr secret;
- size_t value_size;
- unsigned char *value;
-
- secret = get_nonnull_secret (conn, args->secret);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- value = virSecretGetValue (secret, &value_size, args->flags);
- if (value == NULL) {
- remoteDispatchConnError (err, conn);
- virSecretFree(secret);
- return -1;
- }
-
- ret->value.value_len = value_size;
- ret->value.value_val = (char *)value;
- virSecretFree(secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_get_xml_desc_args *args,
- remote_secret_get_xml_desc_ret *ret)
-{
- virSecretPtr secret;
-
- secret = get_nonnull_secret (conn, args->secret);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
- ret->xml = virSecretGetXMLDesc (secret, args->flags);
- if (ret->xml == NULL) {
- remoteDispatchConnError (err, conn);
- virSecretFree(secret);
- return -1;
- }
- virSecretFree(secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_lookup_by_uuid_args *args,
- remote_secret_lookup_by_uuid_ret *ret)
-{
- virSecretPtr secret;
-
- secret = virSecretLookupByUUID (conn, (unsigned char *)args->uuid);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- make_nonnull_secret (&ret->secret, secret);
- virSecretFree (secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretSetValue (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_set_value_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virSecretPtr secret;
-
- secret = get_nonnull_secret (conn, args->secret);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
- if (virSecretSetValue (secret, (const unsigned char *)args->value.value_val,
- args->value.value_len, args->flags) < 0) {
- remoteDispatchConnError (err, conn);
- virSecretFree(secret);
- return -1;
- }
-
- virSecretFree(secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
-{
- virSecretPtr secret;
-
- secret = get_nonnull_secret (conn, args->secret);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
- if (virSecretUndefine (secret) < 0) {
- remoteDispatchConnError (err, conn);
- virSecretFree(secret);
- return -1;
- }
-
- virSecretFree(secret);
- return 0;
-}
-
-static int
-remoteDispatchSecretLookupByUsage (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn, remote_error *err,
- remote_secret_lookup_by_usage_args *args,
- remote_secret_lookup_by_usage_ret *ret)
-{
- virSecretPtr secret;
-
- secret = virSecretLookupByUsage (conn, args->usageType, args->usageID);
- if (secret == NULL) {
- remoteDispatchConnError (err, conn);
- return -1;
- }
-
- make_nonnull_secret (&ret->secret, secret);
- virSecretFree (secret);
- return 0;
-}
-
-
-/*----- Helpers. -----*/
-
-/* get_nonnull_domain and get_nonnull_network turn an on-wire
- * (name, uuid) pair into virDomainPtr or virNetworkPtr object.
- * virDomainPtr or virNetworkPtr cannot be NULL.
- *
- * NB. If these return NULL then the caller must return an error.
- */
-static virDomainPtr
-get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain)
-{
- virDomainPtr dom;
- dom = virGetDomain (conn, domain.name, BAD_CAST domain.uuid);
- /* Should we believe the domain.id sent by the client? Maybe
- * this should be a check rather than an assignment? XXX
- */
- if (dom) dom->id = domain.id;
- return dom;
-}
-
-static virNetworkPtr
-get_nonnull_network (virConnectPtr conn, remote_nonnull_network network)
-{
- return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
-}
-
-static virInterfacePtr
-get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface iface)
-{
- return virGetInterface (conn, iface.name, iface.mac);
-}
-
-static virStoragePoolPtr
-get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
-{
- return virGetStoragePool (conn, pool.name, BAD_CAST pool.uuid);
-}
-
-static virStorageVolPtr
-get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol)
-{
- virStorageVolPtr ret;
- ret = virGetStorageVol (conn, vol.pool, vol.name, vol.key);
- return ret;
-}
-
-static virSecretPtr
-get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret)
-{
- return virGetSecret (conn, BAD_CAST secret.uuid, secret.usageType, secret.usageID);
-}
-
-/* Make remote_nonnull_domain and remote_nonnull_network. */
-static void
-make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
-{
- dom_dst->id = dom_src->id;
- dom_dst->name = strdup (dom_src->name);
- memcpy (dom_dst->uuid, dom_src->uuid, VIR_UUID_BUFLEN);
-}
-
-static void
-make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src)
-{
- net_dst->name = strdup (net_src->name);
- memcpy (net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
-}
-
-static void
-make_nonnull_interface (remote_nonnull_interface *interface_dst,
- virInterfacePtr interface_src)
-{
- interface_dst->name = strdup (interface_src->name);
- interface_dst->mac = strdup (interface_src->mac);
-}
-
-static void
-make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
-{
- pool_dst->name = strdup (pool_src->name);
- memcpy (pool_dst->uuid, pool_src->uuid, VIR_UUID_BUFLEN);
-}
-
-static void
-make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src)
-{
- vol_dst->pool = strdup (vol_src->pool);
- vol_dst->name = strdup (vol_src->name);
- vol_dst->key = strdup (vol_src->key);
-}
-
-static void
-make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src)
-{
- dev_dst->name = strdup(dev_src->name);
-}
-
-static void
-make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src)
-{
- memcpy (secret_dst->uuid, secret_src->uuid, VIR_UUID_BUFLEN);
- secret_dst->usageType = secret_src->usageType;
- secret_dst->usageID = strdup (secret_src->usageID);
-}
+++ /dev/null
-/*
- * 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__ */
+++ /dev/null
-/* 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;
+++ /dev/null
-/* Automatically generated by remote_generate_stubs.pl.
- * Do not edit this file. Any changes you make will be lost.
- */
-
-static int remoteDispatchAuthList(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_auth_list_ret *ret);
-static int remoteDispatchAuthPolkit(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_auth_polkit_ret *ret);
-static int remoteDispatchAuthSaslInit(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_auth_sasl_init_ret *ret);
-static int remoteDispatchAuthSaslStart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_auth_sasl_start_args *args,
- remote_auth_sasl_start_ret *ret);
-static int remoteDispatchAuthSaslStep(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_auth_sasl_step_args *args,
- remote_auth_sasl_step_ret *ret);
-static int remoteDispatchClose(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- void *ret);
-static int remoteDispatchDomainAttachDevice(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_attach_device_args *args,
- void *ret);
-static int remoteDispatchDomainBlockPeek(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_block_peek_args *args,
- remote_domain_block_peek_ret *ret);
-static int remoteDispatchDomainBlockStats(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_block_stats_args *args,
- remote_domain_block_stats_ret *ret);
-static int remoteDispatchDomainCoreDump(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_core_dump_args *args,
- void *ret);
-static int remoteDispatchDomainCreate(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_create_args *args,
- void *ret);
-static int remoteDispatchDomainCreateXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_create_xml_args *args,
- remote_domain_create_xml_ret *ret);
-static int remoteDispatchDomainDefineXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_define_xml_args *args,
- remote_domain_define_xml_ret *ret);
-static int remoteDispatchDomainDestroy(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_destroy_args *args,
- void *ret);
-static int remoteDispatchDomainDetachDevice(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_detach_device_args *args,
- void *ret);
-static int remoteDispatchDomainDumpXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_dump_xml_args *args,
- remote_domain_dump_xml_ret *ret);
-static int remoteDispatchDomainEventsDeregister(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_domain_events_deregister_ret *ret);
-static int remoteDispatchDomainEventsRegister(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_domain_events_register_ret *ret);
-static int remoteDispatchDomainGetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_autostart_args *args,
- remote_domain_get_autostart_ret *ret);
-static int remoteDispatchDomainGetInfo(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_info_args *args,
- remote_domain_get_info_ret *ret);
-static int remoteDispatchDomainGetMaxMemory(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_max_memory_args *args,
- remote_domain_get_max_memory_ret *ret);
-static int remoteDispatchDomainGetMaxVcpus(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_max_vcpus_args *args,
- remote_domain_get_max_vcpus_ret *ret);
-static int remoteDispatchDomainGetOsType(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_os_type_args *args,
- remote_domain_get_os_type_ret *ret);
-static int remoteDispatchDomainGetSchedulerParameters(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_scheduler_parameters_args *args,
- remote_domain_get_scheduler_parameters_ret *ret);
-static int remoteDispatchDomainGetSchedulerType(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_scheduler_type_args *args,
- remote_domain_get_scheduler_type_ret *ret);
-static int remoteDispatchDomainGetSecurityLabel(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_security_label_args *args,
- remote_domain_get_security_label_ret *ret);
-static int remoteDispatchDomainGetVcpus(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_get_vcpus_args *args,
- remote_domain_get_vcpus_ret *ret);
-static int remoteDispatchDomainInterfaceStats(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_interface_stats_args *args,
- remote_domain_interface_stats_ret *ret);
-static int remoteDispatchDomainLookupById(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_lookup_by_id_args *args,
- remote_domain_lookup_by_id_ret *ret);
-static int remoteDispatchDomainLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_lookup_by_name_args *args,
- remote_domain_lookup_by_name_ret *ret);
-static int remoteDispatchDomainLookupByUuid(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_lookup_by_uuid_args *args,
- remote_domain_lookup_by_uuid_ret *ret);
-static int remoteDispatchDomainMemoryPeek(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_memory_peek_args *args,
- remote_domain_memory_peek_ret *ret);
-static int remoteDispatchDomainMigrateFinish(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_migrate_finish_args *args,
- remote_domain_migrate_finish_ret *ret);
-static int remoteDispatchDomainMigrateFinish2(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_migrate_finish2_args *args,
- remote_domain_migrate_finish2_ret *ret);
-static int remoteDispatchDomainMigratePerform(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_migrate_perform_args *args,
- void *ret);
-static int remoteDispatchDomainMigratePrepare(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_migrate_prepare_args *args,
- remote_domain_migrate_prepare_ret *ret);
-static int remoteDispatchDomainMigratePrepare2(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_migrate_prepare2_args *args,
- remote_domain_migrate_prepare2_ret *ret);
-static int remoteDispatchDomainPinVcpu(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_pin_vcpu_args *args,
- void *ret);
-static int remoteDispatchDomainReboot(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_reboot_args *args,
- void *ret);
-static int remoteDispatchDomainRestore(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_restore_args *args,
- void *ret);
-static int remoteDispatchDomainResume(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_resume_args *args,
- void *ret);
-static int remoteDispatchDomainSave(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_save_args *args,
- void *ret);
-static int remoteDispatchDomainSetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_set_autostart_args *args,
- void *ret);
-static int remoteDispatchDomainSetMaxMemory(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_set_max_memory_args *args,
- void *ret);
-static int remoteDispatchDomainSetMemory(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_set_memory_args *args,
- void *ret);
-static int remoteDispatchDomainSetSchedulerParameters(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_set_scheduler_parameters_args *args,
- void *ret);
-static int remoteDispatchDomainSetVcpus(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_set_vcpus_args *args,
- void *ret);
-static int remoteDispatchDomainShutdown(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_shutdown_args *args,
- void *ret);
-static int remoteDispatchDomainSuspend(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_suspend_args *args,
- void *ret);
-static int remoteDispatchDomainUndefine(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_undefine_args *args,
- void *ret);
-static int remoteDispatchDomainXmlFromNative(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_xml_from_native_args *args,
- remote_domain_xml_from_native_ret *ret);
-static int remoteDispatchDomainXmlToNative(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_domain_xml_to_native_args *args,
- remote_domain_xml_to_native_ret *ret);
-static int remoteDispatchFindStoragePoolSources(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_find_storage_pool_sources_args *args,
- remote_find_storage_pool_sources_ret *ret);
-static int remoteDispatchGetCapabilities(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_get_capabilities_ret *ret);
-static int remoteDispatchGetHostname(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_get_hostname_ret *ret);
-static int remoteDispatchGetMaxVcpus(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_get_max_vcpus_args *args,
- remote_get_max_vcpus_ret *ret);
-static int remoteDispatchGetType(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_get_type_ret *ret);
-static int remoteDispatchGetUri(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_get_uri_ret *ret);
-static int remoteDispatchGetVersion(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_get_version_ret *ret);
-static int remoteDispatchInterfaceCreate(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_create_args *args,
- void *ret);
-static int remoteDispatchInterfaceDefineXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_define_xml_args *args,
- remote_interface_define_xml_ret *ret);
-static int remoteDispatchInterfaceDestroy(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_destroy_args *args,
- void *ret);
-static int remoteDispatchInterfaceGetXmlDesc(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_get_xml_desc_args *args,
- remote_interface_get_xml_desc_ret *ret);
-static int remoteDispatchInterfaceLookupByMacString(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_lookup_by_mac_string_args *args,
- remote_interface_lookup_by_mac_string_ret *ret);
-static int remoteDispatchInterfaceLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_lookup_by_name_args *args,
- remote_interface_lookup_by_name_ret *ret);
-static int remoteDispatchInterfaceUndefine(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_interface_undefine_args *args,
- void *ret);
-static int remoteDispatchListDefinedDomains(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_defined_domains_args *args,
- remote_list_defined_domains_ret *ret);
-static int remoteDispatchListDefinedInterfaces(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_defined_interfaces_args *args,
- remote_list_defined_interfaces_ret *ret);
-static int remoteDispatchListDefinedNetworks(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_defined_networks_args *args,
- remote_list_defined_networks_ret *ret);
-static int remoteDispatchListDefinedStoragePools(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_defined_storage_pools_args *args,
- remote_list_defined_storage_pools_ret *ret);
-static int remoteDispatchListDomains(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_domains_args *args,
- remote_list_domains_ret *ret);
-static int remoteDispatchListInterfaces(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_interfaces_args *args,
- remote_list_interfaces_ret *ret);
-static int remoteDispatchListNetworks(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_networks_args *args,
- remote_list_networks_ret *ret);
-static int remoteDispatchListSecrets(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_secrets_args *args,
- remote_list_secrets_ret *ret);
-static int remoteDispatchListStoragePools(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_list_storage_pools_args *args,
- remote_list_storage_pools_ret *ret);
-static int remoteDispatchNetworkCreate(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_create_args *args,
- void *ret);
-static int remoteDispatchNetworkCreateXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_create_xml_args *args,
- remote_network_create_xml_ret *ret);
-static int remoteDispatchNetworkDefineXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_define_xml_args *args,
- remote_network_define_xml_ret *ret);
-static int remoteDispatchNetworkDestroy(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_destroy_args *args,
- void *ret);
-static int remoteDispatchNetworkDumpXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_dump_xml_args *args,
- remote_network_dump_xml_ret *ret);
-static int remoteDispatchNetworkGetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_get_autostart_args *args,
- remote_network_get_autostart_ret *ret);
-static int remoteDispatchNetworkGetBridgeName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_get_bridge_name_args *args,
- remote_network_get_bridge_name_ret *ret);
-static int remoteDispatchNetworkLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_lookup_by_name_args *args,
- remote_network_lookup_by_name_ret *ret);
-static int remoteDispatchNetworkLookupByUuid(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_lookup_by_uuid_args *args,
- remote_network_lookup_by_uuid_ret *ret);
-static int remoteDispatchNetworkSetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_set_autostart_args *args,
- void *ret);
-static int remoteDispatchNetworkUndefine(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_network_undefine_args *args,
- void *ret);
-static int remoteDispatchNodeDeviceCreateXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_create_xml_args *args,
- remote_node_device_create_xml_ret *ret);
-static int remoteDispatchNodeDeviceDestroy(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_destroy_args *args,
- void *ret);
-static int remoteDispatchNodeDeviceDettach(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_dettach_args *args,
- void *ret);
-static int remoteDispatchNodeDeviceDumpXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_dump_xml_args *args,
- remote_node_device_dump_xml_ret *ret);
-static int remoteDispatchNodeDeviceGetParent(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_get_parent_args *args,
- remote_node_device_get_parent_ret *ret);
-static int remoteDispatchNodeDeviceListCaps(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_list_caps_args *args,
- remote_node_device_list_caps_ret *ret);
-static int remoteDispatchNodeDeviceLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_lookup_by_name_args *args,
- remote_node_device_lookup_by_name_ret *ret);
-static int remoteDispatchNodeDeviceNumOfCaps(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_num_of_caps_args *args,
- remote_node_device_num_of_caps_ret *ret);
-static int remoteDispatchNodeDeviceReAttach(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_re_attach_args *args,
- void *ret);
-static int remoteDispatchNodeDeviceReset(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_device_reset_args *args,
- void *ret);
-static int remoteDispatchNodeGetCellsFreeMemory(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_get_cells_free_memory_args *args,
- remote_node_get_cells_free_memory_ret *ret);
-static int remoteDispatchNodeGetFreeMemory(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_node_get_free_memory_ret *ret);
-static int remoteDispatchNodeGetInfo(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_node_get_info_ret *ret);
-static int remoteDispatchNodeGetSecurityModel(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_node_get_security_model_ret *ret);
-static int remoteDispatchNodeListDevices(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_list_devices_args *args,
- remote_node_list_devices_ret *ret);
-static int remoteDispatchNodeNumOfDevices(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_node_num_of_devices_args *args,
- remote_node_num_of_devices_ret *ret);
-static int remoteDispatchNumOfDefinedDomains(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_defined_domains_ret *ret);
-static int remoteDispatchNumOfDefinedInterfaces(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_defined_interfaces_ret *ret);
-static int remoteDispatchNumOfDefinedNetworks(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_defined_networks_ret *ret);
-static int remoteDispatchNumOfDefinedStoragePools(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_defined_storage_pools_ret *ret);
-static int remoteDispatchNumOfDomains(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_domains_ret *ret);
-static int remoteDispatchNumOfInterfaces(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_interfaces_ret *ret);
-static int remoteDispatchNumOfNetworks(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_networks_ret *ret);
-static int remoteDispatchNumOfSecrets(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_secrets_ret *ret);
-static int remoteDispatchNumOfStoragePools(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- void *args,
- remote_num_of_storage_pools_ret *ret);
-static int remoteDispatchOpen(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_open_args *args,
- void *ret);
-static int remoteDispatchSecretDefineXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_define_xml_args *args,
- remote_secret_define_xml_ret *ret);
-static int remoteDispatchSecretGetValue(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_get_value_args *args,
- remote_secret_get_value_ret *ret);
-static int remoteDispatchSecretGetXmlDesc(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_get_xml_desc_args *args,
- remote_secret_get_xml_desc_ret *ret);
-static int remoteDispatchSecretLookupByUsage(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_lookup_by_usage_args *args,
- remote_secret_lookup_by_usage_ret *ret);
-static int remoteDispatchSecretLookupByUuid(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_lookup_by_uuid_args *args,
- remote_secret_lookup_by_uuid_ret *ret);
-static int remoteDispatchSecretSetValue(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_set_value_args *args,
- void *ret);
-static int remoteDispatchSecretUndefine(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_secret_undefine_args *args,
- void *ret);
-static int remoteDispatchStoragePoolBuild(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_build_args *args,
- void *ret);
-static int remoteDispatchStoragePoolCreate(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_create_args *args,
- void *ret);
-static int remoteDispatchStoragePoolCreateXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_create_xml_args *args,
- remote_storage_pool_create_xml_ret *ret);
-static int remoteDispatchStoragePoolDefineXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_define_xml_args *args,
- remote_storage_pool_define_xml_ret *ret);
-static int remoteDispatchStoragePoolDelete(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_delete_args *args,
- void *ret);
-static int remoteDispatchStoragePoolDestroy(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_destroy_args *args,
- void *ret);
-static int remoteDispatchStoragePoolDumpXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_dump_xml_args *args,
- remote_storage_pool_dump_xml_ret *ret);
-static int remoteDispatchStoragePoolGetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_get_autostart_args *args,
- remote_storage_pool_get_autostart_ret *ret);
-static int remoteDispatchStoragePoolGetInfo(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_get_info_args *args,
- remote_storage_pool_get_info_ret *ret);
-static int remoteDispatchStoragePoolListVolumes(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_list_volumes_args *args,
- remote_storage_pool_list_volumes_ret *ret);
-static int remoteDispatchStoragePoolLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_lookup_by_name_args *args,
- remote_storage_pool_lookup_by_name_ret *ret);
-static int remoteDispatchStoragePoolLookupByUuid(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_lookup_by_uuid_args *args,
- remote_storage_pool_lookup_by_uuid_ret *ret);
-static int remoteDispatchStoragePoolLookupByVolume(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_lookup_by_volume_args *args,
- remote_storage_pool_lookup_by_volume_ret *ret);
-static int remoteDispatchStoragePoolNumOfVolumes(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_num_of_volumes_args *args,
- remote_storage_pool_num_of_volumes_ret *ret);
-static int remoteDispatchStoragePoolRefresh(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_refresh_args *args,
- void *ret);
-static int remoteDispatchStoragePoolSetAutostart(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_set_autostart_args *args,
- void *ret);
-static int remoteDispatchStoragePoolUndefine(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_pool_undefine_args *args,
- void *ret);
-static int remoteDispatchStorageVolCreateXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_create_xml_args *args,
- remote_storage_vol_create_xml_ret *ret);
-static int remoteDispatchStorageVolCreateXmlFrom(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_create_xml_from_args *args,
- remote_storage_vol_create_xml_from_ret *ret);
-static int remoteDispatchStorageVolDelete(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_delete_args *args,
- void *ret);
-static int remoteDispatchStorageVolDumpXml(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_dump_xml_args *args,
- remote_storage_vol_dump_xml_ret *ret);
-static int remoteDispatchStorageVolGetInfo(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_get_info_args *args,
- remote_storage_vol_get_info_ret *ret);
-static int remoteDispatchStorageVolGetPath(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_get_path_args *args,
- remote_storage_vol_get_path_ret *ret);
-static int remoteDispatchStorageVolLookupByKey(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_lookup_by_key_args *args,
- remote_storage_vol_lookup_by_key_ret *ret);
-static int remoteDispatchStorageVolLookupByName(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_lookup_by_name_args *args,
- remote_storage_vol_lookup_by_name_ret *ret);
-static int remoteDispatchStorageVolLookupByPath(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_storage_vol_lookup_by_path_args *args,
- remote_storage_vol_lookup_by_path_ret *ret);
-static int remoteDispatchSupportsFeature(
- struct qemud_server *server,
- struct qemud_client *client,
- virConnectPtr conn,
- remote_error *err,
- remote_supports_feature_args *args,
- remote_supports_feature_ret *ret);
+++ /dev/null
-/* 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;
+++ /dev/null
-/* 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,
-},
+++ /dev/null
-#!/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";
- }
- }
-}
+++ /dev/null
-#include <config.h>
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include "remote_protocol.h"
-#include "internal.h"
-#include <arpa/inet.h>
-
-bool_t
-xdr_remote_nonnull_string (XDR *xdrs, remote_nonnull_string *objp)
-{
-
- if (!xdr_string (xdrs, objp, REMOTE_STRING_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_string (XDR *xdrs, remote_string *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_uuid (XDR *xdrs, remote_uuid objp)
-{
-
- if (!xdr_opaque (xdrs, objp, VIR_UUID_BUFLEN))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_domain (XDR *xdrs, remote_nonnull_domain *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- if (!xdr_int (xdrs, &objp->id))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_network (XDR *xdrs, remote_nonnull_network *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_interface (XDR *xdrs, remote_nonnull_interface *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->mac))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_storage_pool (XDR *xdrs, remote_nonnull_storage_pool *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_storage_vol (XDR *xdrs, remote_nonnull_storage_vol *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->key))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_node_device (XDR *xdrs, remote_nonnull_node_device *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_nonnull_secret (XDR *xdrs, remote_nonnull_secret *objp)
-{
-
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- if (!xdr_int (xdrs, &objp->usageType))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->usageID))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain (XDR *xdrs, remote_domain *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_domain), (xdrproc_t) xdr_remote_nonnull_domain))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network (XDR *xdrs, remote_network *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_network), (xdrproc_t) xdr_remote_nonnull_network))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool (XDR *xdrs, remote_storage_pool *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_pool), (xdrproc_t) xdr_remote_nonnull_storage_pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol (XDR *xdrs, remote_storage_vol *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_storage_vol), (xdrproc_t) xdr_remote_nonnull_storage_vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device (XDR *xdrs, remote_node_device *objp)
-{
-
- if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_node_device), (xdrproc_t) xdr_remote_nonnull_node_device))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_error (XDR *xdrs, remote_error *objp)
-{
-
- if (!xdr_int (xdrs, &objp->code))
- return FALSE;
- if (!xdr_int (xdrs, &objp->domain))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->message))
- return FALSE;
- if (!xdr_int (xdrs, &objp->level))
- return FALSE;
- if (!xdr_remote_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->str1))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->str2))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->str3))
- return FALSE;
- if (!xdr_int (xdrs, &objp->int1))
- return FALSE;
- if (!xdr_int (xdrs, &objp->int2))
- return FALSE;
- if (!xdr_remote_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_type (XDR *xdrs, remote_auth_type *objp)
-{
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_vcpu_info (XDR *xdrs, remote_vcpu_info *objp)
-{
-
- if (!xdr_u_int (xdrs, &objp->number))
- return FALSE;
- if (!xdr_int (xdrs, &objp->state))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->cpu_time))
- return FALSE;
- if (!xdr_int (xdrs, &objp->cpu))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_sched_param_value (XDR *xdrs, remote_sched_param_value *objp)
-{
-
- if (!xdr_int (xdrs, &objp->type))
- return FALSE;
- switch (objp->type) {
- case VIR_DOMAIN_SCHED_FIELD_INT:
- return FALSE;
- break;
- case VIR_DOMAIN_SCHED_FIELD_UINT:
- if (!xdr_u_int (xdrs, &objp->remote_sched_param_value_u.ui))
- return FALSE;
- break;
- case VIR_DOMAIN_SCHED_FIELD_LLONG:
- if (!xdr_int64_t (xdrs, &objp->remote_sched_param_value_u.l))
- return FALSE;
- break;
- case VIR_DOMAIN_SCHED_FIELD_ULLONG:
- if (!xdr_uint64_t (xdrs, &objp->remote_sched_param_value_u.ul))
- return FALSE;
- break;
- case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
- if (!xdr_double (xdrs, &objp->remote_sched_param_value_u.d))
- return FALSE;
- break;
- case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
- if (!xdr_int (xdrs, &objp->remote_sched_param_value_u.b))
- return FALSE;
- break;
- default:
- return FALSE;
- }
- return TRUE;
-}
-
-bool_t
-xdr_remote_sched_param (XDR *xdrs, remote_sched_param *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->field))
- return FALSE;
- if (!xdr_remote_sched_param_value (xdrs, &objp->value))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_open_args (XDR *xdrs, remote_open_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_supports_feature_args (XDR *xdrs, remote_supports_feature_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->feature))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_supports_feature_ret (XDR *xdrs, remote_supports_feature_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->supported))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_type_ret (XDR *xdrs, remote_get_type_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_version_ret (XDR *xdrs, remote_get_version_ret *objp)
-{
-
- if (!xdr_int64_t (xdrs, &objp->hv_ver))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_hostname_ret (XDR *xdrs, remote_get_hostname_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->hostname))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_uri_ret (XDR *xdrs, remote_get_uri_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_max_vcpus_args (XDR *xdrs, remote_get_max_vcpus_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_max_vcpus_ret (XDR *xdrs, remote_get_max_vcpus_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->max_vcpus))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_get_info_ret (XDR *xdrs, remote_node_get_info_ret *objp)
-{
- register int32_t *buf;
-
-
- if (xdrs->x_op == XDR_ENCODE) {
- if (!xdr_vector (xdrs, (char *)objp->model, 32,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->memory))
- return FALSE;
- buf = (int32_t*)XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
- if (buf == NULL) {
- if (!xdr_int (xdrs, &objp->cpus))
- return FALSE;
- if (!xdr_int (xdrs, &objp->mhz))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nodes))
- return FALSE;
- if (!xdr_int (xdrs, &objp->sockets))
- return FALSE;
- if (!xdr_int (xdrs, &objp->cores))
- return FALSE;
- if (!xdr_int (xdrs, &objp->threads))
- return FALSE;
- } else {
- (void)IXDR_PUT_INT32(buf, objp->cpus);
- (void)IXDR_PUT_INT32(buf, objp->mhz);
- (void)IXDR_PUT_INT32(buf, objp->nodes);
- (void)IXDR_PUT_INT32(buf, objp->sockets);
- (void)IXDR_PUT_INT32(buf, objp->cores);
- (void)IXDR_PUT_INT32(buf, objp->threads);
- }
- return TRUE;
- } else if (xdrs->x_op == XDR_DECODE) {
- if (!xdr_vector (xdrs, (char *)objp->model, 32,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->memory))
- return FALSE;
- buf = (int32_t*)XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
- if (buf == NULL) {
- if (!xdr_int (xdrs, &objp->cpus))
- return FALSE;
- if (!xdr_int (xdrs, &objp->mhz))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nodes))
- return FALSE;
- if (!xdr_int (xdrs, &objp->sockets))
- return FALSE;
- if (!xdr_int (xdrs, &objp->cores))
- return FALSE;
- if (!xdr_int (xdrs, &objp->threads))
- return FALSE;
- } else {
- objp->cpus = IXDR_GET_INT32(buf);
- objp->mhz = IXDR_GET_INT32(buf);
- objp->nodes = IXDR_GET_INT32(buf);
- objp->sockets = IXDR_GET_INT32(buf);
- objp->cores = IXDR_GET_INT32(buf);
- objp->threads = IXDR_GET_INT32(buf);
- }
- return TRUE;
- }
-
- if (!xdr_vector (xdrs, (char *)objp->model, 32,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->memory))
- return FALSE;
- if (!xdr_int (xdrs, &objp->cpus))
- return FALSE;
- if (!xdr_int (xdrs, &objp->mhz))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nodes))
- return FALSE;
- if (!xdr_int (xdrs, &objp->sockets))
- return FALSE;
- if (!xdr_int (xdrs, &objp->cores))
- return FALSE;
- if (!xdr_int (xdrs, &objp->threads))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_get_capabilities_ret (XDR *xdrs, remote_get_capabilities_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->capabilities))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_get_cells_free_memory_args (XDR *xdrs, remote_node_get_cells_free_memory_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->startCell))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maxCells))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_get_cells_free_memory_ret (XDR *xdrs, remote_node_get_cells_free_memory_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->freeMems.freeMems_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->freeMems.freeMems_len, REMOTE_NODE_MAX_CELLS,
- sizeof (int64_t), (xdrproc_t) xdr_int64_t))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_get_free_memory_ret (XDR *xdrs, remote_node_get_free_memory_ret *objp)
-{
-
- if (!xdr_int64_t (xdrs, &objp->freeMem))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_scheduler_type_args (XDR *xdrs, remote_domain_get_scheduler_type_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_scheduler_type_ret (XDR *xdrs, remote_domain_get_scheduler_type_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->type))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nparams))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_scheduler_parameters_args (XDR *xdrs, remote_domain_get_scheduler_parameters_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nparams))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_scheduler_parameters_ret (XDR *xdrs, remote_domain_get_scheduler_parameters_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->params.params_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
- sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_set_scheduler_parameters_args (XDR *xdrs, remote_domain_set_scheduler_parameters_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->params.params_val;
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX,
- sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_block_stats_args (XDR *xdrs, remote_domain_block_stats_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->path))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_block_stats_ret (XDR *xdrs, remote_domain_block_stats_ret *objp)
-{
-
- if (!xdr_int64_t (xdrs, &objp->rd_req))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->rd_bytes))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->wr_req))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->wr_bytes))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->errs))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_interface_stats_args (XDR *xdrs, remote_domain_interface_stats_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->path))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_interface_stats_ret (XDR *xdrs, remote_domain_interface_stats_ret *objp)
-{
-
- if (!xdr_int64_t (xdrs, &objp->rx_bytes))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->rx_packets))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->rx_errs))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->rx_drop))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->tx_bytes))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->tx_packets))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->tx_errs))
- return FALSE;
- if (!xdr_int64_t (xdrs, &objp->tx_drop))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_block_peek_args (XDR *xdrs, remote_domain_block_peek_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->path))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->offset))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->size))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_block_peek_ret (XDR *xdrs, remote_domain_block_peek_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->buffer.buffer_val;
-
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->buffer.buffer_len, REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_memory_peek_args (XDR *xdrs, remote_domain_memory_peek_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->offset))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->size))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_memory_peek_ret (XDR *xdrs, remote_domain_memory_peek_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->buffer.buffer_val;
-
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->buffer.buffer_len, REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_domains_args (XDR *xdrs, remote_list_domains_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxids))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_domains_ret (XDR *xdrs, remote_list_domains_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->ids.ids_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->ids.ids_len, REMOTE_DOMAIN_ID_LIST_MAX,
- sizeof (int), (xdrproc_t) xdr_int))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_domains_ret (XDR *xdrs, remote_num_of_domains_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_create_xml_args (XDR *xdrs, remote_domain_create_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_create_xml_ret (XDR *xdrs, remote_domain_create_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_id_args (XDR *xdrs, remote_domain_lookup_by_id_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->id))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_id_ret (XDR *xdrs, remote_domain_lookup_by_id_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_uuid_args (XDR *xdrs, remote_domain_lookup_by_uuid_args *objp)
-{
-
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_uuid_ret (XDR *xdrs, remote_domain_lookup_by_uuid_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_name_args (XDR *xdrs, remote_domain_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_lookup_by_name_ret (XDR *xdrs, remote_domain_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_suspend_args (XDR *xdrs, remote_domain_suspend_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_resume_args (XDR *xdrs, remote_domain_resume_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_shutdown_args (XDR *xdrs, remote_domain_shutdown_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_reboot_args (XDR *xdrs, remote_domain_reboot_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_destroy_args (XDR *xdrs, remote_domain_destroy_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_os_type_args (XDR *xdrs, remote_domain_get_os_type_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_os_type_ret (XDR *xdrs, remote_domain_get_os_type_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_max_memory_args (XDR *xdrs, remote_domain_get_max_memory_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_max_memory_ret (XDR *xdrs, remote_domain_get_max_memory_ret *objp)
-{
-
- if (!xdr_uint64_t (xdrs, &objp->memory))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_set_max_memory_args (XDR *xdrs, remote_domain_set_max_memory_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->memory))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_set_memory_args (XDR *xdrs, remote_domain_set_memory_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->memory))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_info_args (XDR *xdrs, remote_domain_get_info_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_info_ret (XDR *xdrs, remote_domain_get_info_ret *objp)
-{
-
- if (!xdr_u_char (xdrs, &objp->state))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->max_mem))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->memory))
- return FALSE;
- if (!xdr_u_short (xdrs, &objp->nr_virt_cpu))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->cpu_time))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_save_args (XDR *xdrs, remote_domain_save_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->to))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_restore_args (XDR *xdrs, remote_domain_restore_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->from))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_core_dump_args (XDR *xdrs, remote_domain_core_dump_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->to))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_dump_xml_args (XDR *xdrs, remote_domain_dump_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_dump_xml_ret (XDR *xdrs, remote_domain_dump_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_prepare_args (XDR *xdrs, remote_domain_migrate_prepare_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->uri_in))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->dname))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->resource))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_prepare_ret (XDR *xdrs, remote_domain_migrate_prepare_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
-
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->uri_out))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_perform_args (XDR *xdrs, remote_domain_migrate_perform_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->dname))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->resource))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_finish_args (XDR *xdrs, remote_domain_migrate_finish_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->dname))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_finish_ret (XDR *xdrs, remote_domain_migrate_finish_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->ddom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_prepare2_args (XDR *xdrs, remote_domain_migrate_prepare2_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->uri_in))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->dname))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->resource))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->dom_xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_prepare2_ret (XDR *xdrs, remote_domain_migrate_prepare2_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
-
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->uri_out))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_finish2_args (XDR *xdrs, remote_domain_migrate_finish2_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val;
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->dname))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->uri))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_int (xdrs, &objp->retcode))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_migrate_finish2_ret (XDR *xdrs, remote_domain_migrate_finish2_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->ddom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_domains_args (XDR *xdrs, remote_list_defined_domains_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_domains_ret (XDR *xdrs, remote_list_defined_domains_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DOMAIN_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_defined_domains_ret (XDR *xdrs, remote_num_of_defined_domains_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_create_args (XDR *xdrs, remote_domain_create_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_define_xml_args (XDR *xdrs, remote_domain_define_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_define_xml_ret (XDR *xdrs, remote_domain_define_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_undefine_args (XDR *xdrs, remote_domain_undefine_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_set_vcpus_args (XDR *xdrs, remote_domain_set_vcpus_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nvcpus))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_pin_vcpu_args (XDR *xdrs, remote_domain_pin_vcpu_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->cpumap.cpumap_val;
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->vcpu))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cpumap.cpumap_len, REMOTE_CPUMAP_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_vcpus_args (XDR *xdrs, remote_domain_get_vcpus_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maxinfo))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maplen))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_vcpus_ret (XDR *xdrs, remote_domain_get_vcpus_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->info.info_val;
- char **objp_cpp1 = (char **) (void *) &objp->cpumaps.cpumaps_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->info.info_len, REMOTE_VCPUINFO_MAX,
- sizeof (remote_vcpu_info), (xdrproc_t) xdr_remote_vcpu_info))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp1, (u_int *) &objp->cpumaps.cpumaps_len, REMOTE_CPUMAPS_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_max_vcpus_args (XDR *xdrs, remote_domain_get_max_vcpus_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_max_vcpus_ret (XDR *xdrs, remote_domain_get_max_vcpus_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_security_label_args (XDR *xdrs, remote_domain_get_security_label_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_security_label_ret (XDR *xdrs, remote_domain_get_security_label_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->label.label_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->label.label_len, REMOTE_SECURITY_LABEL_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- if (!xdr_int (xdrs, &objp->enforcing))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_get_security_model_ret (XDR *xdrs, remote_node_get_security_model_ret *objp)
-{
- char **objp_cpp1 = (char **) (void *) &objp->doi.doi_val;
- char **objp_cpp0 = (char **) (void *) &objp->model.model_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->model.model_len, REMOTE_SECURITY_MODEL_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp1, (u_int *) &objp->doi.doi_len, REMOTE_SECURITY_DOI_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_attach_device_args (XDR *xdrs, remote_domain_attach_device_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_detach_device_args (XDR *xdrs, remote_domain_detach_device_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_autostart_args (XDR *xdrs, remote_domain_get_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_get_autostart_ret (XDR *xdrs, remote_domain_get_autostart_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_set_autostart_args (XDR *xdrs, remote_domain_set_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_networks_ret (XDR *xdrs, remote_num_of_networks_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_networks_args (XDR *xdrs, remote_list_networks_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_networks_ret (XDR *xdrs, remote_list_networks_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_defined_networks_ret (XDR *xdrs, remote_num_of_defined_networks_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_networks_args (XDR *xdrs, remote_list_defined_networks_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_networks_ret (XDR *xdrs, remote_list_defined_networks_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_lookup_by_uuid_args (XDR *xdrs, remote_network_lookup_by_uuid_args *objp)
-{
-
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_lookup_by_uuid_ret (XDR *xdrs, remote_network_lookup_by_uuid_ret *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_lookup_by_name_args (XDR *xdrs, remote_network_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_lookup_by_name_ret (XDR *xdrs, remote_network_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_create_xml_args (XDR *xdrs, remote_network_create_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_create_xml_ret (XDR *xdrs, remote_network_create_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_define_xml_args (XDR *xdrs, remote_network_define_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_define_xml_ret (XDR *xdrs, remote_network_define_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_undefine_args (XDR *xdrs, remote_network_undefine_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_create_args (XDR *xdrs, remote_network_create_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_destroy_args (XDR *xdrs, remote_network_destroy_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_dump_xml_args (XDR *xdrs, remote_network_dump_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_dump_xml_ret (XDR *xdrs, remote_network_dump_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_get_bridge_name_args (XDR *xdrs, remote_network_get_bridge_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_get_bridge_name_ret (XDR *xdrs, remote_network_get_bridge_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_get_autostart_args (XDR *xdrs, remote_network_get_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_get_autostart_ret (XDR *xdrs, remote_network_get_autostart_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_network_set_autostart_args (XDR *xdrs, remote_network_set_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_network (xdrs, &objp->net))
- return FALSE;
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_interfaces_ret (XDR *xdrs, remote_num_of_interfaces_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_interfaces_args (XDR *xdrs, remote_list_interfaces_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_interfaces_ret (XDR *xdrs, remote_list_interfaces_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_INTERFACE_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_defined_interfaces_ret (XDR *xdrs, remote_num_of_defined_interfaces_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_interfaces_args (XDR *xdrs, remote_list_defined_interfaces_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_interfaces_ret (XDR *xdrs, remote_list_defined_interfaces_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_lookup_by_name_args (XDR *xdrs, remote_interface_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_lookup_by_name_ret (XDR *xdrs, remote_interface_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_lookup_by_mac_string_args (XDR *xdrs, remote_interface_lookup_by_mac_string_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->mac))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_lookup_by_mac_string_ret (XDR *xdrs, remote_interface_lookup_by_mac_string_ret *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_get_xml_desc_args (XDR *xdrs, remote_interface_get_xml_desc_args *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_get_xml_desc_ret (XDR *xdrs, remote_interface_get_xml_desc_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_define_xml_args (XDR *xdrs, remote_interface_define_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_define_xml_ret (XDR *xdrs, remote_interface_define_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_undefine_args (XDR *xdrs, remote_interface_undefine_args *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_create_args (XDR *xdrs, remote_interface_create_args *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_interface_destroy_args (XDR *xdrs, remote_interface_destroy_args *objp)
-{
-
- if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_list_ret (XDR *xdrs, remote_auth_list_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->types.types_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->types.types_len, REMOTE_AUTH_TYPE_LIST_MAX,
- sizeof (remote_auth_type), (xdrproc_t) xdr_remote_auth_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_sasl_init_ret (XDR *xdrs, remote_auth_sasl_init_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->mechlist))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_sasl_start_args (XDR *xdrs, remote_auth_sasl_start_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->mech))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nil))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_sasl_start_ret (XDR *xdrs, remote_auth_sasl_start_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
-
- if (!xdr_int (xdrs, &objp->complete))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nil))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_sasl_step_args (XDR *xdrs, remote_auth_sasl_step_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
-
- if (!xdr_int (xdrs, &objp->nil))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_sasl_step_ret (XDR *xdrs, remote_auth_sasl_step_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->data.data_val;
-
- if (!xdr_int (xdrs, &objp->complete))
- return FALSE;
- if (!xdr_int (xdrs, &objp->nil))
- return FALSE;
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->data.data_len, REMOTE_AUTH_SASL_DATA_MAX,
- sizeof (char), (xdrproc_t) xdr_char))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_auth_polkit_ret (XDR *xdrs, remote_auth_polkit_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->complete))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_storage_pools_ret (XDR *xdrs, remote_num_of_storage_pools_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_storage_pools_args (XDR *xdrs, remote_list_storage_pools_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_storage_pools_ret (XDR *xdrs, remote_list_storage_pools_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_defined_storage_pools_ret (XDR *xdrs, remote_num_of_defined_storage_pools_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_storage_pools_args (XDR *xdrs, remote_list_defined_storage_pools_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_defined_storage_pools_ret (XDR *xdrs, remote_list_defined_storage_pools_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_POOL_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_find_storage_pool_sources_args (XDR *xdrs, remote_find_storage_pool_sources_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->type))
- return FALSE;
- if (!xdr_remote_string (xdrs, &objp->srcSpec))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_find_storage_pool_sources_ret (XDR *xdrs, remote_find_storage_pool_sources_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_uuid_args (XDR *xdrs, remote_storage_pool_lookup_by_uuid_args *objp)
-{
-
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *xdrs, remote_storage_pool_lookup_by_uuid_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_name_args (XDR *xdrs, remote_storage_pool_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_name_ret (XDR *xdrs, remote_storage_pool_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_volume_args (XDR *xdrs, remote_storage_pool_lookup_by_volume_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_lookup_by_volume_ret (XDR *xdrs, remote_storage_pool_lookup_by_volume_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_create_xml_args (XDR *xdrs, remote_storage_pool_create_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_create_xml_ret (XDR *xdrs, remote_storage_pool_create_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_define_xml_args (XDR *xdrs, remote_storage_pool_define_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_define_xml_ret (XDR *xdrs, remote_storage_pool_define_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_build_args (XDR *xdrs, remote_storage_pool_build_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_undefine_args (XDR *xdrs, remote_storage_pool_undefine_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_create_args (XDR *xdrs, remote_storage_pool_create_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_destroy_args (XDR *xdrs, remote_storage_pool_destroy_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_delete_args (XDR *xdrs, remote_storage_pool_delete_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_refresh_args (XDR *xdrs, remote_storage_pool_refresh_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_dump_xml_args (XDR *xdrs, remote_storage_pool_dump_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_dump_xml_ret (XDR *xdrs, remote_storage_pool_dump_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_get_info_args (XDR *xdrs, remote_storage_pool_get_info_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_get_info_ret (XDR *xdrs, remote_storage_pool_get_info_ret *objp)
-{
-
- if (!xdr_u_char (xdrs, &objp->state))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->capacity))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->allocation))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->available))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_get_autostart_args (XDR *xdrs, remote_storage_pool_get_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_get_autostart_ret (XDR *xdrs, remote_storage_pool_get_autostart_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_set_autostart_args (XDR *xdrs, remote_storage_pool_set_autostart_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_int (xdrs, &objp->autostart))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_num_of_volumes_args (XDR *xdrs, remote_storage_pool_num_of_volumes_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_num_of_volumes_ret (XDR *xdrs, remote_storage_pool_num_of_volumes_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_list_volumes_args (XDR *xdrs, remote_storage_pool_list_volumes_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_pool_list_volumes_ret (XDR *xdrs, remote_storage_pool_list_volumes_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_STORAGE_VOL_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_name_args (XDR *xdrs, remote_storage_vol_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_name_ret (XDR *xdrs, remote_storage_vol_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_key_args (XDR *xdrs, remote_storage_vol_lookup_by_key_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->key))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_key_ret (XDR *xdrs, remote_storage_vol_lookup_by_key_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_path_args (XDR *xdrs, remote_storage_vol_lookup_by_path_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->path))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_lookup_by_path_ret (XDR *xdrs, remote_storage_vol_lookup_by_path_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_create_xml_args (XDR *xdrs, remote_storage_vol_create_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_create_xml_ret (XDR *xdrs, remote_storage_vol_create_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_create_xml_from_args (XDR *xdrs, remote_storage_vol_create_xml_from_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->clonevol))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_create_xml_from_ret (XDR *xdrs, remote_storage_vol_create_xml_from_ret *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_delete_args (XDR *xdrs, remote_storage_vol_delete_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_dump_xml_args (XDR *xdrs, remote_storage_vol_dump_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_dump_xml_ret (XDR *xdrs, remote_storage_vol_dump_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_get_info_args (XDR *xdrs, remote_storage_vol_get_info_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_get_info_ret (XDR *xdrs, remote_storage_vol_get_info_ret *objp)
-{
-
- if (!xdr_char (xdrs, &objp->type))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->capacity))
- return FALSE;
- if (!xdr_uint64_t (xdrs, &objp->allocation))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_get_path_args (XDR *xdrs, remote_storage_vol_get_path_args *objp)
-{
-
- if (!xdr_remote_nonnull_storage_vol (xdrs, &objp->vol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_storage_vol_get_path_ret (XDR *xdrs, remote_storage_vol_get_path_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_num_of_devices_args (XDR *xdrs, remote_node_num_of_devices_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->cap))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_num_of_devices_ret (XDR *xdrs, remote_node_num_of_devices_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_list_devices_args (XDR *xdrs, remote_node_list_devices_args *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->cap))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_list_devices_ret (XDR *xdrs, remote_node_list_devices_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NODE_DEVICE_NAME_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_lookup_by_name_args (XDR *xdrs, remote_node_device_lookup_by_name_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_lookup_by_name_ret (XDR *xdrs, remote_node_device_lookup_by_name_ret *objp)
-{
-
- if (!xdr_remote_nonnull_node_device (xdrs, &objp->dev))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_dump_xml_args (XDR *xdrs, remote_node_device_dump_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_dump_xml_ret (XDR *xdrs, remote_node_device_dump_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_get_parent_args (XDR *xdrs, remote_node_device_get_parent_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_get_parent_ret (XDR *xdrs, remote_node_device_get_parent_ret *objp)
-{
-
- if (!xdr_remote_string (xdrs, &objp->parent))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_num_of_caps_args (XDR *xdrs, remote_node_device_num_of_caps_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_num_of_caps_ret (XDR *xdrs, remote_node_device_num_of_caps_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_list_caps_args (XDR *xdrs, remote_node_device_list_caps_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- if (!xdr_int (xdrs, &objp->maxnames))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_list_caps_ret (XDR *xdrs, remote_node_device_list_caps_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NODE_DEVICE_CAPS_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_dettach_args (XDR *xdrs, remote_node_device_dettach_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_re_attach_args (XDR *xdrs, remote_node_device_re_attach_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_reset_args (XDR *xdrs, remote_node_device_reset_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_create_xml_args (XDR *xdrs, remote_node_device_create_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc))
- return FALSE;
- if (!xdr_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_create_xml_ret (XDR *xdrs, remote_node_device_create_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_node_device (xdrs, &objp->dev))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_node_device_destroy_args (XDR *xdrs, remote_node_device_destroy_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->name))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_events_register_ret (XDR *xdrs, remote_domain_events_register_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->cb_registered))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_events_deregister_ret (XDR *xdrs, remote_domain_events_deregister_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->cb_registered))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_event_msg (XDR *xdrs, remote_domain_event_msg *objp)
-{
-
- if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
- return FALSE;
- if (!xdr_int (xdrs, &objp->event))
- return FALSE;
- if (!xdr_int (xdrs, &objp->detail))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_xml_from_native_args (XDR *xdrs, remote_domain_xml_from_native_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->nativeFormat))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->nativeConfig))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_xml_from_native_ret (XDR *xdrs, remote_domain_xml_from_native_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->domainXml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_xml_to_native_args (XDR *xdrs, remote_domain_xml_to_native_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->nativeFormat))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->domainXml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_domain_xml_to_native_ret (XDR *xdrs, remote_domain_xml_to_native_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->nativeConfig))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_num_of_secrets_ret (XDR *xdrs, remote_num_of_secrets_ret *objp)
-{
-
- if (!xdr_int (xdrs, &objp->num))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_secrets_args (XDR *xdrs, remote_list_secrets_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->maxuuids))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_list_secrets_ret (XDR *xdrs, remote_list_secrets_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->uuids.uuids_val;
-
- if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->uuids.uuids_len, REMOTE_SECRET_UUID_LIST_MAX,
- sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_lookup_by_uuid_args (XDR *xdrs, remote_secret_lookup_by_uuid_args *objp)
-{
-
- if (!xdr_remote_uuid (xdrs, objp->uuid))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_lookup_by_uuid_ret (XDR *xdrs, remote_secret_lookup_by_uuid_ret *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_define_xml_args (XDR *xdrs, remote_secret_define_xml_args *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_define_xml_ret (XDR *xdrs, remote_secret_define_xml_ret *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_get_xml_desc_args (XDR *xdrs, remote_secret_get_xml_desc_args *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_get_xml_desc_ret (XDR *xdrs, remote_secret_get_xml_desc_ret *objp)
-{
-
- if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_set_value_args (XDR *xdrs, remote_secret_set_value_args *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->value.value_val;
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->value.value_len, REMOTE_SECRET_VALUE_MAX))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_get_value_args (XDR *xdrs, remote_secret_get_value_args *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->flags))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_get_value_ret (XDR *xdrs, remote_secret_get_value_ret *objp)
-{
- char **objp_cpp0 = (char **) (void *) &objp->value.value_val;
-
- if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->value.value_len, REMOTE_SECRET_VALUE_MAX))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_undefine_args (XDR *xdrs, remote_secret_undefine_args *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_lookup_by_usage_args (XDR *xdrs, remote_secret_lookup_by_usage_args *objp)
-{
-
- if (!xdr_int (xdrs, &objp->usageType))
- return FALSE;
- if (!xdr_remote_nonnull_string (xdrs, &objp->usageID))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_secret_lookup_by_usage_ret (XDR *xdrs, remote_secret_lookup_by_usage_ret *objp)
-{
-
- if (!xdr_remote_nonnull_secret (xdrs, &objp->secret))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
-{
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_message_type (XDR *xdrs, remote_message_type *objp)
-{
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_message_status (XDR *xdrs, remote_message_status *objp)
-{
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_remote_message_header (XDR *xdrs, remote_message_header *objp)
-{
-
- if (!xdr_u_int (xdrs, &objp->prog))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->vers))
- return FALSE;
- if (!xdr_remote_procedure (xdrs, &objp->proc))
- return FALSE;
- if (!xdr_remote_message_type (xdrs, &objp->type))
- return FALSE;
- if (!xdr_u_int (xdrs, &objp->serial))
- return FALSE;
- if (!xdr_remote_message_status (xdrs, &objp->status))
- return FALSE;
- return TRUE;
-}
+++ /dev/null
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#ifndef _RP_H_RPCGEN
-#define _RP_H_RPCGEN
-
-#include <rpc/rpc.h>
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "internal.h"
-#include <arpa/inet.h>
-#define REMOTE_MESSAGE_MAX 262144
-#define REMOTE_STRING_MAX 65536
-
-typedef char *remote_nonnull_string;
-
-typedef remote_nonnull_string *remote_string;
-#define REMOTE_DOMAIN_ID_LIST_MAX 16384
-#define REMOTE_DOMAIN_NAME_LIST_MAX 1024
-#define REMOTE_CPUMAP_MAX 256
-#define REMOTE_VCPUINFO_MAX 2048
-#define REMOTE_CPUMAPS_MAX 16384
-#define REMOTE_MIGRATE_COOKIE_MAX 256
-#define REMOTE_NETWORK_NAME_LIST_MAX 256
-#define REMOTE_INTERFACE_NAME_LIST_MAX 256
-#define REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX 256
-#define REMOTE_STORAGE_POOL_NAME_LIST_MAX 256
-#define REMOTE_STORAGE_VOL_NAME_LIST_MAX 1024
-#define REMOTE_NODE_DEVICE_NAME_LIST_MAX 16384
-#define REMOTE_NODE_DEVICE_CAPS_LIST_MAX 16384
-#define REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX 16
-#define REMOTE_NODE_MAX_CELLS 1024
-#define REMOTE_AUTH_SASL_DATA_MAX 65536
-#define REMOTE_AUTH_TYPE_LIST_MAX 20
-#define REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX 65536
-#define REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX 65536
-#define REMOTE_SECURITY_MODEL_MAX VIR_SECURITY_MODEL_BUFLEN
-#define REMOTE_SECURITY_LABEL_MAX VIR_SECURITY_LABEL_BUFLEN
-#define REMOTE_SECURITY_DOI_MAX VIR_SECURITY_DOI_BUFLEN
-#define REMOTE_SECRET_VALUE_MAX 65536
-#define REMOTE_SECRET_UUID_LIST_MAX 16384
-
-typedef char remote_uuid[VIR_UUID_BUFLEN];
-
-struct remote_nonnull_domain {
- remote_nonnull_string name;
- remote_uuid uuid;
- int id;
-};
-typedef struct remote_nonnull_domain remote_nonnull_domain;
-
-struct remote_nonnull_network {
- remote_nonnull_string name;
- remote_uuid uuid;
-};
-typedef struct remote_nonnull_network remote_nonnull_network;
-
-struct remote_nonnull_interface {
- remote_nonnull_string name;
- remote_nonnull_string mac;
-};
-typedef struct remote_nonnull_interface remote_nonnull_interface;
-
-struct remote_nonnull_storage_pool {
- remote_nonnull_string name;
- remote_uuid uuid;
-};
-typedef struct remote_nonnull_storage_pool remote_nonnull_storage_pool;
-
-struct remote_nonnull_storage_vol {
- remote_nonnull_string pool;
- remote_nonnull_string name;
- remote_nonnull_string key;
-};
-typedef struct remote_nonnull_storage_vol remote_nonnull_storage_vol;
-
-struct remote_nonnull_node_device {
- remote_nonnull_string name;
-};
-typedef struct remote_nonnull_node_device remote_nonnull_node_device;
-
-struct remote_nonnull_secret {
- remote_uuid uuid;
- int usageType;
- remote_nonnull_string usageID;
-};
-typedef struct remote_nonnull_secret remote_nonnull_secret;
-
-typedef remote_nonnull_domain *remote_domain;
-
-typedef remote_nonnull_network *remote_network;
-
-typedef remote_nonnull_storage_pool *remote_storage_pool;
-
-typedef remote_nonnull_storage_vol *remote_storage_vol;
-
-typedef remote_nonnull_node_device *remote_node_device;
-
-struct remote_error {
- int code;
- int domain;
- remote_string message;
- int level;
- remote_domain dom;
- remote_string str1;
- remote_string str2;
- remote_string str3;
- int int1;
- int int2;
- remote_network net;
-};
-typedef struct remote_error remote_error;
-
-enum remote_auth_type {
- REMOTE_AUTH_NONE = 0,
- REMOTE_AUTH_SASL = 1,
- REMOTE_AUTH_POLKIT = 2,
-};
-typedef enum remote_auth_type remote_auth_type;
-
-struct remote_vcpu_info {
- u_int number;
- int state;
- uint64_t cpu_time;
- int cpu;
-};
-typedef struct remote_vcpu_info remote_vcpu_info;
-
-struct remote_sched_param_value {
- int type;
- union {
- int i;
- u_int ui;
- int64_t l;
- uint64_t ul;
- double d;
- int b;
- } remote_sched_param_value_u;
-};
-typedef struct remote_sched_param_value remote_sched_param_value;
-
-struct remote_sched_param {
- remote_nonnull_string field;
- remote_sched_param_value value;
-};
-typedef struct remote_sched_param remote_sched_param;
-
-struct remote_open_args {
- remote_string name;
- int flags;
-};
-typedef struct remote_open_args remote_open_args;
-
-struct remote_supports_feature_args {
- int feature;
-};
-typedef struct remote_supports_feature_args remote_supports_feature_args;
-
-struct remote_supports_feature_ret {
- int supported;
-};
-typedef struct remote_supports_feature_ret remote_supports_feature_ret;
-
-struct remote_get_type_ret {
- remote_nonnull_string type;
-};
-typedef struct remote_get_type_ret remote_get_type_ret;
-
-struct remote_get_version_ret {
- int64_t hv_ver;
-};
-typedef struct remote_get_version_ret remote_get_version_ret;
-
-struct remote_get_hostname_ret {
- remote_nonnull_string hostname;
-};
-typedef struct remote_get_hostname_ret remote_get_hostname_ret;
-
-struct remote_get_uri_ret {
- remote_nonnull_string uri;
-};
-typedef struct remote_get_uri_ret remote_get_uri_ret;
-
-struct remote_get_max_vcpus_args {
- remote_string type;
-};
-typedef struct remote_get_max_vcpus_args remote_get_max_vcpus_args;
-
-struct remote_get_max_vcpus_ret {
- int max_vcpus;
-};
-typedef struct remote_get_max_vcpus_ret remote_get_max_vcpus_ret;
-
-struct remote_node_get_info_ret {
- char model[32];
- int64_t memory;
- int cpus;
- int mhz;
- int nodes;
- int sockets;
- int cores;
- int threads;
-};
-typedef struct remote_node_get_info_ret remote_node_get_info_ret;
-
-struct remote_get_capabilities_ret {
- remote_nonnull_string capabilities;
-};
-typedef struct remote_get_capabilities_ret remote_get_capabilities_ret;
-
-struct remote_node_get_cells_free_memory_args {
- int startCell;
- int maxCells;
-};
-typedef struct remote_node_get_cells_free_memory_args remote_node_get_cells_free_memory_args;
-
-struct remote_node_get_cells_free_memory_ret {
- struct {
- u_int freeMems_len;
- int64_t *freeMems_val;
- } freeMems;
-};
-typedef struct remote_node_get_cells_free_memory_ret remote_node_get_cells_free_memory_ret;
-
-struct remote_node_get_free_memory_ret {
- int64_t freeMem;
-};
-typedef struct remote_node_get_free_memory_ret remote_node_get_free_memory_ret;
-
-struct remote_domain_get_scheduler_type_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_scheduler_type_args remote_domain_get_scheduler_type_args;
-
-struct remote_domain_get_scheduler_type_ret {
- remote_nonnull_string type;
- int nparams;
-};
-typedef struct remote_domain_get_scheduler_type_ret remote_domain_get_scheduler_type_ret;
-
-struct remote_domain_get_scheduler_parameters_args {
- remote_nonnull_domain dom;
- int nparams;
-};
-typedef struct remote_domain_get_scheduler_parameters_args remote_domain_get_scheduler_parameters_args;
-
-struct remote_domain_get_scheduler_parameters_ret {
- struct {
- u_int params_len;
- remote_sched_param *params_val;
- } params;
-};
-typedef struct remote_domain_get_scheduler_parameters_ret remote_domain_get_scheduler_parameters_ret;
-
-struct remote_domain_set_scheduler_parameters_args {
- remote_nonnull_domain dom;
- struct {
- u_int params_len;
- remote_sched_param *params_val;
- } params;
-};
-typedef struct remote_domain_set_scheduler_parameters_args remote_domain_set_scheduler_parameters_args;
-
-struct remote_domain_block_stats_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
-};
-typedef struct remote_domain_block_stats_args remote_domain_block_stats_args;
-
-struct remote_domain_block_stats_ret {
- int64_t rd_req;
- int64_t rd_bytes;
- int64_t wr_req;
- int64_t wr_bytes;
- int64_t errs;
-};
-typedef struct remote_domain_block_stats_ret remote_domain_block_stats_ret;
-
-struct remote_domain_interface_stats_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
-};
-typedef struct remote_domain_interface_stats_args remote_domain_interface_stats_args;
-
-struct remote_domain_interface_stats_ret {
- int64_t rx_bytes;
- int64_t rx_packets;
- int64_t rx_errs;
- int64_t rx_drop;
- int64_t tx_bytes;
- int64_t tx_packets;
- int64_t tx_errs;
- int64_t tx_drop;
-};
-typedef struct remote_domain_interface_stats_ret remote_domain_interface_stats_ret;
-
-struct remote_domain_block_peek_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
- uint64_t offset;
- u_int size;
- u_int flags;
-};
-typedef struct remote_domain_block_peek_args remote_domain_block_peek_args;
-
-struct remote_domain_block_peek_ret {
- struct {
- u_int buffer_len;
- char *buffer_val;
- } buffer;
-};
-typedef struct remote_domain_block_peek_ret remote_domain_block_peek_ret;
-
-struct remote_domain_memory_peek_args {
- remote_nonnull_domain dom;
- uint64_t offset;
- u_int size;
- u_int flags;
-};
-typedef struct remote_domain_memory_peek_args remote_domain_memory_peek_args;
-
-struct remote_domain_memory_peek_ret {
- struct {
- u_int buffer_len;
- char *buffer_val;
- } buffer;
-};
-typedef struct remote_domain_memory_peek_ret remote_domain_memory_peek_ret;
-
-struct remote_list_domains_args {
- int maxids;
-};
-typedef struct remote_list_domains_args remote_list_domains_args;
-
-struct remote_list_domains_ret {
- struct {
- u_int ids_len;
- int *ids_val;
- } ids;
-};
-typedef struct remote_list_domains_ret remote_list_domains_ret;
-
-struct remote_num_of_domains_ret {
- int num;
-};
-typedef struct remote_num_of_domains_ret remote_num_of_domains_ret;
-
-struct remote_domain_create_xml_args {
- remote_nonnull_string xml_desc;
- int flags;
-};
-typedef struct remote_domain_create_xml_args remote_domain_create_xml_args;
-
-struct remote_domain_create_xml_ret {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_create_xml_ret remote_domain_create_xml_ret;
-
-struct remote_domain_lookup_by_id_args {
- int id;
-};
-typedef struct remote_domain_lookup_by_id_args remote_domain_lookup_by_id_args;
-
-struct remote_domain_lookup_by_id_ret {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_lookup_by_id_ret remote_domain_lookup_by_id_ret;
-
-struct remote_domain_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-typedef struct remote_domain_lookup_by_uuid_args remote_domain_lookup_by_uuid_args;
-
-struct remote_domain_lookup_by_uuid_ret {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_lookup_by_uuid_ret remote_domain_lookup_by_uuid_ret;
-
-struct remote_domain_lookup_by_name_args {
- remote_nonnull_string name;
-};
-typedef struct remote_domain_lookup_by_name_args remote_domain_lookup_by_name_args;
-
-struct remote_domain_lookup_by_name_ret {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_lookup_by_name_ret remote_domain_lookup_by_name_ret;
-
-struct remote_domain_suspend_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_suspend_args remote_domain_suspend_args;
-
-struct remote_domain_resume_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_resume_args remote_domain_resume_args;
-
-struct remote_domain_shutdown_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_shutdown_args remote_domain_shutdown_args;
-
-struct remote_domain_reboot_args {
- remote_nonnull_domain dom;
- int flags;
-};
-typedef struct remote_domain_reboot_args remote_domain_reboot_args;
-
-struct remote_domain_destroy_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_destroy_args remote_domain_destroy_args;
-
-struct remote_domain_get_os_type_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_os_type_args remote_domain_get_os_type_args;
-
-struct remote_domain_get_os_type_ret {
- remote_nonnull_string type;
-};
-typedef struct remote_domain_get_os_type_ret remote_domain_get_os_type_ret;
-
-struct remote_domain_get_max_memory_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_max_memory_args remote_domain_get_max_memory_args;
-
-struct remote_domain_get_max_memory_ret {
- uint64_t memory;
-};
-typedef struct remote_domain_get_max_memory_ret remote_domain_get_max_memory_ret;
-
-struct remote_domain_set_max_memory_args {
- remote_nonnull_domain dom;
- uint64_t memory;
-};
-typedef struct remote_domain_set_max_memory_args remote_domain_set_max_memory_args;
-
-struct remote_domain_set_memory_args {
- remote_nonnull_domain dom;
- uint64_t memory;
-};
-typedef struct remote_domain_set_memory_args remote_domain_set_memory_args;
-
-struct remote_domain_get_info_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_info_args remote_domain_get_info_args;
-
-struct remote_domain_get_info_ret {
- u_char state;
- uint64_t max_mem;
- uint64_t memory;
- u_short nr_virt_cpu;
- uint64_t cpu_time;
-};
-typedef struct remote_domain_get_info_ret remote_domain_get_info_ret;
-
-struct remote_domain_save_args {
- remote_nonnull_domain dom;
- remote_nonnull_string to;
-};
-typedef struct remote_domain_save_args remote_domain_save_args;
-
-struct remote_domain_restore_args {
- remote_nonnull_string from;
-};
-typedef struct remote_domain_restore_args remote_domain_restore_args;
-
-struct remote_domain_core_dump_args {
- remote_nonnull_domain dom;
- remote_nonnull_string to;
- int flags;
-};
-typedef struct remote_domain_core_dump_args remote_domain_core_dump_args;
-
-struct remote_domain_dump_xml_args {
- remote_nonnull_domain dom;
- int flags;
-};
-typedef struct remote_domain_dump_xml_args remote_domain_dump_xml_args;
-
-struct remote_domain_dump_xml_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_domain_dump_xml_ret remote_domain_dump_xml_ret;
-
-struct remote_domain_migrate_prepare_args {
- remote_string uri_in;
- uint64_t flags;
- remote_string dname;
- uint64_t resource;
-};
-typedef struct remote_domain_migrate_prepare_args remote_domain_migrate_prepare_args;
-
-struct remote_domain_migrate_prepare_ret {
- struct {
- u_int cookie_len;
- char *cookie_val;
- } cookie;
- remote_string uri_out;
-};
-typedef struct remote_domain_migrate_prepare_ret remote_domain_migrate_prepare_ret;
-
-struct remote_domain_migrate_perform_args {
- remote_nonnull_domain dom;
- struct {
- u_int cookie_len;
- char *cookie_val;
- } cookie;
- remote_nonnull_string uri;
- uint64_t flags;
- remote_string dname;
- uint64_t resource;
-};
-typedef struct remote_domain_migrate_perform_args remote_domain_migrate_perform_args;
-
-struct remote_domain_migrate_finish_args {
- remote_nonnull_string dname;
- struct {
- u_int cookie_len;
- char *cookie_val;
- } cookie;
- remote_nonnull_string uri;
- uint64_t flags;
-};
-typedef struct remote_domain_migrate_finish_args remote_domain_migrate_finish_args;
-
-struct remote_domain_migrate_finish_ret {
- remote_nonnull_domain ddom;
-};
-typedef struct remote_domain_migrate_finish_ret remote_domain_migrate_finish_ret;
-
-struct remote_domain_migrate_prepare2_args {
- remote_string uri_in;
- uint64_t flags;
- remote_string dname;
- uint64_t resource;
- remote_nonnull_string dom_xml;
-};
-typedef struct remote_domain_migrate_prepare2_args remote_domain_migrate_prepare2_args;
-
-struct remote_domain_migrate_prepare2_ret {
- struct {
- u_int cookie_len;
- char *cookie_val;
- } cookie;
- remote_string uri_out;
-};
-typedef struct remote_domain_migrate_prepare2_ret remote_domain_migrate_prepare2_ret;
-
-struct remote_domain_migrate_finish2_args {
- remote_nonnull_string dname;
- struct {
- u_int cookie_len;
- char *cookie_val;
- } cookie;
- remote_nonnull_string uri;
- uint64_t flags;
- int retcode;
-};
-typedef struct remote_domain_migrate_finish2_args remote_domain_migrate_finish2_args;
-
-struct remote_domain_migrate_finish2_ret {
- remote_nonnull_domain ddom;
-};
-typedef struct remote_domain_migrate_finish2_ret remote_domain_migrate_finish2_ret;
-
-struct remote_list_defined_domains_args {
- int maxnames;
-};
-typedef struct remote_list_defined_domains_args remote_list_defined_domains_args;
-
-struct remote_list_defined_domains_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_defined_domains_ret remote_list_defined_domains_ret;
-
-struct remote_num_of_defined_domains_ret {
- int num;
-};
-typedef struct remote_num_of_defined_domains_ret remote_num_of_defined_domains_ret;
-
-struct remote_domain_create_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_create_args remote_domain_create_args;
-
-struct remote_domain_define_xml_args {
- remote_nonnull_string xml;
-};
-typedef struct remote_domain_define_xml_args remote_domain_define_xml_args;
-
-struct remote_domain_define_xml_ret {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_define_xml_ret remote_domain_define_xml_ret;
-
-struct remote_domain_undefine_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_undefine_args remote_domain_undefine_args;
-
-struct remote_domain_set_vcpus_args {
- remote_nonnull_domain dom;
- int nvcpus;
-};
-typedef struct remote_domain_set_vcpus_args remote_domain_set_vcpus_args;
-
-struct remote_domain_pin_vcpu_args {
- remote_nonnull_domain dom;
- int vcpu;
- struct {
- u_int cpumap_len;
- char *cpumap_val;
- } cpumap;
-};
-typedef struct remote_domain_pin_vcpu_args remote_domain_pin_vcpu_args;
-
-struct remote_domain_get_vcpus_args {
- remote_nonnull_domain dom;
- int maxinfo;
- int maplen;
-};
-typedef struct remote_domain_get_vcpus_args remote_domain_get_vcpus_args;
-
-struct remote_domain_get_vcpus_ret {
- struct {
- u_int info_len;
- remote_vcpu_info *info_val;
- } info;
- struct {
- u_int cpumaps_len;
- char *cpumaps_val;
- } cpumaps;
-};
-typedef struct remote_domain_get_vcpus_ret remote_domain_get_vcpus_ret;
-
-struct remote_domain_get_max_vcpus_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_max_vcpus_args remote_domain_get_max_vcpus_args;
-
-struct remote_domain_get_max_vcpus_ret {
- int num;
-};
-typedef struct remote_domain_get_max_vcpus_ret remote_domain_get_max_vcpus_ret;
-
-struct remote_domain_get_security_label_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_security_label_args remote_domain_get_security_label_args;
-
-struct remote_domain_get_security_label_ret {
- struct {
- u_int label_len;
- char *label_val;
- } label;
- int enforcing;
-};
-typedef struct remote_domain_get_security_label_ret remote_domain_get_security_label_ret;
-
-struct remote_node_get_security_model_ret {
- struct {
- u_int model_len;
- char *model_val;
- } model;
- struct {
- u_int doi_len;
- char *doi_val;
- } doi;
-};
-typedef struct remote_node_get_security_model_ret remote_node_get_security_model_ret;
-
-struct remote_domain_attach_device_args {
- remote_nonnull_domain dom;
- remote_nonnull_string xml;
-};
-typedef struct remote_domain_attach_device_args remote_domain_attach_device_args;
-
-struct remote_domain_detach_device_args {
- remote_nonnull_domain dom;
- remote_nonnull_string xml;
-};
-typedef struct remote_domain_detach_device_args remote_domain_detach_device_args;
-
-struct remote_domain_get_autostart_args {
- remote_nonnull_domain dom;
-};
-typedef struct remote_domain_get_autostart_args remote_domain_get_autostart_args;
-
-struct remote_domain_get_autostart_ret {
- int autostart;
-};
-typedef struct remote_domain_get_autostart_ret remote_domain_get_autostart_ret;
-
-struct remote_domain_set_autostart_args {
- remote_nonnull_domain dom;
- int autostart;
-};
-typedef struct remote_domain_set_autostart_args remote_domain_set_autostart_args;
-
-struct remote_num_of_networks_ret {
- int num;
-};
-typedef struct remote_num_of_networks_ret remote_num_of_networks_ret;
-
-struct remote_list_networks_args {
- int maxnames;
-};
-typedef struct remote_list_networks_args remote_list_networks_args;
-
-struct remote_list_networks_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_networks_ret remote_list_networks_ret;
-
-struct remote_num_of_defined_networks_ret {
- int num;
-};
-typedef struct remote_num_of_defined_networks_ret remote_num_of_defined_networks_ret;
-
-struct remote_list_defined_networks_args {
- int maxnames;
-};
-typedef struct remote_list_defined_networks_args remote_list_defined_networks_args;
-
-struct remote_list_defined_networks_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_defined_networks_ret remote_list_defined_networks_ret;
-
-struct remote_network_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-typedef struct remote_network_lookup_by_uuid_args remote_network_lookup_by_uuid_args;
-
-struct remote_network_lookup_by_uuid_ret {
- remote_nonnull_network net;
-};
-typedef struct remote_network_lookup_by_uuid_ret remote_network_lookup_by_uuid_ret;
-
-struct remote_network_lookup_by_name_args {
- remote_nonnull_string name;
-};
-typedef struct remote_network_lookup_by_name_args remote_network_lookup_by_name_args;
-
-struct remote_network_lookup_by_name_ret {
- remote_nonnull_network net;
-};
-typedef struct remote_network_lookup_by_name_ret remote_network_lookup_by_name_ret;
-
-struct remote_network_create_xml_args {
- remote_nonnull_string xml;
-};
-typedef struct remote_network_create_xml_args remote_network_create_xml_args;
-
-struct remote_network_create_xml_ret {
- remote_nonnull_network net;
-};
-typedef struct remote_network_create_xml_ret remote_network_create_xml_ret;
-
-struct remote_network_define_xml_args {
- remote_nonnull_string xml;
-};
-typedef struct remote_network_define_xml_args remote_network_define_xml_args;
-
-struct remote_network_define_xml_ret {
- remote_nonnull_network net;
-};
-typedef struct remote_network_define_xml_ret remote_network_define_xml_ret;
-
-struct remote_network_undefine_args {
- remote_nonnull_network net;
-};
-typedef struct remote_network_undefine_args remote_network_undefine_args;
-
-struct remote_network_create_args {
- remote_nonnull_network net;
-};
-typedef struct remote_network_create_args remote_network_create_args;
-
-struct remote_network_destroy_args {
- remote_nonnull_network net;
-};
-typedef struct remote_network_destroy_args remote_network_destroy_args;
-
-struct remote_network_dump_xml_args {
- remote_nonnull_network net;
- int flags;
-};
-typedef struct remote_network_dump_xml_args remote_network_dump_xml_args;
-
-struct remote_network_dump_xml_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_network_dump_xml_ret remote_network_dump_xml_ret;
-
-struct remote_network_get_bridge_name_args {
- remote_nonnull_network net;
-};
-typedef struct remote_network_get_bridge_name_args remote_network_get_bridge_name_args;
-
-struct remote_network_get_bridge_name_ret {
- remote_nonnull_string name;
-};
-typedef struct remote_network_get_bridge_name_ret remote_network_get_bridge_name_ret;
-
-struct remote_network_get_autostart_args {
- remote_nonnull_network net;
-};
-typedef struct remote_network_get_autostart_args remote_network_get_autostart_args;
-
-struct remote_network_get_autostart_ret {
- int autostart;
-};
-typedef struct remote_network_get_autostart_ret remote_network_get_autostart_ret;
-
-struct remote_network_set_autostart_args {
- remote_nonnull_network net;
- int autostart;
-};
-typedef struct remote_network_set_autostart_args remote_network_set_autostart_args;
-
-struct remote_num_of_interfaces_ret {
- int num;
-};
-typedef struct remote_num_of_interfaces_ret remote_num_of_interfaces_ret;
-
-struct remote_list_interfaces_args {
- int maxnames;
-};
-typedef struct remote_list_interfaces_args remote_list_interfaces_args;
-
-struct remote_list_interfaces_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_interfaces_ret remote_list_interfaces_ret;
-
-struct remote_num_of_defined_interfaces_ret {
- int num;
-};
-typedef struct remote_num_of_defined_interfaces_ret remote_num_of_defined_interfaces_ret;
-
-struct remote_list_defined_interfaces_args {
- int maxnames;
-};
-typedef struct remote_list_defined_interfaces_args remote_list_defined_interfaces_args;
-
-struct remote_list_defined_interfaces_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_defined_interfaces_ret remote_list_defined_interfaces_ret;
-
-struct remote_interface_lookup_by_name_args {
- remote_nonnull_string name;
-};
-typedef struct remote_interface_lookup_by_name_args remote_interface_lookup_by_name_args;
-
-struct remote_interface_lookup_by_name_ret {
- remote_nonnull_interface iface;
-};
-typedef struct remote_interface_lookup_by_name_ret remote_interface_lookup_by_name_ret;
-
-struct remote_interface_lookup_by_mac_string_args {
- remote_nonnull_string mac;
-};
-typedef struct remote_interface_lookup_by_mac_string_args remote_interface_lookup_by_mac_string_args;
-
-struct remote_interface_lookup_by_mac_string_ret {
- remote_nonnull_interface iface;
-};
-typedef struct remote_interface_lookup_by_mac_string_ret remote_interface_lookup_by_mac_string_ret;
-
-struct remote_interface_get_xml_desc_args {
- remote_nonnull_interface iface;
- u_int flags;
-};
-typedef struct remote_interface_get_xml_desc_args remote_interface_get_xml_desc_args;
-
-struct remote_interface_get_xml_desc_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_interface_get_xml_desc_ret remote_interface_get_xml_desc_ret;
-
-struct remote_interface_define_xml_args {
- remote_nonnull_string xml;
- u_int flags;
-};
-typedef struct remote_interface_define_xml_args remote_interface_define_xml_args;
-
-struct remote_interface_define_xml_ret {
- remote_nonnull_interface iface;
-};
-typedef struct remote_interface_define_xml_ret remote_interface_define_xml_ret;
-
-struct remote_interface_undefine_args {
- remote_nonnull_interface iface;
-};
-typedef struct remote_interface_undefine_args remote_interface_undefine_args;
-
-struct remote_interface_create_args {
- remote_nonnull_interface iface;
- u_int flags;
-};
-typedef struct remote_interface_create_args remote_interface_create_args;
-
-struct remote_interface_destroy_args {
- remote_nonnull_interface iface;
- u_int flags;
-};
-typedef struct remote_interface_destroy_args remote_interface_destroy_args;
-
-struct remote_auth_list_ret {
- struct {
- u_int types_len;
- remote_auth_type *types_val;
- } types;
-};
-typedef struct remote_auth_list_ret remote_auth_list_ret;
-
-struct remote_auth_sasl_init_ret {
- remote_nonnull_string mechlist;
-};
-typedef struct remote_auth_sasl_init_ret remote_auth_sasl_init_ret;
-
-struct remote_auth_sasl_start_args {
- remote_nonnull_string mech;
- int nil;
- struct {
- u_int data_len;
- char *data_val;
- } data;
-};
-typedef struct remote_auth_sasl_start_args remote_auth_sasl_start_args;
-
-struct remote_auth_sasl_start_ret {
- int complete;
- int nil;
- struct {
- u_int data_len;
- char *data_val;
- } data;
-};
-typedef struct remote_auth_sasl_start_ret remote_auth_sasl_start_ret;
-
-struct remote_auth_sasl_step_args {
- int nil;
- struct {
- u_int data_len;
- char *data_val;
- } data;
-};
-typedef struct remote_auth_sasl_step_args remote_auth_sasl_step_args;
-
-struct remote_auth_sasl_step_ret {
- int complete;
- int nil;
- struct {
- u_int data_len;
- char *data_val;
- } data;
-};
-typedef struct remote_auth_sasl_step_ret remote_auth_sasl_step_ret;
-
-struct remote_auth_polkit_ret {
- int complete;
-};
-typedef struct remote_auth_polkit_ret remote_auth_polkit_ret;
-
-struct remote_num_of_storage_pools_ret {
- int num;
-};
-typedef struct remote_num_of_storage_pools_ret remote_num_of_storage_pools_ret;
-
-struct remote_list_storage_pools_args {
- int maxnames;
-};
-typedef struct remote_list_storage_pools_args remote_list_storage_pools_args;
-
-struct remote_list_storage_pools_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_storage_pools_ret remote_list_storage_pools_ret;
-
-struct remote_num_of_defined_storage_pools_ret {
- int num;
-};
-typedef struct remote_num_of_defined_storage_pools_ret remote_num_of_defined_storage_pools_ret;
-
-struct remote_list_defined_storage_pools_args {
- int maxnames;
-};
-typedef struct remote_list_defined_storage_pools_args remote_list_defined_storage_pools_args;
-
-struct remote_list_defined_storage_pools_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_list_defined_storage_pools_ret remote_list_defined_storage_pools_ret;
-
-struct remote_find_storage_pool_sources_args {
- remote_nonnull_string type;
- remote_string srcSpec;
- u_int flags;
-};
-typedef struct remote_find_storage_pool_sources_args remote_find_storage_pool_sources_args;
-
-struct remote_find_storage_pool_sources_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_find_storage_pool_sources_ret remote_find_storage_pool_sources_ret;
-
-struct remote_storage_pool_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-typedef struct remote_storage_pool_lookup_by_uuid_args remote_storage_pool_lookup_by_uuid_args;
-
-struct remote_storage_pool_lookup_by_uuid_ret {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_lookup_by_uuid_ret remote_storage_pool_lookup_by_uuid_ret;
-
-struct remote_storage_pool_lookup_by_name_args {
- remote_nonnull_string name;
-};
-typedef struct remote_storage_pool_lookup_by_name_args remote_storage_pool_lookup_by_name_args;
-
-struct remote_storage_pool_lookup_by_name_ret {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_lookup_by_name_ret remote_storage_pool_lookup_by_name_ret;
-
-struct remote_storage_pool_lookup_by_volume_args {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_pool_lookup_by_volume_args remote_storage_pool_lookup_by_volume_args;
-
-struct remote_storage_pool_lookup_by_volume_ret {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_lookup_by_volume_ret remote_storage_pool_lookup_by_volume_ret;
-
-struct remote_storage_pool_create_xml_args {
- remote_nonnull_string xml;
- u_int flags;
-};
-typedef struct remote_storage_pool_create_xml_args remote_storage_pool_create_xml_args;
-
-struct remote_storage_pool_create_xml_ret {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_create_xml_ret remote_storage_pool_create_xml_ret;
-
-struct remote_storage_pool_define_xml_args {
- remote_nonnull_string xml;
- u_int flags;
-};
-typedef struct remote_storage_pool_define_xml_args remote_storage_pool_define_xml_args;
-
-struct remote_storage_pool_define_xml_ret {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_define_xml_ret remote_storage_pool_define_xml_ret;
-
-struct remote_storage_pool_build_args {
- remote_nonnull_storage_pool pool;
- u_int flags;
-};
-typedef struct remote_storage_pool_build_args remote_storage_pool_build_args;
-
-struct remote_storage_pool_undefine_args {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_undefine_args remote_storage_pool_undefine_args;
-
-struct remote_storage_pool_create_args {
- remote_nonnull_storage_pool pool;
- u_int flags;
-};
-typedef struct remote_storage_pool_create_args remote_storage_pool_create_args;
-
-struct remote_storage_pool_destroy_args {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_destroy_args remote_storage_pool_destroy_args;
-
-struct remote_storage_pool_delete_args {
- remote_nonnull_storage_pool pool;
- u_int flags;
-};
-typedef struct remote_storage_pool_delete_args remote_storage_pool_delete_args;
-
-struct remote_storage_pool_refresh_args {
- remote_nonnull_storage_pool pool;
- u_int flags;
-};
-typedef struct remote_storage_pool_refresh_args remote_storage_pool_refresh_args;
-
-struct remote_storage_pool_dump_xml_args {
- remote_nonnull_storage_pool pool;
- u_int flags;
-};
-typedef struct remote_storage_pool_dump_xml_args remote_storage_pool_dump_xml_args;
-
-struct remote_storage_pool_dump_xml_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_storage_pool_dump_xml_ret remote_storage_pool_dump_xml_ret;
-
-struct remote_storage_pool_get_info_args {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_get_info_args remote_storage_pool_get_info_args;
-
-struct remote_storage_pool_get_info_ret {
- u_char state;
- uint64_t capacity;
- uint64_t allocation;
- uint64_t available;
-};
-typedef struct remote_storage_pool_get_info_ret remote_storage_pool_get_info_ret;
-
-struct remote_storage_pool_get_autostart_args {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_get_autostart_args remote_storage_pool_get_autostart_args;
-
-struct remote_storage_pool_get_autostart_ret {
- int autostart;
-};
-typedef struct remote_storage_pool_get_autostart_ret remote_storage_pool_get_autostart_ret;
-
-struct remote_storage_pool_set_autostart_args {
- remote_nonnull_storage_pool pool;
- int autostart;
-};
-typedef struct remote_storage_pool_set_autostart_args remote_storage_pool_set_autostart_args;
-
-struct remote_storage_pool_num_of_volumes_args {
- remote_nonnull_storage_pool pool;
-};
-typedef struct remote_storage_pool_num_of_volumes_args remote_storage_pool_num_of_volumes_args;
-
-struct remote_storage_pool_num_of_volumes_ret {
- int num;
-};
-typedef struct remote_storage_pool_num_of_volumes_ret remote_storage_pool_num_of_volumes_ret;
-
-struct remote_storage_pool_list_volumes_args {
- remote_nonnull_storage_pool pool;
- int maxnames;
-};
-typedef struct remote_storage_pool_list_volumes_args remote_storage_pool_list_volumes_args;
-
-struct remote_storage_pool_list_volumes_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_storage_pool_list_volumes_ret remote_storage_pool_list_volumes_ret;
-
-struct remote_storage_vol_lookup_by_name_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string name;
-};
-typedef struct remote_storage_vol_lookup_by_name_args remote_storage_vol_lookup_by_name_args;
-
-struct remote_storage_vol_lookup_by_name_ret {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_lookup_by_name_ret remote_storage_vol_lookup_by_name_ret;
-
-struct remote_storage_vol_lookup_by_key_args {
- remote_nonnull_string key;
-};
-typedef struct remote_storage_vol_lookup_by_key_args remote_storage_vol_lookup_by_key_args;
-
-struct remote_storage_vol_lookup_by_key_ret {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_lookup_by_key_ret remote_storage_vol_lookup_by_key_ret;
-
-struct remote_storage_vol_lookup_by_path_args {
- remote_nonnull_string path;
-};
-typedef struct remote_storage_vol_lookup_by_path_args remote_storage_vol_lookup_by_path_args;
-
-struct remote_storage_vol_lookup_by_path_ret {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_lookup_by_path_ret remote_storage_vol_lookup_by_path_ret;
-
-struct remote_storage_vol_create_xml_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string xml;
- u_int flags;
-};
-typedef struct remote_storage_vol_create_xml_args remote_storage_vol_create_xml_args;
-
-struct remote_storage_vol_create_xml_ret {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_create_xml_ret remote_storage_vol_create_xml_ret;
-
-struct remote_storage_vol_create_xml_from_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string xml;
- remote_nonnull_storage_vol clonevol;
- u_int flags;
-};
-typedef struct remote_storage_vol_create_xml_from_args remote_storage_vol_create_xml_from_args;
-
-struct remote_storage_vol_create_xml_from_ret {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_create_xml_from_ret remote_storage_vol_create_xml_from_ret;
-
-struct remote_storage_vol_delete_args {
- remote_nonnull_storage_vol vol;
- u_int flags;
-};
-typedef struct remote_storage_vol_delete_args remote_storage_vol_delete_args;
-
-struct remote_storage_vol_dump_xml_args {
- remote_nonnull_storage_vol vol;
- u_int flags;
-};
-typedef struct remote_storage_vol_dump_xml_args remote_storage_vol_dump_xml_args;
-
-struct remote_storage_vol_dump_xml_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_storage_vol_dump_xml_ret remote_storage_vol_dump_xml_ret;
-
-struct remote_storage_vol_get_info_args {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_get_info_args remote_storage_vol_get_info_args;
-
-struct remote_storage_vol_get_info_ret {
- char type;
- uint64_t capacity;
- uint64_t allocation;
-};
-typedef struct remote_storage_vol_get_info_ret remote_storage_vol_get_info_ret;
-
-struct remote_storage_vol_get_path_args {
- remote_nonnull_storage_vol vol;
-};
-typedef struct remote_storage_vol_get_path_args remote_storage_vol_get_path_args;
-
-struct remote_storage_vol_get_path_ret {
- remote_nonnull_string name;
-};
-typedef struct remote_storage_vol_get_path_ret remote_storage_vol_get_path_ret;
-
-struct remote_node_num_of_devices_args {
- remote_string cap;
- u_int flags;
-};
-typedef struct remote_node_num_of_devices_args remote_node_num_of_devices_args;
-
-struct remote_node_num_of_devices_ret {
- int num;
-};
-typedef struct remote_node_num_of_devices_ret remote_node_num_of_devices_ret;
-
-struct remote_node_list_devices_args {
- remote_string cap;
- int maxnames;
- u_int flags;
-};
-typedef struct remote_node_list_devices_args remote_node_list_devices_args;
-
-struct remote_node_list_devices_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_node_list_devices_ret remote_node_list_devices_ret;
-
-struct remote_node_device_lookup_by_name_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_lookup_by_name_args remote_node_device_lookup_by_name_args;
-
-struct remote_node_device_lookup_by_name_ret {
- remote_nonnull_node_device dev;
-};
-typedef struct remote_node_device_lookup_by_name_ret remote_node_device_lookup_by_name_ret;
-
-struct remote_node_device_dump_xml_args {
- remote_nonnull_string name;
- u_int flags;
-};
-typedef struct remote_node_device_dump_xml_args remote_node_device_dump_xml_args;
-
-struct remote_node_device_dump_xml_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_node_device_dump_xml_ret remote_node_device_dump_xml_ret;
-
-struct remote_node_device_get_parent_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_get_parent_args remote_node_device_get_parent_args;
-
-struct remote_node_device_get_parent_ret {
- remote_string parent;
-};
-typedef struct remote_node_device_get_parent_ret remote_node_device_get_parent_ret;
-
-struct remote_node_device_num_of_caps_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_num_of_caps_args remote_node_device_num_of_caps_args;
-
-struct remote_node_device_num_of_caps_ret {
- int num;
-};
-typedef struct remote_node_device_num_of_caps_ret remote_node_device_num_of_caps_ret;
-
-struct remote_node_device_list_caps_args {
- remote_nonnull_string name;
- int maxnames;
-};
-typedef struct remote_node_device_list_caps_args remote_node_device_list_caps_args;
-
-struct remote_node_device_list_caps_ret {
- struct {
- u_int names_len;
- remote_nonnull_string *names_val;
- } names;
-};
-typedef struct remote_node_device_list_caps_ret remote_node_device_list_caps_ret;
-
-struct remote_node_device_dettach_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_dettach_args remote_node_device_dettach_args;
-
-struct remote_node_device_re_attach_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_re_attach_args remote_node_device_re_attach_args;
-
-struct remote_node_device_reset_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_reset_args remote_node_device_reset_args;
-
-struct remote_node_device_create_xml_args {
- remote_nonnull_string xml_desc;
- int flags;
-};
-typedef struct remote_node_device_create_xml_args remote_node_device_create_xml_args;
-
-struct remote_node_device_create_xml_ret {
- remote_nonnull_node_device dev;
-};
-typedef struct remote_node_device_create_xml_ret remote_node_device_create_xml_ret;
-
-struct remote_node_device_destroy_args {
- remote_nonnull_string name;
-};
-typedef struct remote_node_device_destroy_args remote_node_device_destroy_args;
-
-struct remote_domain_events_register_ret {
- int cb_registered;
-};
-typedef struct remote_domain_events_register_ret remote_domain_events_register_ret;
-
-struct remote_domain_events_deregister_ret {
- int cb_registered;
-};
-typedef struct remote_domain_events_deregister_ret remote_domain_events_deregister_ret;
-
-struct remote_domain_event_msg {
- remote_nonnull_domain dom;
- int event;
- int detail;
-};
-typedef struct remote_domain_event_msg remote_domain_event_msg;
-
-struct remote_domain_xml_from_native_args {
- remote_nonnull_string nativeFormat;
- remote_nonnull_string nativeConfig;
- u_int flags;
-};
-typedef struct remote_domain_xml_from_native_args remote_domain_xml_from_native_args;
-
-struct remote_domain_xml_from_native_ret {
- remote_nonnull_string domainXml;
-};
-typedef struct remote_domain_xml_from_native_ret remote_domain_xml_from_native_ret;
-
-struct remote_domain_xml_to_native_args {
- remote_nonnull_string nativeFormat;
- remote_nonnull_string domainXml;
- u_int flags;
-};
-typedef struct remote_domain_xml_to_native_args remote_domain_xml_to_native_args;
-
-struct remote_domain_xml_to_native_ret {
- remote_nonnull_string nativeConfig;
-};
-typedef struct remote_domain_xml_to_native_ret remote_domain_xml_to_native_ret;
-
-struct remote_num_of_secrets_ret {
- int num;
-};
-typedef struct remote_num_of_secrets_ret remote_num_of_secrets_ret;
-
-struct remote_list_secrets_args {
- int maxuuids;
-};
-typedef struct remote_list_secrets_args remote_list_secrets_args;
-
-struct remote_list_secrets_ret {
- struct {
- u_int uuids_len;
- remote_nonnull_string *uuids_val;
- } uuids;
-};
-typedef struct remote_list_secrets_ret remote_list_secrets_ret;
-
-struct remote_secret_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-typedef struct remote_secret_lookup_by_uuid_args remote_secret_lookup_by_uuid_args;
-
-struct remote_secret_lookup_by_uuid_ret {
- remote_nonnull_secret secret;
-};
-typedef struct remote_secret_lookup_by_uuid_ret remote_secret_lookup_by_uuid_ret;
-
-struct remote_secret_define_xml_args {
- remote_nonnull_string xml;
- u_int flags;
-};
-typedef struct remote_secret_define_xml_args remote_secret_define_xml_args;
-
-struct remote_secret_define_xml_ret {
- remote_nonnull_secret secret;
-};
-typedef struct remote_secret_define_xml_ret remote_secret_define_xml_ret;
-
-struct remote_secret_get_xml_desc_args {
- remote_nonnull_secret secret;
- u_int flags;
-};
-typedef struct remote_secret_get_xml_desc_args remote_secret_get_xml_desc_args;
-
-struct remote_secret_get_xml_desc_ret {
- remote_nonnull_string xml;
-};
-typedef struct remote_secret_get_xml_desc_ret remote_secret_get_xml_desc_ret;
-
-struct remote_secret_set_value_args {
- remote_nonnull_secret secret;
- struct {
- u_int value_len;
- char *value_val;
- } value;
- u_int flags;
-};
-typedef struct remote_secret_set_value_args remote_secret_set_value_args;
-
-struct remote_secret_get_value_args {
- remote_nonnull_secret secret;
- u_int flags;
-};
-typedef struct remote_secret_get_value_args remote_secret_get_value_args;
-
-struct remote_secret_get_value_ret {
- struct {
- u_int value_len;
- char *value_val;
- } value;
-};
-typedef struct remote_secret_get_value_ret remote_secret_get_value_ret;
-
-struct remote_secret_undefine_args {
- remote_nonnull_secret secret;
-};
-typedef struct remote_secret_undefine_args remote_secret_undefine_args;
-
-struct remote_secret_lookup_by_usage_args {
- int usageType;
- remote_nonnull_string usageID;
-};
-typedef struct remote_secret_lookup_by_usage_args remote_secret_lookup_by_usage_args;
-
-struct remote_secret_lookup_by_usage_ret {
- remote_nonnull_secret secret;
-};
-typedef struct remote_secret_lookup_by_usage_ret remote_secret_lookup_by_usage_ret;
-#define REMOTE_PROGRAM 0x20008086
-#define REMOTE_PROTOCOL_VERSION 1
-
-enum remote_procedure {
- REMOTE_PROC_OPEN = 1,
- REMOTE_PROC_CLOSE = 2,
- REMOTE_PROC_GET_TYPE = 3,
- REMOTE_PROC_GET_VERSION = 4,
- REMOTE_PROC_GET_MAX_VCPUS = 5,
- REMOTE_PROC_NODE_GET_INFO = 6,
- REMOTE_PROC_GET_CAPABILITIES = 7,
- REMOTE_PROC_DOMAIN_ATTACH_DEVICE = 8,
- REMOTE_PROC_DOMAIN_CREATE = 9,
- REMOTE_PROC_DOMAIN_CREATE_XML = 10,
- REMOTE_PROC_DOMAIN_DEFINE_XML = 11,
- REMOTE_PROC_DOMAIN_DESTROY = 12,
- REMOTE_PROC_DOMAIN_DETACH_DEVICE = 13,
- REMOTE_PROC_DOMAIN_DUMP_XML = 14,
- REMOTE_PROC_DOMAIN_GET_AUTOSTART = 15,
- REMOTE_PROC_DOMAIN_GET_INFO = 16,
- REMOTE_PROC_DOMAIN_GET_MAX_MEMORY = 17,
- REMOTE_PROC_DOMAIN_GET_MAX_VCPUS = 18,
- REMOTE_PROC_DOMAIN_GET_OS_TYPE = 19,
- REMOTE_PROC_DOMAIN_GET_VCPUS = 20,
- REMOTE_PROC_LIST_DEFINED_DOMAINS = 21,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_ID = 22,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME = 23,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID = 24,
- REMOTE_PROC_NUM_OF_DEFINED_DOMAINS = 25,
- REMOTE_PROC_DOMAIN_PIN_VCPU = 26,
- REMOTE_PROC_DOMAIN_REBOOT = 27,
- REMOTE_PROC_DOMAIN_RESUME = 28,
- REMOTE_PROC_DOMAIN_SET_AUTOSTART = 29,
- REMOTE_PROC_DOMAIN_SET_MAX_MEMORY = 30,
- REMOTE_PROC_DOMAIN_SET_MEMORY = 31,
- REMOTE_PROC_DOMAIN_SET_VCPUS = 32,
- REMOTE_PROC_DOMAIN_SHUTDOWN = 33,
- REMOTE_PROC_DOMAIN_SUSPEND = 34,
- REMOTE_PROC_DOMAIN_UNDEFINE = 35,
- REMOTE_PROC_LIST_DEFINED_NETWORKS = 36,
- REMOTE_PROC_LIST_DOMAINS = 37,
- REMOTE_PROC_LIST_NETWORKS = 38,
- REMOTE_PROC_NETWORK_CREATE = 39,
- REMOTE_PROC_NETWORK_CREATE_XML = 40,
- REMOTE_PROC_NETWORK_DEFINE_XML = 41,
- REMOTE_PROC_NETWORK_DESTROY = 42,
- REMOTE_PROC_NETWORK_DUMP_XML = 43,
- REMOTE_PROC_NETWORK_GET_AUTOSTART = 44,
- REMOTE_PROC_NETWORK_GET_BRIDGE_NAME = 45,
- REMOTE_PROC_NETWORK_LOOKUP_BY_NAME = 46,
- REMOTE_PROC_NETWORK_LOOKUP_BY_UUID = 47,
- REMOTE_PROC_NETWORK_SET_AUTOSTART = 48,
- REMOTE_PROC_NETWORK_UNDEFINE = 49,
- REMOTE_PROC_NUM_OF_DEFINED_NETWORKS = 50,
- REMOTE_PROC_NUM_OF_DOMAINS = 51,
- REMOTE_PROC_NUM_OF_NETWORKS = 52,
- REMOTE_PROC_DOMAIN_CORE_DUMP = 53,
- REMOTE_PROC_DOMAIN_RESTORE = 54,
- REMOTE_PROC_DOMAIN_SAVE = 55,
- REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE = 56,
- REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS = 57,
- REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS = 58,
- REMOTE_PROC_GET_HOSTNAME = 59,
- REMOTE_PROC_SUPPORTS_FEATURE = 60,
- REMOTE_PROC_DOMAIN_MIGRATE_PREPARE = 61,
- REMOTE_PROC_DOMAIN_MIGRATE_PERFORM = 62,
- REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
- REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
- REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
- REMOTE_PROC_AUTH_LIST = 66,
- REMOTE_PROC_AUTH_SASL_INIT = 67,
- REMOTE_PROC_AUTH_SASL_START = 68,
- REMOTE_PROC_AUTH_SASL_STEP = 69,
- REMOTE_PROC_AUTH_POLKIT = 70,
- REMOTE_PROC_NUM_OF_STORAGE_POOLS = 71,
- REMOTE_PROC_LIST_STORAGE_POOLS = 72,
- REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 73,
- REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 74,
- REMOTE_PROC_FIND_STORAGE_POOL_SOURCES = 75,
- REMOTE_PROC_STORAGE_POOL_CREATE_XML = 76,
- REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 77,
- REMOTE_PROC_STORAGE_POOL_CREATE = 78,
- REMOTE_PROC_STORAGE_POOL_BUILD = 79,
- REMOTE_PROC_STORAGE_POOL_DESTROY = 80,
- REMOTE_PROC_STORAGE_POOL_DELETE = 81,
- REMOTE_PROC_STORAGE_POOL_UNDEFINE = 82,
- REMOTE_PROC_STORAGE_POOL_REFRESH = 83,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 84,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 85,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME = 86,
- REMOTE_PROC_STORAGE_POOL_GET_INFO = 87,
- REMOTE_PROC_STORAGE_POOL_DUMP_XML = 88,
- REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 89,
- REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 90,
- REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 91,
- REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 92,
- REMOTE_PROC_STORAGE_VOL_CREATE_XML = 93,
- REMOTE_PROC_STORAGE_VOL_DELETE = 94,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 95,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY = 96,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH = 97,
- REMOTE_PROC_STORAGE_VOL_GET_INFO = 98,
- REMOTE_PROC_STORAGE_VOL_DUMP_XML = 99,
- REMOTE_PROC_STORAGE_VOL_GET_PATH = 100,
- REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY = 101,
- REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
- REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
- REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
- REMOTE_PROC_DOMAIN_EVENTS_REGISTER = 105,
- REMOTE_PROC_DOMAIN_EVENTS_DEREGISTER = 106,
- REMOTE_PROC_DOMAIN_EVENT = 107,
- REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2 = 108,
- REMOTE_PROC_DOMAIN_MIGRATE_FINISH2 = 109,
- REMOTE_PROC_GET_URI = 110,
- REMOTE_PROC_NODE_NUM_OF_DEVICES = 111,
- REMOTE_PROC_NODE_LIST_DEVICES = 112,
- REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME = 113,
- REMOTE_PROC_NODE_DEVICE_DUMP_XML = 114,
- REMOTE_PROC_NODE_DEVICE_GET_PARENT = 115,
- REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS = 116,
- REMOTE_PROC_NODE_DEVICE_LIST_CAPS = 117,
- REMOTE_PROC_NODE_DEVICE_DETTACH = 118,
- REMOTE_PROC_NODE_DEVICE_RE_ATTACH = 119,
- REMOTE_PROC_NODE_DEVICE_RESET = 120,
- REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL = 121,
- REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
- REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
- REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
- REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM = 125,
- REMOTE_PROC_NUM_OF_INTERFACES = 126,
- REMOTE_PROC_LIST_INTERFACES = 127,
- REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
- REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING = 129,
- REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
- REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
- REMOTE_PROC_INTERFACE_UNDEFINE = 132,
- REMOTE_PROC_INTERFACE_CREATE = 133,
- REMOTE_PROC_INTERFACE_DESTROY = 134,
- REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
- REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
- REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
- REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
- REMOTE_PROC_NUM_OF_SECRETS = 139,
- REMOTE_PROC_LIST_SECRETS = 140,
- REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
- REMOTE_PROC_SECRET_DEFINE_XML = 142,
- REMOTE_PROC_SECRET_GET_XML_DESC = 143,
- REMOTE_PROC_SECRET_SET_VALUE = 144,
- REMOTE_PROC_SECRET_GET_VALUE = 145,
- REMOTE_PROC_SECRET_UNDEFINE = 146,
- REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
-};
-typedef enum remote_procedure remote_procedure;
-
-enum remote_message_type {
- REMOTE_CALL = 0,
- REMOTE_REPLY = 1,
- REMOTE_MESSAGE = 2,
-};
-typedef enum remote_message_type remote_message_type;
-
-enum remote_message_status {
- REMOTE_OK = 0,
- REMOTE_ERROR = 1,
-};
-typedef enum remote_message_status remote_message_status;
-#define REMOTE_MESSAGE_HEADER_XDR_LEN 4
-
-struct remote_message_header {
- u_int prog;
- u_int vers;
- remote_procedure proc;
- remote_message_type type;
- u_int serial;
- remote_message_status status;
-};
-typedef struct remote_message_header remote_message_header;
-
-/* the xdr functions */
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern bool_t xdr_remote_nonnull_string (XDR *, remote_nonnull_string*);
-extern bool_t xdr_remote_string (XDR *, remote_string*);
-extern bool_t xdr_remote_uuid (XDR *, remote_uuid);
-extern bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*);
-extern bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*);
-extern bool_t xdr_remote_nonnull_interface (XDR *, remote_nonnull_interface*);
-extern bool_t xdr_remote_nonnull_storage_pool (XDR *, remote_nonnull_storage_pool*);
-extern bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
-extern bool_t xdr_remote_nonnull_node_device (XDR *, remote_nonnull_node_device*);
-extern bool_t xdr_remote_nonnull_secret (XDR *, remote_nonnull_secret*);
-extern bool_t xdr_remote_domain (XDR *, remote_domain*);
-extern bool_t xdr_remote_network (XDR *, remote_network*);
-extern bool_t xdr_remote_storage_pool (XDR *, remote_storage_pool*);
-extern bool_t xdr_remote_storage_vol (XDR *, remote_storage_vol*);
-extern bool_t xdr_remote_node_device (XDR *, remote_node_device*);
-extern bool_t xdr_remote_error (XDR *, remote_error*);
-extern bool_t xdr_remote_auth_type (XDR *, remote_auth_type*);
-extern bool_t xdr_remote_vcpu_info (XDR *, remote_vcpu_info*);
-extern bool_t xdr_remote_sched_param_value (XDR *, remote_sched_param_value*);
-extern bool_t xdr_remote_sched_param (XDR *, remote_sched_param*);
-extern bool_t xdr_remote_open_args (XDR *, remote_open_args*);
-extern bool_t xdr_remote_supports_feature_args (XDR *, remote_supports_feature_args*);
-extern bool_t xdr_remote_supports_feature_ret (XDR *, remote_supports_feature_ret*);
-extern bool_t xdr_remote_get_type_ret (XDR *, remote_get_type_ret*);
-extern bool_t xdr_remote_get_version_ret (XDR *, remote_get_version_ret*);
-extern bool_t xdr_remote_get_hostname_ret (XDR *, remote_get_hostname_ret*);
-extern bool_t xdr_remote_get_uri_ret (XDR *, remote_get_uri_ret*);
-extern bool_t xdr_remote_get_max_vcpus_args (XDR *, remote_get_max_vcpus_args*);
-extern bool_t xdr_remote_get_max_vcpus_ret (XDR *, remote_get_max_vcpus_ret*);
-extern bool_t xdr_remote_node_get_info_ret (XDR *, remote_node_get_info_ret*);
-extern bool_t xdr_remote_get_capabilities_ret (XDR *, remote_get_capabilities_ret*);
-extern bool_t xdr_remote_node_get_cells_free_memory_args (XDR *, remote_node_get_cells_free_memory_args*);
-extern bool_t xdr_remote_node_get_cells_free_memory_ret (XDR *, remote_node_get_cells_free_memory_ret*);
-extern bool_t xdr_remote_node_get_free_memory_ret (XDR *, remote_node_get_free_memory_ret*);
-extern bool_t xdr_remote_domain_get_scheduler_type_args (XDR *, remote_domain_get_scheduler_type_args*);
-extern bool_t xdr_remote_domain_get_scheduler_type_ret (XDR *, remote_domain_get_scheduler_type_ret*);
-extern bool_t xdr_remote_domain_get_scheduler_parameters_args (XDR *, remote_domain_get_scheduler_parameters_args*);
-extern bool_t xdr_remote_domain_get_scheduler_parameters_ret (XDR *, remote_domain_get_scheduler_parameters_ret*);
-extern bool_t xdr_remote_domain_set_scheduler_parameters_args (XDR *, remote_domain_set_scheduler_parameters_args*);
-extern bool_t xdr_remote_domain_block_stats_args (XDR *, remote_domain_block_stats_args*);
-extern bool_t xdr_remote_domain_block_stats_ret (XDR *, remote_domain_block_stats_ret*);
-extern bool_t xdr_remote_domain_interface_stats_args (XDR *, remote_domain_interface_stats_args*);
-extern bool_t xdr_remote_domain_interface_stats_ret (XDR *, remote_domain_interface_stats_ret*);
-extern bool_t xdr_remote_domain_block_peek_args (XDR *, remote_domain_block_peek_args*);
-extern bool_t xdr_remote_domain_block_peek_ret (XDR *, remote_domain_block_peek_ret*);
-extern bool_t xdr_remote_domain_memory_peek_args (XDR *, remote_domain_memory_peek_args*);
-extern bool_t xdr_remote_domain_memory_peek_ret (XDR *, remote_domain_memory_peek_ret*);
-extern bool_t xdr_remote_list_domains_args (XDR *, remote_list_domains_args*);
-extern bool_t xdr_remote_list_domains_ret (XDR *, remote_list_domains_ret*);
-extern bool_t xdr_remote_num_of_domains_ret (XDR *, remote_num_of_domains_ret*);
-extern bool_t xdr_remote_domain_create_xml_args (XDR *, remote_domain_create_xml_args*);
-extern bool_t xdr_remote_domain_create_xml_ret (XDR *, remote_domain_create_xml_ret*);
-extern bool_t xdr_remote_domain_lookup_by_id_args (XDR *, remote_domain_lookup_by_id_args*);
-extern bool_t xdr_remote_domain_lookup_by_id_ret (XDR *, remote_domain_lookup_by_id_ret*);
-extern bool_t xdr_remote_domain_lookup_by_uuid_args (XDR *, remote_domain_lookup_by_uuid_args*);
-extern bool_t xdr_remote_domain_lookup_by_uuid_ret (XDR *, remote_domain_lookup_by_uuid_ret*);
-extern bool_t xdr_remote_domain_lookup_by_name_args (XDR *, remote_domain_lookup_by_name_args*);
-extern bool_t xdr_remote_domain_lookup_by_name_ret (XDR *, remote_domain_lookup_by_name_ret*);
-extern bool_t xdr_remote_domain_suspend_args (XDR *, remote_domain_suspend_args*);
-extern bool_t xdr_remote_domain_resume_args (XDR *, remote_domain_resume_args*);
-extern bool_t xdr_remote_domain_shutdown_args (XDR *, remote_domain_shutdown_args*);
-extern bool_t xdr_remote_domain_reboot_args (XDR *, remote_domain_reboot_args*);
-extern bool_t xdr_remote_domain_destroy_args (XDR *, remote_domain_destroy_args*);
-extern bool_t xdr_remote_domain_get_os_type_args (XDR *, remote_domain_get_os_type_args*);
-extern bool_t xdr_remote_domain_get_os_type_ret (XDR *, remote_domain_get_os_type_ret*);
-extern bool_t xdr_remote_domain_get_max_memory_args (XDR *, remote_domain_get_max_memory_args*);
-extern bool_t xdr_remote_domain_get_max_memory_ret (XDR *, remote_domain_get_max_memory_ret*);
-extern bool_t xdr_remote_domain_set_max_memory_args (XDR *, remote_domain_set_max_memory_args*);
-extern bool_t xdr_remote_domain_set_memory_args (XDR *, remote_domain_set_memory_args*);
-extern bool_t xdr_remote_domain_get_info_args (XDR *, remote_domain_get_info_args*);
-extern bool_t xdr_remote_domain_get_info_ret (XDR *, remote_domain_get_info_ret*);
-extern bool_t xdr_remote_domain_save_args (XDR *, remote_domain_save_args*);
-extern bool_t xdr_remote_domain_restore_args (XDR *, remote_domain_restore_args*);
-extern bool_t xdr_remote_domain_core_dump_args (XDR *, remote_domain_core_dump_args*);
-extern bool_t xdr_remote_domain_dump_xml_args (XDR *, remote_domain_dump_xml_args*);
-extern bool_t xdr_remote_domain_dump_xml_ret (XDR *, remote_domain_dump_xml_ret*);
-extern bool_t xdr_remote_domain_migrate_prepare_args (XDR *, remote_domain_migrate_prepare_args*);
-extern bool_t xdr_remote_domain_migrate_prepare_ret (XDR *, remote_domain_migrate_prepare_ret*);
-extern bool_t xdr_remote_domain_migrate_perform_args (XDR *, remote_domain_migrate_perform_args*);
-extern bool_t xdr_remote_domain_migrate_finish_args (XDR *, remote_domain_migrate_finish_args*);
-extern bool_t xdr_remote_domain_migrate_finish_ret (XDR *, remote_domain_migrate_finish_ret*);
-extern bool_t xdr_remote_domain_migrate_prepare2_args (XDR *, remote_domain_migrate_prepare2_args*);
-extern bool_t xdr_remote_domain_migrate_prepare2_ret (XDR *, remote_domain_migrate_prepare2_ret*);
-extern bool_t xdr_remote_domain_migrate_finish2_args (XDR *, remote_domain_migrate_finish2_args*);
-extern bool_t xdr_remote_domain_migrate_finish2_ret (XDR *, remote_domain_migrate_finish2_ret*);
-extern bool_t xdr_remote_list_defined_domains_args (XDR *, remote_list_defined_domains_args*);
-extern bool_t xdr_remote_list_defined_domains_ret (XDR *, remote_list_defined_domains_ret*);
-extern bool_t xdr_remote_num_of_defined_domains_ret (XDR *, remote_num_of_defined_domains_ret*);
-extern bool_t xdr_remote_domain_create_args (XDR *, remote_domain_create_args*);
-extern bool_t xdr_remote_domain_define_xml_args (XDR *, remote_domain_define_xml_args*);
-extern bool_t xdr_remote_domain_define_xml_ret (XDR *, remote_domain_define_xml_ret*);
-extern bool_t xdr_remote_domain_undefine_args (XDR *, remote_domain_undefine_args*);
-extern bool_t xdr_remote_domain_set_vcpus_args (XDR *, remote_domain_set_vcpus_args*);
-extern bool_t xdr_remote_domain_pin_vcpu_args (XDR *, remote_domain_pin_vcpu_args*);
-extern bool_t xdr_remote_domain_get_vcpus_args (XDR *, remote_domain_get_vcpus_args*);
-extern bool_t xdr_remote_domain_get_vcpus_ret (XDR *, remote_domain_get_vcpus_ret*);
-extern bool_t xdr_remote_domain_get_max_vcpus_args (XDR *, remote_domain_get_max_vcpus_args*);
-extern bool_t xdr_remote_domain_get_max_vcpus_ret (XDR *, remote_domain_get_max_vcpus_ret*);
-extern bool_t xdr_remote_domain_get_security_label_args (XDR *, remote_domain_get_security_label_args*);
-extern bool_t xdr_remote_domain_get_security_label_ret (XDR *, remote_domain_get_security_label_ret*);
-extern bool_t xdr_remote_node_get_security_model_ret (XDR *, remote_node_get_security_model_ret*);
-extern bool_t xdr_remote_domain_attach_device_args (XDR *, remote_domain_attach_device_args*);
-extern bool_t xdr_remote_domain_detach_device_args (XDR *, remote_domain_detach_device_args*);
-extern bool_t xdr_remote_domain_get_autostart_args (XDR *, remote_domain_get_autostart_args*);
-extern bool_t xdr_remote_domain_get_autostart_ret (XDR *, remote_domain_get_autostart_ret*);
-extern bool_t xdr_remote_domain_set_autostart_args (XDR *, remote_domain_set_autostart_args*);
-extern bool_t xdr_remote_num_of_networks_ret (XDR *, remote_num_of_networks_ret*);
-extern bool_t xdr_remote_list_networks_args (XDR *, remote_list_networks_args*);
-extern bool_t xdr_remote_list_networks_ret (XDR *, remote_list_networks_ret*);
-extern bool_t xdr_remote_num_of_defined_networks_ret (XDR *, remote_num_of_defined_networks_ret*);
-extern bool_t xdr_remote_list_defined_networks_args (XDR *, remote_list_defined_networks_args*);
-extern bool_t xdr_remote_list_defined_networks_ret (XDR *, remote_list_defined_networks_ret*);
-extern bool_t xdr_remote_network_lookup_by_uuid_args (XDR *, remote_network_lookup_by_uuid_args*);
-extern bool_t xdr_remote_network_lookup_by_uuid_ret (XDR *, remote_network_lookup_by_uuid_ret*);
-extern bool_t xdr_remote_network_lookup_by_name_args (XDR *, remote_network_lookup_by_name_args*);
-extern bool_t xdr_remote_network_lookup_by_name_ret (XDR *, remote_network_lookup_by_name_ret*);
-extern bool_t xdr_remote_network_create_xml_args (XDR *, remote_network_create_xml_args*);
-extern bool_t xdr_remote_network_create_xml_ret (XDR *, remote_network_create_xml_ret*);
-extern bool_t xdr_remote_network_define_xml_args (XDR *, remote_network_define_xml_args*);
-extern bool_t xdr_remote_network_define_xml_ret (XDR *, remote_network_define_xml_ret*);
-extern bool_t xdr_remote_network_undefine_args (XDR *, remote_network_undefine_args*);
-extern bool_t xdr_remote_network_create_args (XDR *, remote_network_create_args*);
-extern bool_t xdr_remote_network_destroy_args (XDR *, remote_network_destroy_args*);
-extern bool_t xdr_remote_network_dump_xml_args (XDR *, remote_network_dump_xml_args*);
-extern bool_t xdr_remote_network_dump_xml_ret (XDR *, remote_network_dump_xml_ret*);
-extern bool_t xdr_remote_network_get_bridge_name_args (XDR *, remote_network_get_bridge_name_args*);
-extern bool_t xdr_remote_network_get_bridge_name_ret (XDR *, remote_network_get_bridge_name_ret*);
-extern bool_t xdr_remote_network_get_autostart_args (XDR *, remote_network_get_autostart_args*);
-extern bool_t xdr_remote_network_get_autostart_ret (XDR *, remote_network_get_autostart_ret*);
-extern bool_t xdr_remote_network_set_autostart_args (XDR *, remote_network_set_autostart_args*);
-extern bool_t xdr_remote_num_of_interfaces_ret (XDR *, remote_num_of_interfaces_ret*);
-extern bool_t xdr_remote_list_interfaces_args (XDR *, remote_list_interfaces_args*);
-extern bool_t xdr_remote_list_interfaces_ret (XDR *, remote_list_interfaces_ret*);
-extern bool_t xdr_remote_num_of_defined_interfaces_ret (XDR *, remote_num_of_defined_interfaces_ret*);
-extern bool_t xdr_remote_list_defined_interfaces_args (XDR *, remote_list_defined_interfaces_args*);
-extern bool_t xdr_remote_list_defined_interfaces_ret (XDR *, remote_list_defined_interfaces_ret*);
-extern bool_t xdr_remote_interface_lookup_by_name_args (XDR *, remote_interface_lookup_by_name_args*);
-extern bool_t xdr_remote_interface_lookup_by_name_ret (XDR *, remote_interface_lookup_by_name_ret*);
-extern bool_t xdr_remote_interface_lookup_by_mac_string_args (XDR *, remote_interface_lookup_by_mac_string_args*);
-extern bool_t xdr_remote_interface_lookup_by_mac_string_ret (XDR *, remote_interface_lookup_by_mac_string_ret*);
-extern bool_t xdr_remote_interface_get_xml_desc_args (XDR *, remote_interface_get_xml_desc_args*);
-extern bool_t xdr_remote_interface_get_xml_desc_ret (XDR *, remote_interface_get_xml_desc_ret*);
-extern bool_t xdr_remote_interface_define_xml_args (XDR *, remote_interface_define_xml_args*);
-extern bool_t xdr_remote_interface_define_xml_ret (XDR *, remote_interface_define_xml_ret*);
-extern bool_t xdr_remote_interface_undefine_args (XDR *, remote_interface_undefine_args*);
-extern bool_t xdr_remote_interface_create_args (XDR *, remote_interface_create_args*);
-extern bool_t xdr_remote_interface_destroy_args (XDR *, remote_interface_destroy_args*);
-extern bool_t xdr_remote_auth_list_ret (XDR *, remote_auth_list_ret*);
-extern bool_t xdr_remote_auth_sasl_init_ret (XDR *, remote_auth_sasl_init_ret*);
-extern bool_t xdr_remote_auth_sasl_start_args (XDR *, remote_auth_sasl_start_args*);
-extern bool_t xdr_remote_auth_sasl_start_ret (XDR *, remote_auth_sasl_start_ret*);
-extern bool_t xdr_remote_auth_sasl_step_args (XDR *, remote_auth_sasl_step_args*);
-extern bool_t xdr_remote_auth_sasl_step_ret (XDR *, remote_auth_sasl_step_ret*);
-extern bool_t xdr_remote_auth_polkit_ret (XDR *, remote_auth_polkit_ret*);
-extern bool_t xdr_remote_num_of_storage_pools_ret (XDR *, remote_num_of_storage_pools_ret*);
-extern bool_t xdr_remote_list_storage_pools_args (XDR *, remote_list_storage_pools_args*);
-extern bool_t xdr_remote_list_storage_pools_ret (XDR *, remote_list_storage_pools_ret*);
-extern bool_t xdr_remote_num_of_defined_storage_pools_ret (XDR *, remote_num_of_defined_storage_pools_ret*);
-extern bool_t xdr_remote_list_defined_storage_pools_args (XDR *, remote_list_defined_storage_pools_args*);
-extern bool_t xdr_remote_list_defined_storage_pools_ret (XDR *, remote_list_defined_storage_pools_ret*);
-extern bool_t xdr_remote_find_storage_pool_sources_args (XDR *, remote_find_storage_pool_sources_args*);
-extern bool_t xdr_remote_find_storage_pool_sources_ret (XDR *, remote_find_storage_pool_sources_ret*);
-extern bool_t xdr_remote_storage_pool_lookup_by_uuid_args (XDR *, remote_storage_pool_lookup_by_uuid_args*);
-extern bool_t xdr_remote_storage_pool_lookup_by_uuid_ret (XDR *, remote_storage_pool_lookup_by_uuid_ret*);
-extern bool_t xdr_remote_storage_pool_lookup_by_name_args (XDR *, remote_storage_pool_lookup_by_name_args*);
-extern bool_t xdr_remote_storage_pool_lookup_by_name_ret (XDR *, remote_storage_pool_lookup_by_name_ret*);
-extern bool_t xdr_remote_storage_pool_lookup_by_volume_args (XDR *, remote_storage_pool_lookup_by_volume_args*);
-extern bool_t xdr_remote_storage_pool_lookup_by_volume_ret (XDR *, remote_storage_pool_lookup_by_volume_ret*);
-extern bool_t xdr_remote_storage_pool_create_xml_args (XDR *, remote_storage_pool_create_xml_args*);
-extern bool_t xdr_remote_storage_pool_create_xml_ret (XDR *, remote_storage_pool_create_xml_ret*);
-extern bool_t xdr_remote_storage_pool_define_xml_args (XDR *, remote_storage_pool_define_xml_args*);
-extern bool_t xdr_remote_storage_pool_define_xml_ret (XDR *, remote_storage_pool_define_xml_ret*);
-extern bool_t xdr_remote_storage_pool_build_args (XDR *, remote_storage_pool_build_args*);
-extern bool_t xdr_remote_storage_pool_undefine_args (XDR *, remote_storage_pool_undefine_args*);
-extern bool_t xdr_remote_storage_pool_create_args (XDR *, remote_storage_pool_create_args*);
-extern bool_t xdr_remote_storage_pool_destroy_args (XDR *, remote_storage_pool_destroy_args*);
-extern bool_t xdr_remote_storage_pool_delete_args (XDR *, remote_storage_pool_delete_args*);
-extern bool_t xdr_remote_storage_pool_refresh_args (XDR *, remote_storage_pool_refresh_args*);
-extern bool_t xdr_remote_storage_pool_dump_xml_args (XDR *, remote_storage_pool_dump_xml_args*);
-extern bool_t xdr_remote_storage_pool_dump_xml_ret (XDR *, remote_storage_pool_dump_xml_ret*);
-extern bool_t xdr_remote_storage_pool_get_info_args (XDR *, remote_storage_pool_get_info_args*);
-extern bool_t xdr_remote_storage_pool_get_info_ret (XDR *, remote_storage_pool_get_info_ret*);
-extern bool_t xdr_remote_storage_pool_get_autostart_args (XDR *, remote_storage_pool_get_autostart_args*);
-extern bool_t xdr_remote_storage_pool_get_autostart_ret (XDR *, remote_storage_pool_get_autostart_ret*);
-extern bool_t xdr_remote_storage_pool_set_autostart_args (XDR *, remote_storage_pool_set_autostart_args*);
-extern bool_t xdr_remote_storage_pool_num_of_volumes_args (XDR *, remote_storage_pool_num_of_volumes_args*);
-extern bool_t xdr_remote_storage_pool_num_of_volumes_ret (XDR *, remote_storage_pool_num_of_volumes_ret*);
-extern bool_t xdr_remote_storage_pool_list_volumes_args (XDR *, remote_storage_pool_list_volumes_args*);
-extern bool_t xdr_remote_storage_pool_list_volumes_ret (XDR *, remote_storage_pool_list_volumes_ret*);
-extern bool_t xdr_remote_storage_vol_lookup_by_name_args (XDR *, remote_storage_vol_lookup_by_name_args*);
-extern bool_t xdr_remote_storage_vol_lookup_by_name_ret (XDR *, remote_storage_vol_lookup_by_name_ret*);
-extern bool_t xdr_remote_storage_vol_lookup_by_key_args (XDR *, remote_storage_vol_lookup_by_key_args*);
-extern bool_t xdr_remote_storage_vol_lookup_by_key_ret (XDR *, remote_storage_vol_lookup_by_key_ret*);
-extern bool_t xdr_remote_storage_vol_lookup_by_path_args (XDR *, remote_storage_vol_lookup_by_path_args*);
-extern bool_t xdr_remote_storage_vol_lookup_by_path_ret (XDR *, remote_storage_vol_lookup_by_path_ret*);
-extern bool_t xdr_remote_storage_vol_create_xml_args (XDR *, remote_storage_vol_create_xml_args*);
-extern bool_t xdr_remote_storage_vol_create_xml_ret (XDR *, remote_storage_vol_create_xml_ret*);
-extern bool_t xdr_remote_storage_vol_create_xml_from_args (XDR *, remote_storage_vol_create_xml_from_args*);
-extern bool_t xdr_remote_storage_vol_create_xml_from_ret (XDR *, remote_storage_vol_create_xml_from_ret*);
-extern bool_t xdr_remote_storage_vol_delete_args (XDR *, remote_storage_vol_delete_args*);
-extern bool_t xdr_remote_storage_vol_dump_xml_args (XDR *, remote_storage_vol_dump_xml_args*);
-extern bool_t xdr_remote_storage_vol_dump_xml_ret (XDR *, remote_storage_vol_dump_xml_ret*);
-extern bool_t xdr_remote_storage_vol_get_info_args (XDR *, remote_storage_vol_get_info_args*);
-extern bool_t xdr_remote_storage_vol_get_info_ret (XDR *, remote_storage_vol_get_info_ret*);
-extern bool_t xdr_remote_storage_vol_get_path_args (XDR *, remote_storage_vol_get_path_args*);
-extern bool_t xdr_remote_storage_vol_get_path_ret (XDR *, remote_storage_vol_get_path_ret*);
-extern bool_t xdr_remote_node_num_of_devices_args (XDR *, remote_node_num_of_devices_args*);
-extern bool_t xdr_remote_node_num_of_devices_ret (XDR *, remote_node_num_of_devices_ret*);
-extern bool_t xdr_remote_node_list_devices_args (XDR *, remote_node_list_devices_args*);
-extern bool_t xdr_remote_node_list_devices_ret (XDR *, remote_node_list_devices_ret*);
-extern bool_t xdr_remote_node_device_lookup_by_name_args (XDR *, remote_node_device_lookup_by_name_args*);
-extern bool_t xdr_remote_node_device_lookup_by_name_ret (XDR *, remote_node_device_lookup_by_name_ret*);
-extern bool_t xdr_remote_node_device_dump_xml_args (XDR *, remote_node_device_dump_xml_args*);
-extern bool_t xdr_remote_node_device_dump_xml_ret (XDR *, remote_node_device_dump_xml_ret*);
-extern bool_t xdr_remote_node_device_get_parent_args (XDR *, remote_node_device_get_parent_args*);
-extern bool_t xdr_remote_node_device_get_parent_ret (XDR *, remote_node_device_get_parent_ret*);
-extern bool_t xdr_remote_node_device_num_of_caps_args (XDR *, remote_node_device_num_of_caps_args*);
-extern bool_t xdr_remote_node_device_num_of_caps_ret (XDR *, remote_node_device_num_of_caps_ret*);
-extern bool_t xdr_remote_node_device_list_caps_args (XDR *, remote_node_device_list_caps_args*);
-extern bool_t xdr_remote_node_device_list_caps_ret (XDR *, remote_node_device_list_caps_ret*);
-extern bool_t xdr_remote_node_device_dettach_args (XDR *, remote_node_device_dettach_args*);
-extern bool_t xdr_remote_node_device_re_attach_args (XDR *, remote_node_device_re_attach_args*);
-extern bool_t xdr_remote_node_device_reset_args (XDR *, remote_node_device_reset_args*);
-extern bool_t xdr_remote_node_device_create_xml_args (XDR *, remote_node_device_create_xml_args*);
-extern bool_t xdr_remote_node_device_create_xml_ret (XDR *, remote_node_device_create_xml_ret*);
-extern bool_t xdr_remote_node_device_destroy_args (XDR *, remote_node_device_destroy_args*);
-extern bool_t xdr_remote_domain_events_register_ret (XDR *, remote_domain_events_register_ret*);
-extern bool_t xdr_remote_domain_events_deregister_ret (XDR *, remote_domain_events_deregister_ret*);
-extern bool_t xdr_remote_domain_event_msg (XDR *, remote_domain_event_msg*);
-extern bool_t xdr_remote_domain_xml_from_native_args (XDR *, remote_domain_xml_from_native_args*);
-extern bool_t xdr_remote_domain_xml_from_native_ret (XDR *, remote_domain_xml_from_native_ret*);
-extern bool_t xdr_remote_domain_xml_to_native_args (XDR *, remote_domain_xml_to_native_args*);
-extern bool_t xdr_remote_domain_xml_to_native_ret (XDR *, remote_domain_xml_to_native_ret*);
-extern bool_t xdr_remote_num_of_secrets_ret (XDR *, remote_num_of_secrets_ret*);
-extern bool_t xdr_remote_list_secrets_args (XDR *, remote_list_secrets_args*);
-extern bool_t xdr_remote_list_secrets_ret (XDR *, remote_list_secrets_ret*);
-extern bool_t xdr_remote_secret_lookup_by_uuid_args (XDR *, remote_secret_lookup_by_uuid_args*);
-extern bool_t xdr_remote_secret_lookup_by_uuid_ret (XDR *, remote_secret_lookup_by_uuid_ret*);
-extern bool_t xdr_remote_secret_define_xml_args (XDR *, remote_secret_define_xml_args*);
-extern bool_t xdr_remote_secret_define_xml_ret (XDR *, remote_secret_define_xml_ret*);
-extern bool_t xdr_remote_secret_get_xml_desc_args (XDR *, remote_secret_get_xml_desc_args*);
-extern bool_t xdr_remote_secret_get_xml_desc_ret (XDR *, remote_secret_get_xml_desc_ret*);
-extern bool_t xdr_remote_secret_set_value_args (XDR *, remote_secret_set_value_args*);
-extern bool_t xdr_remote_secret_get_value_args (XDR *, remote_secret_get_value_args*);
-extern bool_t xdr_remote_secret_get_value_ret (XDR *, remote_secret_get_value_ret*);
-extern bool_t xdr_remote_secret_undefine_args (XDR *, remote_secret_undefine_args*);
-extern bool_t xdr_remote_secret_lookup_by_usage_args (XDR *, remote_secret_lookup_by_usage_args*);
-extern bool_t xdr_remote_secret_lookup_by_usage_ret (XDR *, remote_secret_lookup_by_usage_ret*);
-extern bool_t xdr_remote_procedure (XDR *, remote_procedure*);
-extern bool_t xdr_remote_message_type (XDR *, remote_message_type*);
-extern bool_t xdr_remote_message_status (XDR *, remote_message_status*);
-extern bool_t xdr_remote_message_header (XDR *, remote_message_header*);
-
-#else /* K&R C */
-extern bool_t xdr_remote_nonnull_string ();
-extern bool_t xdr_remote_string ();
-extern bool_t xdr_remote_uuid ();
-extern bool_t xdr_remote_nonnull_domain ();
-extern bool_t xdr_remote_nonnull_network ();
-extern bool_t xdr_remote_nonnull_interface ();
-extern bool_t xdr_remote_nonnull_storage_pool ();
-extern bool_t xdr_remote_nonnull_storage_vol ();
-extern bool_t xdr_remote_nonnull_node_device ();
-extern bool_t xdr_remote_nonnull_secret ();
-extern bool_t xdr_remote_domain ();
-extern bool_t xdr_remote_network ();
-extern bool_t xdr_remote_storage_pool ();
-extern bool_t xdr_remote_storage_vol ();
-extern bool_t xdr_remote_node_device ();
-extern bool_t xdr_remote_error ();
-extern bool_t xdr_remote_auth_type ();
-extern bool_t xdr_remote_vcpu_info ();
-extern bool_t xdr_remote_sched_param_value ();
-extern bool_t xdr_remote_sched_param ();
-extern bool_t xdr_remote_open_args ();
-extern bool_t xdr_remote_supports_feature_args ();
-extern bool_t xdr_remote_supports_feature_ret ();
-extern bool_t xdr_remote_get_type_ret ();
-extern bool_t xdr_remote_get_version_ret ();
-extern bool_t xdr_remote_get_hostname_ret ();
-extern bool_t xdr_remote_get_uri_ret ();
-extern bool_t xdr_remote_get_max_vcpus_args ();
-extern bool_t xdr_remote_get_max_vcpus_ret ();
-extern bool_t xdr_remote_node_get_info_ret ();
-extern bool_t xdr_remote_get_capabilities_ret ();
-extern bool_t xdr_remote_node_get_cells_free_memory_args ();
-extern bool_t xdr_remote_node_get_cells_free_memory_ret ();
-extern bool_t xdr_remote_node_get_free_memory_ret ();
-extern bool_t xdr_remote_domain_get_scheduler_type_args ();
-extern bool_t xdr_remote_domain_get_scheduler_type_ret ();
-extern bool_t xdr_remote_domain_get_scheduler_parameters_args ();
-extern bool_t xdr_remote_domain_get_scheduler_parameters_ret ();
-extern bool_t xdr_remote_domain_set_scheduler_parameters_args ();
-extern bool_t xdr_remote_domain_block_stats_args ();
-extern bool_t xdr_remote_domain_block_stats_ret ();
-extern bool_t xdr_remote_domain_interface_stats_args ();
-extern bool_t xdr_remote_domain_interface_stats_ret ();
-extern bool_t xdr_remote_domain_block_peek_args ();
-extern bool_t xdr_remote_domain_block_peek_ret ();
-extern bool_t xdr_remote_domain_memory_peek_args ();
-extern bool_t xdr_remote_domain_memory_peek_ret ();
-extern bool_t xdr_remote_list_domains_args ();
-extern bool_t xdr_remote_list_domains_ret ();
-extern bool_t xdr_remote_num_of_domains_ret ();
-extern bool_t xdr_remote_domain_create_xml_args ();
-extern bool_t xdr_remote_domain_create_xml_ret ();
-extern bool_t xdr_remote_domain_lookup_by_id_args ();
-extern bool_t xdr_remote_domain_lookup_by_id_ret ();
-extern bool_t xdr_remote_domain_lookup_by_uuid_args ();
-extern bool_t xdr_remote_domain_lookup_by_uuid_ret ();
-extern bool_t xdr_remote_domain_lookup_by_name_args ();
-extern bool_t xdr_remote_domain_lookup_by_name_ret ();
-extern bool_t xdr_remote_domain_suspend_args ();
-extern bool_t xdr_remote_domain_resume_args ();
-extern bool_t xdr_remote_domain_shutdown_args ();
-extern bool_t xdr_remote_domain_reboot_args ();
-extern bool_t xdr_remote_domain_destroy_args ();
-extern bool_t xdr_remote_domain_get_os_type_args ();
-extern bool_t xdr_remote_domain_get_os_type_ret ();
-extern bool_t xdr_remote_domain_get_max_memory_args ();
-extern bool_t xdr_remote_domain_get_max_memory_ret ();
-extern bool_t xdr_remote_domain_set_max_memory_args ();
-extern bool_t xdr_remote_domain_set_memory_args ();
-extern bool_t xdr_remote_domain_get_info_args ();
-extern bool_t xdr_remote_domain_get_info_ret ();
-extern bool_t xdr_remote_domain_save_args ();
-extern bool_t xdr_remote_domain_restore_args ();
-extern bool_t xdr_remote_domain_core_dump_args ();
-extern bool_t xdr_remote_domain_dump_xml_args ();
-extern bool_t xdr_remote_domain_dump_xml_ret ();
-extern bool_t xdr_remote_domain_migrate_prepare_args ();
-extern bool_t xdr_remote_domain_migrate_prepare_ret ();
-extern bool_t xdr_remote_domain_migrate_perform_args ();
-extern bool_t xdr_remote_domain_migrate_finish_args ();
-extern bool_t xdr_remote_domain_migrate_finish_ret ();
-extern bool_t xdr_remote_domain_migrate_prepare2_args ();
-extern bool_t xdr_remote_domain_migrate_prepare2_ret ();
-extern bool_t xdr_remote_domain_migrate_finish2_args ();
-extern bool_t xdr_remote_domain_migrate_finish2_ret ();
-extern bool_t xdr_remote_list_defined_domains_args ();
-extern bool_t xdr_remote_list_defined_domains_ret ();
-extern bool_t xdr_remote_num_of_defined_domains_ret ();
-extern bool_t xdr_remote_domain_create_args ();
-extern bool_t xdr_remote_domain_define_xml_args ();
-extern bool_t xdr_remote_domain_define_xml_ret ();
-extern bool_t xdr_remote_domain_undefine_args ();
-extern bool_t xdr_remote_domain_set_vcpus_args ();
-extern bool_t xdr_remote_domain_pin_vcpu_args ();
-extern bool_t xdr_remote_domain_get_vcpus_args ();
-extern bool_t xdr_remote_domain_get_vcpus_ret ();
-extern bool_t xdr_remote_domain_get_max_vcpus_args ();
-extern bool_t xdr_remote_domain_get_max_vcpus_ret ();
-extern bool_t xdr_remote_domain_get_security_label_args ();
-extern bool_t xdr_remote_domain_get_security_label_ret ();
-extern bool_t xdr_remote_node_get_security_model_ret ();
-extern bool_t xdr_remote_domain_attach_device_args ();
-extern bool_t xdr_remote_domain_detach_device_args ();
-extern bool_t xdr_remote_domain_get_autostart_args ();
-extern bool_t xdr_remote_domain_get_autostart_ret ();
-extern bool_t xdr_remote_domain_set_autostart_args ();
-extern bool_t xdr_remote_num_of_networks_ret ();
-extern bool_t xdr_remote_list_networks_args ();
-extern bool_t xdr_remote_list_networks_ret ();
-extern bool_t xdr_remote_num_of_defined_networks_ret ();
-extern bool_t xdr_remote_list_defined_networks_args ();
-extern bool_t xdr_remote_list_defined_networks_ret ();
-extern bool_t xdr_remote_network_lookup_by_uuid_args ();
-extern bool_t xdr_remote_network_lookup_by_uuid_ret ();
-extern bool_t xdr_remote_network_lookup_by_name_args ();
-extern bool_t xdr_remote_network_lookup_by_name_ret ();
-extern bool_t xdr_remote_network_create_xml_args ();
-extern bool_t xdr_remote_network_create_xml_ret ();
-extern bool_t xdr_remote_network_define_xml_args ();
-extern bool_t xdr_remote_network_define_xml_ret ();
-extern bool_t xdr_remote_network_undefine_args ();
-extern bool_t xdr_remote_network_create_args ();
-extern bool_t xdr_remote_network_destroy_args ();
-extern bool_t xdr_remote_network_dump_xml_args ();
-extern bool_t xdr_remote_network_dump_xml_ret ();
-extern bool_t xdr_remote_network_get_bridge_name_args ();
-extern bool_t xdr_remote_network_get_bridge_name_ret ();
-extern bool_t xdr_remote_network_get_autostart_args ();
-extern bool_t xdr_remote_network_get_autostart_ret ();
-extern bool_t xdr_remote_network_set_autostart_args ();
-extern bool_t xdr_remote_num_of_interfaces_ret ();
-extern bool_t xdr_remote_list_interfaces_args ();
-extern bool_t xdr_remote_list_interfaces_ret ();
-extern bool_t xdr_remote_num_of_defined_interfaces_ret ();
-extern bool_t xdr_remote_list_defined_interfaces_args ();
-extern bool_t xdr_remote_list_defined_interfaces_ret ();
-extern bool_t xdr_remote_interface_lookup_by_name_args ();
-extern bool_t xdr_remote_interface_lookup_by_name_ret ();
-extern bool_t xdr_remote_interface_lookup_by_mac_string_args ();
-extern bool_t xdr_remote_interface_lookup_by_mac_string_ret ();
-extern bool_t xdr_remote_interface_get_xml_desc_args ();
-extern bool_t xdr_remote_interface_get_xml_desc_ret ();
-extern bool_t xdr_remote_interface_define_xml_args ();
-extern bool_t xdr_remote_interface_define_xml_ret ();
-extern bool_t xdr_remote_interface_undefine_args ();
-extern bool_t xdr_remote_interface_create_args ();
-extern bool_t xdr_remote_interface_destroy_args ();
-extern bool_t xdr_remote_auth_list_ret ();
-extern bool_t xdr_remote_auth_sasl_init_ret ();
-extern bool_t xdr_remote_auth_sasl_start_args ();
-extern bool_t xdr_remote_auth_sasl_start_ret ();
-extern bool_t xdr_remote_auth_sasl_step_args ();
-extern bool_t xdr_remote_auth_sasl_step_ret ();
-extern bool_t xdr_remote_auth_polkit_ret ();
-extern bool_t xdr_remote_num_of_storage_pools_ret ();
-extern bool_t xdr_remote_list_storage_pools_args ();
-extern bool_t xdr_remote_list_storage_pools_ret ();
-extern bool_t xdr_remote_num_of_defined_storage_pools_ret ();
-extern bool_t xdr_remote_list_defined_storage_pools_args ();
-extern bool_t xdr_remote_list_defined_storage_pools_ret ();
-extern bool_t xdr_remote_find_storage_pool_sources_args ();
-extern bool_t xdr_remote_find_storage_pool_sources_ret ();
-extern bool_t xdr_remote_storage_pool_lookup_by_uuid_args ();
-extern bool_t xdr_remote_storage_pool_lookup_by_uuid_ret ();
-extern bool_t xdr_remote_storage_pool_lookup_by_name_args ();
-extern bool_t xdr_remote_storage_pool_lookup_by_name_ret ();
-extern bool_t xdr_remote_storage_pool_lookup_by_volume_args ();
-extern bool_t xdr_remote_storage_pool_lookup_by_volume_ret ();
-extern bool_t xdr_remote_storage_pool_create_xml_args ();
-extern bool_t xdr_remote_storage_pool_create_xml_ret ();
-extern bool_t xdr_remote_storage_pool_define_xml_args ();
-extern bool_t xdr_remote_storage_pool_define_xml_ret ();
-extern bool_t xdr_remote_storage_pool_build_args ();
-extern bool_t xdr_remote_storage_pool_undefine_args ();
-extern bool_t xdr_remote_storage_pool_create_args ();
-extern bool_t xdr_remote_storage_pool_destroy_args ();
-extern bool_t xdr_remote_storage_pool_delete_args ();
-extern bool_t xdr_remote_storage_pool_refresh_args ();
-extern bool_t xdr_remote_storage_pool_dump_xml_args ();
-extern bool_t xdr_remote_storage_pool_dump_xml_ret ();
-extern bool_t xdr_remote_storage_pool_get_info_args ();
-extern bool_t xdr_remote_storage_pool_get_info_ret ();
-extern bool_t xdr_remote_storage_pool_get_autostart_args ();
-extern bool_t xdr_remote_storage_pool_get_autostart_ret ();
-extern bool_t xdr_remote_storage_pool_set_autostart_args ();
-extern bool_t xdr_remote_storage_pool_num_of_volumes_args ();
-extern bool_t xdr_remote_storage_pool_num_of_volumes_ret ();
-extern bool_t xdr_remote_storage_pool_list_volumes_args ();
-extern bool_t xdr_remote_storage_pool_list_volumes_ret ();
-extern bool_t xdr_remote_storage_vol_lookup_by_name_args ();
-extern bool_t xdr_remote_storage_vol_lookup_by_name_ret ();
-extern bool_t xdr_remote_storage_vol_lookup_by_key_args ();
-extern bool_t xdr_remote_storage_vol_lookup_by_key_ret ();
-extern bool_t xdr_remote_storage_vol_lookup_by_path_args ();
-extern bool_t xdr_remote_storage_vol_lookup_by_path_ret ();
-extern bool_t xdr_remote_storage_vol_create_xml_args ();
-extern bool_t xdr_remote_storage_vol_create_xml_ret ();
-extern bool_t xdr_remote_storage_vol_create_xml_from_args ();
-extern bool_t xdr_remote_storage_vol_create_xml_from_ret ();
-extern bool_t xdr_remote_storage_vol_delete_args ();
-extern bool_t xdr_remote_storage_vol_dump_xml_args ();
-extern bool_t xdr_remote_storage_vol_dump_xml_ret ();
-extern bool_t xdr_remote_storage_vol_get_info_args ();
-extern bool_t xdr_remote_storage_vol_get_info_ret ();
-extern bool_t xdr_remote_storage_vol_get_path_args ();
-extern bool_t xdr_remote_storage_vol_get_path_ret ();
-extern bool_t xdr_remote_node_num_of_devices_args ();
-extern bool_t xdr_remote_node_num_of_devices_ret ();
-extern bool_t xdr_remote_node_list_devices_args ();
-extern bool_t xdr_remote_node_list_devices_ret ();
-extern bool_t xdr_remote_node_device_lookup_by_name_args ();
-extern bool_t xdr_remote_node_device_lookup_by_name_ret ();
-extern bool_t xdr_remote_node_device_dump_xml_args ();
-extern bool_t xdr_remote_node_device_dump_xml_ret ();
-extern bool_t xdr_remote_node_device_get_parent_args ();
-extern bool_t xdr_remote_node_device_get_parent_ret ();
-extern bool_t xdr_remote_node_device_num_of_caps_args ();
-extern bool_t xdr_remote_node_device_num_of_caps_ret ();
-extern bool_t xdr_remote_node_device_list_caps_args ();
-extern bool_t xdr_remote_node_device_list_caps_ret ();
-extern bool_t xdr_remote_node_device_dettach_args ();
-extern bool_t xdr_remote_node_device_re_attach_args ();
-extern bool_t xdr_remote_node_device_reset_args ();
-extern bool_t xdr_remote_node_device_create_xml_args ();
-extern bool_t xdr_remote_node_device_create_xml_ret ();
-extern bool_t xdr_remote_node_device_destroy_args ();
-extern bool_t xdr_remote_domain_events_register_ret ();
-extern bool_t xdr_remote_domain_events_deregister_ret ();
-extern bool_t xdr_remote_domain_event_msg ();
-extern bool_t xdr_remote_domain_xml_from_native_args ();
-extern bool_t xdr_remote_domain_xml_from_native_ret ();
-extern bool_t xdr_remote_domain_xml_to_native_args ();
-extern bool_t xdr_remote_domain_xml_to_native_ret ();
-extern bool_t xdr_remote_num_of_secrets_ret ();
-extern bool_t xdr_remote_list_secrets_args ();
-extern bool_t xdr_remote_list_secrets_ret ();
-extern bool_t xdr_remote_secret_lookup_by_uuid_args ();
-extern bool_t xdr_remote_secret_lookup_by_uuid_ret ();
-extern bool_t xdr_remote_secret_define_xml_args ();
-extern bool_t xdr_remote_secret_define_xml_ret ();
-extern bool_t xdr_remote_secret_get_xml_desc_args ();
-extern bool_t xdr_remote_secret_get_xml_desc_ret ();
-extern bool_t xdr_remote_secret_set_value_args ();
-extern bool_t xdr_remote_secret_get_value_args ();
-extern bool_t xdr_remote_secret_get_value_ret ();
-extern bool_t xdr_remote_secret_undefine_args ();
-extern bool_t xdr_remote_secret_lookup_by_usage_args ();
-extern bool_t xdr_remote_secret_lookup_by_usage_ret ();
-extern bool_t xdr_remote_procedure ();
-extern bool_t xdr_remote_message_type ();
-extern bool_t xdr_remote_message_status ();
-extern bool_t xdr_remote_message_header ();
-
-#endif /* K&R C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !_RP_H_RPCGEN */
+++ /dev/null
-/* -*- c -*-
- * remote_protocol.x: private protocol for communicating between
- * remote_internal driver and libvirtd. This protocol is
- * internal and may change at any time.
- *
- * Copyright (C) 2006-2008 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 Jones <rjones@redhat.com>
- */
-
-/* Notes:
- *
- * (1) The protocol is internal and may change at any time, without
- * notice. Do not use it. Instead link to libvirt and use the remote
- * driver.
- *
- * (2) See bottom of this file for a description of the home-brew RPC.
- *
- * (3) Authentication/encryption is done outside this protocol.
- *
- * (4) For namespace reasons, all exported names begin 'remote_' or
- * 'REMOTE_'. This makes names quite long.
- */
-
-%#include "internal.h"
-%#include <arpa/inet.h>
-
-/*----- Data types. -----*/
-
-/* Maximum total message size (serialised). */
-const REMOTE_MESSAGE_MAX = 262144;
-
-/* Length of long, but not unbounded, strings.
- * This is an arbitrary limit designed to stop the decoder from trying
- * to allocate unbounded amounts of memory when fed with a bad message.
- */
-const REMOTE_STRING_MAX = 65536;
-
-/* A long string, which may NOT be NULL. */
-typedef string remote_nonnull_string<REMOTE_STRING_MAX>;
-
-/* A long string, which may be NULL. */
-typedef remote_nonnull_string *remote_string;
-
-/* This just places an upper limit on the length of lists of
- * domain IDs which may be sent via the protocol.
- */
-const REMOTE_DOMAIN_ID_LIST_MAX = 16384;
-
-/* Upper limit on lists of domain names. */
-const REMOTE_DOMAIN_NAME_LIST_MAX = 1024;
-
-/* Upper limit on cpumap (bytes) passed to virDomainPinVcpu. */
-const REMOTE_CPUMAP_MAX = 256;
-
-/* Upper limit on number of info fields returned by virDomainGetVcpus. */
-const REMOTE_VCPUINFO_MAX = 2048;
-
-/* Upper limit on cpumaps (bytes) passed to virDomainGetVcpus. */
-const REMOTE_CPUMAPS_MAX = 16384;
-
-/* Upper limit on migrate cookie. */
-const REMOTE_MIGRATE_COOKIE_MAX = 256;
-
-/* Upper limit on lists of network names. */
-const REMOTE_NETWORK_NAME_LIST_MAX = 256;
-
-/* Upper limit on lists of interface names. */
-const REMOTE_INTERFACE_NAME_LIST_MAX = 256;
-
-/* Upper limit on lists of defined interface names. */
-const REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX = 256;
-
-/* Upper limit on lists of storage pool names. */
-const REMOTE_STORAGE_POOL_NAME_LIST_MAX = 256;
-
-/* Upper limit on lists of storage vol names. */
-const REMOTE_STORAGE_VOL_NAME_LIST_MAX = 1024;
-
-/* Upper limit on lists of node device names. */
-const REMOTE_NODE_DEVICE_NAME_LIST_MAX = 16384;
-
-/* Upper limit on lists of node device capabilities. */
-const REMOTE_NODE_DEVICE_CAPS_LIST_MAX = 16384;
-
-/* Upper limit on list of scheduler parameters. */
-const REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX = 16;
-
-/* Upper limit on number of NUMA cells */
-const REMOTE_NODE_MAX_CELLS = 1024;
-
-/* Upper limit on SASL auth negotiation packet */
-const REMOTE_AUTH_SASL_DATA_MAX = 65536;
-
-/* Maximum number of auth types */
-const REMOTE_AUTH_TYPE_LIST_MAX = 20;
-
-/* Maximum length of a block peek buffer message.
- * Note applications need to be aware of this limit and issue multiple
- * requests for large amounts of data.
- */
-const REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX = 65536;
-
-/* Maximum length of a memory peek buffer message.
- * Note applications need to be aware of this limit and issue multiple
- * requests for large amounts of data.
- */
-const REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX = 65536;
-
-/*
- * Maximum length of a security model field.
- */
-const REMOTE_SECURITY_MODEL_MAX = VIR_SECURITY_MODEL_BUFLEN;
-
-/*
- * Maximum length of a security label field.
- */
-const REMOTE_SECURITY_LABEL_MAX = VIR_SECURITY_LABEL_BUFLEN;
-
-/*
- * Maximum length of a security DOI field.
- */
-const REMOTE_SECURITY_DOI_MAX = VIR_SECURITY_DOI_BUFLEN;
-
-/*
- * Maximum size of a secret value.
- */
-const REMOTE_SECRET_VALUE_MAX = 65536;
-
-/*
- * Upper limit on list of secrets.
- */
-const REMOTE_SECRET_UUID_LIST_MAX = 16384;
-
-/* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */
-typedef opaque remote_uuid[VIR_UUID_BUFLEN];
-
-/* A domain which may not be NULL. */
-struct remote_nonnull_domain {
- remote_nonnull_string name;
- remote_uuid uuid;
- int id;
-};
-
-/* A network which may not be NULL. */
-struct remote_nonnull_network {
- remote_nonnull_string name;
- remote_uuid uuid;
-};
-
-/* An interface which may not be NULL. */
-struct remote_nonnull_interface {
- remote_nonnull_string name;
- remote_nonnull_string mac;
-};
-
-/* A storage pool which may not be NULL. */
-struct remote_nonnull_storage_pool {
- remote_nonnull_string name;
- remote_uuid uuid;
-};
-
-/* A storage vol which may not be NULL. */
-struct remote_nonnull_storage_vol {
- remote_nonnull_string pool;
- remote_nonnull_string name;
- remote_nonnull_string key;
-};
-
-/* A node device which may not be NULL. */
-struct remote_nonnull_node_device {
- remote_nonnull_string name;
-};
-
-/* A secret which may not be null. */
-struct remote_nonnull_secret {
- remote_uuid uuid;
- int usageType;
- remote_nonnull_string usageID;
-};
-
-/* A domain or network which may be NULL. */
-typedef remote_nonnull_domain *remote_domain;
-typedef remote_nonnull_network *remote_network;
-typedef remote_nonnull_storage_pool *remote_storage_pool;
-typedef remote_nonnull_storage_vol *remote_storage_vol;
-typedef remote_nonnull_node_device *remote_node_device;
-
-/* Error message. See <virterror.h> for explanation of fields. */
-
-/* NB. Fields "code", "domain" and "level" are really enums. The
- * numeric value should remain compatible between libvirt and
- * libvirtd. This means, no changing or reordering the enums as
- * defined in <virterror.h> (but we don't do that anyway, for separate
- * ABI reasons).
- */
-struct remote_error {
- int code;
- int domain;
- remote_string message;
- int level;
- remote_domain dom;
- remote_string str1;
- remote_string str2;
- remote_string str3;
- int int1;
- int int2;
- remote_network net;
-};
-
-/* Authentication types available thus far.... */
-enum remote_auth_type {
- REMOTE_AUTH_NONE = 0,
- REMOTE_AUTH_SASL = 1,
- REMOTE_AUTH_POLKIT = 2
-};
-
-
-/* Wire encoding of virVcpuInfo. */
-struct remote_vcpu_info {
- unsigned int number;
- int state;
- unsigned hyper cpu_time;
- int cpu;
-};
-
-/* Wire encoding of virDomainSchedParameter.
- * Note the enum (type) which must remain binary compatible.
- */
-union remote_sched_param_value switch (int type) {
- case VIR_DOMAIN_SCHED_FIELD_INT:
- int i;
- case VIR_DOMAIN_SCHED_FIELD_UINT:
- unsigned int ui;
- case VIR_DOMAIN_SCHED_FIELD_LLONG:
- hyper l;
- case VIR_DOMAIN_SCHED_FIELD_ULLONG:
- unsigned hyper ul;
- case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
- double d;
- case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
- int b;
-};
-
-struct remote_sched_param {
- remote_nonnull_string field;
- remote_sched_param_value value;
-};
-
-/*----- Calls. -----*/
-
-/* For each call we may have a 'remote_CALL_args' and 'remote_CALL_ret'
- * type. These are omitted when they are void. The virConnectPtr
- * is not passed at all (it is inferred on the remote server from the
- * connection). Errors are returned implicitly in the RPC protocol.
- *
- * Please follow the naming convention carefully - this file is
- * parsed by 'remote_generate_stubs.pl'.
- */
-
-struct remote_open_args {
- /* NB. "name" might be NULL although in practice you can't
- * yet do that using the remote_internal driver.
- */
- remote_string name;
- int flags;
-};
-
-struct remote_supports_feature_args {
- int feature;
-};
-
-struct remote_supports_feature_ret {
- int supported;
-};
-
-struct remote_get_type_ret {
- remote_nonnull_string type;
-};
-
-struct remote_get_version_ret {
- hyper hv_ver;
-};
-
-struct remote_get_hostname_ret {
- remote_nonnull_string hostname;
-};
-
-struct remote_get_uri_ret {
- remote_nonnull_string uri;
-};
-
-struct remote_get_max_vcpus_args {
- /* The only backend which supports this call is Xen HV, and
- * there the type is ignored so it could be NULL.
- */
- remote_string type;
-};
-
-struct remote_get_max_vcpus_ret {
- int max_vcpus;
-};
-
-struct remote_node_get_info_ret {
- char model[32];
- hyper memory;
- int cpus;
- int mhz;
- int nodes;
- int sockets;
- int cores;
- int threads;
-};
-
-struct remote_get_capabilities_ret {
- remote_nonnull_string capabilities;
-};
-
-struct remote_node_get_cells_free_memory_args {
- int startCell;
- int maxCells;
-};
-
-struct remote_node_get_cells_free_memory_ret {
- hyper freeMems<REMOTE_NODE_MAX_CELLS>;
-};
-
-struct remote_node_get_free_memory_ret {
- hyper freeMem;
-};
-
-struct remote_domain_get_scheduler_type_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_scheduler_type_ret {
- remote_nonnull_string type;
- int nparams;
-};
-
-struct remote_domain_get_scheduler_parameters_args {
- remote_nonnull_domain dom;
- int nparams;
-};
-
-struct remote_domain_get_scheduler_parameters_ret {
- remote_sched_param params<REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX>;
-};
-
-struct remote_domain_set_scheduler_parameters_args {
- remote_nonnull_domain dom;
- remote_sched_param params<REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX>;
-};
-
-struct remote_domain_block_stats_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
-};
-
-struct remote_domain_block_stats_ret {
- hyper rd_req;
- hyper rd_bytes;
- hyper wr_req;
- hyper wr_bytes;
- hyper errs;
-};
-
-struct remote_domain_interface_stats_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
-};
-
-struct remote_domain_interface_stats_ret {
- hyper rx_bytes;
- hyper rx_packets;
- hyper rx_errs;
- hyper rx_drop;
- hyper tx_bytes;
- hyper tx_packets;
- hyper tx_errs;
- hyper tx_drop;
-};
-
-struct remote_domain_block_peek_args {
- remote_nonnull_domain dom;
- remote_nonnull_string path;
- unsigned hyper offset;
- unsigned size;
- unsigned flags;
-};
-
-struct remote_domain_block_peek_ret {
- opaque buffer<REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX>;
-};
-
-struct remote_domain_memory_peek_args {
- remote_nonnull_domain dom;
- unsigned hyper offset;
- unsigned size;
- unsigned flags;
-};
-
-struct remote_domain_memory_peek_ret {
- opaque buffer<REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX>;
-};
-
-struct remote_list_domains_args {
- int maxids;
-};
-
-struct remote_list_domains_ret {
- int ids<REMOTE_DOMAIN_ID_LIST_MAX>;
-};
-
-struct remote_num_of_domains_ret {
- int num;
-};
-
-struct remote_domain_create_xml_args {
- remote_nonnull_string xml_desc;
- int flags;
-};
-
-struct remote_domain_create_xml_ret {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_lookup_by_id_args {
- int id;
-};
-
-struct remote_domain_lookup_by_id_ret {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-
-struct remote_domain_lookup_by_uuid_ret {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_lookup_by_name_args {
- remote_nonnull_string name;
-};
-
-struct remote_domain_lookup_by_name_ret {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_suspend_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_resume_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_shutdown_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_reboot_args {
- remote_nonnull_domain dom;
- int flags;
-};
-
-struct remote_domain_destroy_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_os_type_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_os_type_ret {
- remote_nonnull_string type;
-};
-
-struct remote_domain_get_max_memory_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_max_memory_ret {
- unsigned hyper memory;
-};
-
-struct remote_domain_set_max_memory_args {
- remote_nonnull_domain dom;
- unsigned hyper memory;
-};
-
-struct remote_domain_set_memory_args {
- remote_nonnull_domain dom;
- unsigned hyper memory;
-};
-
-struct remote_domain_get_info_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_info_ret {
- unsigned char state;
- unsigned hyper max_mem;
- unsigned hyper memory;
- unsigned short nr_virt_cpu;
- unsigned hyper cpu_time;
-};
-
-struct remote_domain_save_args {
- remote_nonnull_domain dom;
- remote_nonnull_string to;
-};
-
-struct remote_domain_restore_args {
- remote_nonnull_string from;
-};
-
-struct remote_domain_core_dump_args {
- remote_nonnull_domain dom;
- remote_nonnull_string to;
- int flags;
-};
-
-struct remote_domain_dump_xml_args {
- remote_nonnull_domain dom;
- int flags;
-};
-
-struct remote_domain_dump_xml_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_domain_migrate_prepare_args {
- remote_string uri_in;
- unsigned hyper flags;
- remote_string dname;
- unsigned hyper resource;
-};
-
-struct remote_domain_migrate_prepare_ret {
- opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
- remote_string uri_out;
-};
-
-struct remote_domain_migrate_perform_args {
- remote_nonnull_domain dom;
- opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
- remote_nonnull_string uri;
- unsigned hyper flags;
- remote_string dname;
- unsigned hyper resource;
-};
-
-struct remote_domain_migrate_finish_args {
- remote_nonnull_string dname;
- opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
- remote_nonnull_string uri;
- unsigned hyper flags;
-};
-
-struct remote_domain_migrate_finish_ret {
- remote_nonnull_domain ddom;
-};
-
-struct remote_domain_migrate_prepare2_args {
- remote_string uri_in;
- unsigned hyper flags;
- remote_string dname;
- unsigned hyper resource;
- remote_nonnull_string dom_xml;
-};
-
-struct remote_domain_migrate_prepare2_ret {
- opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
- remote_string uri_out;
-};
-
-struct remote_domain_migrate_finish2_args {
- remote_nonnull_string dname;
- opaque cookie<REMOTE_MIGRATE_COOKIE_MAX>;
- remote_nonnull_string uri;
- unsigned hyper flags;
- int retcode;
-};
-
-struct remote_domain_migrate_finish2_ret {
- remote_nonnull_domain ddom;
-};
-
-struct remote_list_defined_domains_args {
- int maxnames;
-};
-
-struct remote_list_defined_domains_ret {
- remote_nonnull_string names<REMOTE_DOMAIN_NAME_LIST_MAX>;
-};
-
-struct remote_num_of_defined_domains_ret {
- int num;
-};
-
-struct remote_domain_create_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_define_xml_args {
- remote_nonnull_string xml;
-};
-
-struct remote_domain_define_xml_ret {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_undefine_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_set_vcpus_args {
- remote_nonnull_domain dom;
- int nvcpus;
-};
-
-struct remote_domain_pin_vcpu_args {
- remote_nonnull_domain dom;
- int vcpu;
- opaque cpumap<REMOTE_CPUMAP_MAX>;
-};
-
-struct remote_domain_get_vcpus_args {
- remote_nonnull_domain dom;
- int maxinfo;
- int maplen;
-};
-
-struct remote_domain_get_vcpus_ret {
- remote_vcpu_info info<REMOTE_VCPUINFO_MAX>;
- opaque cpumaps<REMOTE_CPUMAPS_MAX>;
-};
-
-struct remote_domain_get_max_vcpus_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_max_vcpus_ret {
- int num;
-};
-
-struct remote_domain_get_security_label_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_security_label_ret {
- char label<REMOTE_SECURITY_LABEL_MAX>;
- int enforcing;
-};
-
-struct remote_node_get_security_model_ret {
- char model<REMOTE_SECURITY_MODEL_MAX>;
- char doi<REMOTE_SECURITY_DOI_MAX>;
-};
-
-struct remote_domain_attach_device_args {
- remote_nonnull_domain dom;
- remote_nonnull_string xml;
-};
-
-struct remote_domain_detach_device_args {
- remote_nonnull_domain dom;
- remote_nonnull_string xml;
-};
-
-struct remote_domain_get_autostart_args {
- remote_nonnull_domain dom;
-};
-
-struct remote_domain_get_autostart_ret {
- int autostart;
-};
-
-struct remote_domain_set_autostart_args {
- remote_nonnull_domain dom;
- int autostart;
-};
-
-/* Network calls: */
-
-struct remote_num_of_networks_ret {
- int num;
-};
-
-struct remote_list_networks_args {
- int maxnames;
-};
-
-struct remote_list_networks_ret {
- remote_nonnull_string names<REMOTE_NETWORK_NAME_LIST_MAX>;
-};
-
-struct remote_num_of_defined_networks_ret {
- int num;
-};
-
-struct remote_list_defined_networks_args {
- int maxnames;
-};
-
-struct remote_list_defined_networks_ret {
- remote_nonnull_string names<REMOTE_NETWORK_NAME_LIST_MAX>;
-};
-
-struct remote_network_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-
-struct remote_network_lookup_by_uuid_ret {
- remote_nonnull_network net;
-};
-
-struct remote_network_lookup_by_name_args {
- remote_nonnull_string name;
-};
-
-struct remote_network_lookup_by_name_ret {
- remote_nonnull_network net;
-};
-
-struct remote_network_create_xml_args {
- remote_nonnull_string xml;
-};
-
-struct remote_network_create_xml_ret {
- remote_nonnull_network net;
-};
-
-struct remote_network_define_xml_args {
- remote_nonnull_string xml;
-};
-
-struct remote_network_define_xml_ret {
- remote_nonnull_network net;
-};
-
-struct remote_network_undefine_args {
- remote_nonnull_network net;
-};
-
-struct remote_network_create_args {
- remote_nonnull_network net;
-};
-
-struct remote_network_destroy_args {
- remote_nonnull_network net;
-};
-
-struct remote_network_dump_xml_args {
- remote_nonnull_network net;
- int flags;
-};
-
-struct remote_network_dump_xml_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_network_get_bridge_name_args {
- remote_nonnull_network net;
-};
-
-struct remote_network_get_bridge_name_ret {
- remote_nonnull_string name;
-};
-
-struct remote_network_get_autostart_args {
- remote_nonnull_network net;
-};
-
-struct remote_network_get_autostart_ret {
- int autostart;
-};
-
-struct remote_network_set_autostart_args {
- remote_nonnull_network net;
- int autostart;
-};
-
-
-/* Interface calls: */
-
-struct remote_num_of_interfaces_ret {
- int num;
-};
-
-struct remote_list_interfaces_args {
- int maxnames;
-};
-
-struct remote_list_interfaces_ret {
- remote_nonnull_string names<REMOTE_INTERFACE_NAME_LIST_MAX>;
-};
-
-struct remote_num_of_defined_interfaces_ret {
- int num;
-};
-
-struct remote_list_defined_interfaces_args {
- int maxnames;
-};
-
-struct remote_list_defined_interfaces_ret {
- remote_nonnull_string names<REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX>;
-};
-
-struct remote_interface_lookup_by_name_args {
- remote_nonnull_string name;
-};
-
-struct remote_interface_lookup_by_name_ret {
- remote_nonnull_interface iface;
-};
-
-struct remote_interface_lookup_by_mac_string_args {
- remote_nonnull_string mac;
-};
-
-struct remote_interface_lookup_by_mac_string_ret {
- remote_nonnull_interface iface;
-};
-
-struct remote_interface_get_xml_desc_args {
- remote_nonnull_interface iface;
- unsigned int flags;
-};
-
-struct remote_interface_get_xml_desc_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_interface_define_xml_args {
- remote_nonnull_string xml;
- unsigned int flags;
-};
-
-struct remote_interface_define_xml_ret {
- remote_nonnull_interface iface;
-};
-
-struct remote_interface_undefine_args {
- remote_nonnull_interface iface;
-};
-
-struct remote_interface_create_args {
- remote_nonnull_interface iface;
- unsigned int flags;
-};
-
-struct remote_interface_destroy_args {
- remote_nonnull_interface iface;
- unsigned int flags;
-};
-
-
-/* Auth calls: */
-
-struct remote_auth_list_ret {
- remote_auth_type types<REMOTE_AUTH_TYPE_LIST_MAX>;
-};
-
-struct remote_auth_sasl_init_ret {
- remote_nonnull_string mechlist;
-};
-
-struct remote_auth_sasl_start_args {
- remote_nonnull_string mech;
- int nil;
- char data<REMOTE_AUTH_SASL_DATA_MAX>;
-};
-
-struct remote_auth_sasl_start_ret {
- int complete;
- int nil;
- char data<REMOTE_AUTH_SASL_DATA_MAX>;
-};
-
-struct remote_auth_sasl_step_args {
- int nil;
- char data<REMOTE_AUTH_SASL_DATA_MAX>;
-};
-
-struct remote_auth_sasl_step_ret {
- int complete;
- int nil;
- char data<REMOTE_AUTH_SASL_DATA_MAX>;
-};
-
-struct remote_auth_polkit_ret {
- int complete;
-};
-
-
-
-/* Storage pool calls: */
-
-struct remote_num_of_storage_pools_ret {
- int num;
-};
-
-struct remote_list_storage_pools_args {
- int maxnames;
-};
-
-struct remote_list_storage_pools_ret {
- remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
-};
-
-struct remote_num_of_defined_storage_pools_ret {
- int num;
-};
-
-struct remote_list_defined_storage_pools_args {
- int maxnames;
-};
-
-struct remote_list_defined_storage_pools_ret {
- remote_nonnull_string names<REMOTE_STORAGE_POOL_NAME_LIST_MAX>;
-};
-
-struct remote_find_storage_pool_sources_args {
- remote_nonnull_string type;
- remote_string srcSpec;
- unsigned flags;
-};
-
-struct remote_find_storage_pool_sources_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_storage_pool_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-
-struct remote_storage_pool_lookup_by_uuid_ret {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_lookup_by_name_args {
- remote_nonnull_string name;
-};
-
-struct remote_storage_pool_lookup_by_name_ret {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_lookup_by_volume_args {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_pool_lookup_by_volume_ret {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_create_xml_args {
- remote_nonnull_string xml;
- unsigned flags;
-};
-
-struct remote_storage_pool_create_xml_ret {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_define_xml_args {
- remote_nonnull_string xml;
- unsigned flags;
-};
-
-struct remote_storage_pool_define_xml_ret {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_build_args {
- remote_nonnull_storage_pool pool;
- unsigned flags;
-};
-
-struct remote_storage_pool_undefine_args {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_create_args {
- remote_nonnull_storage_pool pool;
- unsigned flags;
-};
-
-struct remote_storage_pool_destroy_args {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_delete_args {
- remote_nonnull_storage_pool pool;
- unsigned flags;
-};
-
-struct remote_storage_pool_refresh_args {
- remote_nonnull_storage_pool pool;
- unsigned flags;
-};
-
-struct remote_storage_pool_dump_xml_args {
- remote_nonnull_storage_pool pool;
- unsigned flags;
-};
-
-struct remote_storage_pool_dump_xml_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_storage_pool_get_info_args {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_get_info_ret {
- unsigned char state;
- unsigned hyper capacity;
- unsigned hyper allocation;
- unsigned hyper available;
-};
-
-struct remote_storage_pool_get_autostart_args {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_get_autostart_ret {
- int autostart;
-};
-
-struct remote_storage_pool_set_autostart_args {
- remote_nonnull_storage_pool pool;
- int autostart;
-};
-
-struct remote_storage_pool_num_of_volumes_args {
- remote_nonnull_storage_pool pool;
-};
-
-struct remote_storage_pool_num_of_volumes_ret {
- int num;
-};
-
-struct remote_storage_pool_list_volumes_args {
- remote_nonnull_storage_pool pool;
- int maxnames;
-};
-
-struct remote_storage_pool_list_volumes_ret {
- remote_nonnull_string names<REMOTE_STORAGE_VOL_NAME_LIST_MAX>;
-};
-
-
-
-/* Storage vol calls: */
-
-struct remote_storage_vol_lookup_by_name_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string name;
-};
-
-struct remote_storage_vol_lookup_by_name_ret {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_lookup_by_key_args {
- remote_nonnull_string key;
-};
-
-struct remote_storage_vol_lookup_by_key_ret {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_lookup_by_path_args {
- remote_nonnull_string path;
-};
-
-struct remote_storage_vol_lookup_by_path_ret {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_create_xml_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string xml;
- unsigned flags;
-};
-
-struct remote_storage_vol_create_xml_ret {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_create_xml_from_args {
- remote_nonnull_storage_pool pool;
- remote_nonnull_string xml;
- remote_nonnull_storage_vol clonevol;
- unsigned flags;
-};
-
-struct remote_storage_vol_create_xml_from_ret {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_delete_args {
- remote_nonnull_storage_vol vol;
- unsigned flags;
-};
-
-struct remote_storage_vol_dump_xml_args {
- remote_nonnull_storage_vol vol;
- unsigned flags;
-};
-
-struct remote_storage_vol_dump_xml_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_storage_vol_get_info_args {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_get_info_ret {
- char type;
- unsigned hyper capacity;
- unsigned hyper allocation;
-};
-
-struct remote_storage_vol_get_path_args {
- remote_nonnull_storage_vol vol;
-};
-
-struct remote_storage_vol_get_path_ret {
- remote_nonnull_string name;
-};
-
-/* Node driver calls: */
-
-struct remote_node_num_of_devices_args {
- remote_string cap;
- unsigned flags;
-};
-
-struct remote_node_num_of_devices_ret {
- int num;
-};
-
-struct remote_node_list_devices_args {
- remote_string cap;
- int maxnames;
- unsigned flags;
-};
-
-struct remote_node_list_devices_ret {
- remote_nonnull_string names<REMOTE_NODE_DEVICE_NAME_LIST_MAX>;
-};
-
-struct remote_node_device_lookup_by_name_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_lookup_by_name_ret {
- remote_nonnull_node_device dev;
-};
-
-struct remote_node_device_dump_xml_args {
- remote_nonnull_string name;
- unsigned flags;
-};
-
-struct remote_node_device_dump_xml_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_node_device_get_parent_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_get_parent_ret {
- remote_string parent;
-};
-
-struct remote_node_device_num_of_caps_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_num_of_caps_ret {
- int num;
-};
-
-struct remote_node_device_list_caps_args {
- remote_nonnull_string name;
- int maxnames;
-};
-
-struct remote_node_device_list_caps_ret {
- remote_nonnull_string names<REMOTE_NODE_DEVICE_CAPS_LIST_MAX>;
-};
-
-struct remote_node_device_dettach_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_re_attach_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_reset_args {
- remote_nonnull_string name;
-};
-
-struct remote_node_device_create_xml_args {
- remote_nonnull_string xml_desc;
- int flags;
-};
-
-struct remote_node_device_create_xml_ret {
- remote_nonnull_node_device dev;
-};
-
-struct remote_node_device_destroy_args {
- remote_nonnull_string name;
-};
-
-
-/**
- * Events Register/Deregister:
- * It would seem rpcgen does not like both args, and ret
- * to be null. It will not generate the prototype otherwise.
- * Pass back a redundant boolean to force prototype generation.
- */
-struct remote_domain_events_register_ret {
- int cb_registered;
-};
-
-struct remote_domain_events_deregister_ret {
- int cb_registered;
-};
-
-struct remote_domain_event_msg {
- remote_nonnull_domain dom;
- int event;
- int detail;
-};
-
-
-struct remote_domain_xml_from_native_args {
- remote_nonnull_string nativeFormat;
- remote_nonnull_string nativeConfig;
- unsigned flags;
-};
-
-struct remote_domain_xml_from_native_ret {
- remote_nonnull_string domainXml;
-};
-
-
-struct remote_domain_xml_to_native_args {
- remote_nonnull_string nativeFormat;
- remote_nonnull_string domainXml;
- unsigned flags;
-};
-
-struct remote_domain_xml_to_native_ret {
- remote_nonnull_string nativeConfig;
-};
-
-
-struct remote_num_of_secrets_ret {
- int num;
-};
-
-struct remote_list_secrets_args {
- int maxuuids;
-};
-
-struct remote_list_secrets_ret {
- remote_nonnull_string uuids<REMOTE_SECRET_UUID_LIST_MAX>;
-};
-
-struct remote_secret_lookup_by_uuid_args {
- remote_uuid uuid;
-};
-
-struct remote_secret_lookup_by_uuid_ret {
- remote_nonnull_secret secret;
-};
-
-struct remote_secret_define_xml_args {
- remote_nonnull_string xml;
- unsigned flags;
-};
-
-struct remote_secret_define_xml_ret {
- remote_nonnull_secret secret;
-};
-
-struct remote_secret_get_xml_desc_args {
- remote_nonnull_secret secret;
- unsigned flags;
-};
-
-struct remote_secret_get_xml_desc_ret {
- remote_nonnull_string xml;
-};
-
-struct remote_secret_set_value_args {
- remote_nonnull_secret secret;
- opaque value<REMOTE_SECRET_VALUE_MAX>;
- unsigned flags;
-};
-
-struct remote_secret_get_value_args {
- remote_nonnull_secret secret;
- unsigned flags;
-};
-
-struct remote_secret_get_value_ret {
- opaque value<REMOTE_SECRET_VALUE_MAX>;
-};
-
-struct remote_secret_undefine_args {
- remote_nonnull_secret secret;
-};
-
-struct remote_secret_lookup_by_usage_args {
- int usageType;
- remote_nonnull_string usageID;
-};
-
-struct remote_secret_lookup_by_usage_ret {
- remote_nonnull_secret secret;
-};
-
-/*----- Protocol. -----*/
-
-/* Define the program number, protocol version and procedure numbers here. */
-const REMOTE_PROGRAM = 0x20008086;
-const REMOTE_PROTOCOL_VERSION = 1;
-
-enum remote_procedure {
- REMOTE_PROC_OPEN = 1,
- REMOTE_PROC_CLOSE = 2,
- REMOTE_PROC_GET_TYPE = 3,
- REMOTE_PROC_GET_VERSION = 4,
- REMOTE_PROC_GET_MAX_VCPUS = 5,
- REMOTE_PROC_NODE_GET_INFO = 6,
- REMOTE_PROC_GET_CAPABILITIES = 7,
- REMOTE_PROC_DOMAIN_ATTACH_DEVICE = 8,
- REMOTE_PROC_DOMAIN_CREATE = 9,
- REMOTE_PROC_DOMAIN_CREATE_XML = 10,
-
- REMOTE_PROC_DOMAIN_DEFINE_XML = 11,
- REMOTE_PROC_DOMAIN_DESTROY = 12,
- REMOTE_PROC_DOMAIN_DETACH_DEVICE = 13,
- REMOTE_PROC_DOMAIN_DUMP_XML = 14,
- REMOTE_PROC_DOMAIN_GET_AUTOSTART = 15,
- REMOTE_PROC_DOMAIN_GET_INFO = 16,
- REMOTE_PROC_DOMAIN_GET_MAX_MEMORY = 17,
- REMOTE_PROC_DOMAIN_GET_MAX_VCPUS = 18,
- REMOTE_PROC_DOMAIN_GET_OS_TYPE = 19,
- REMOTE_PROC_DOMAIN_GET_VCPUS = 20,
-
- REMOTE_PROC_LIST_DEFINED_DOMAINS = 21,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_ID = 22,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME = 23,
- REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID = 24,
- REMOTE_PROC_NUM_OF_DEFINED_DOMAINS = 25,
- REMOTE_PROC_DOMAIN_PIN_VCPU = 26,
- REMOTE_PROC_DOMAIN_REBOOT = 27,
- REMOTE_PROC_DOMAIN_RESUME = 28,
- REMOTE_PROC_DOMAIN_SET_AUTOSTART = 29,
- REMOTE_PROC_DOMAIN_SET_MAX_MEMORY = 30,
-
- REMOTE_PROC_DOMAIN_SET_MEMORY = 31,
- REMOTE_PROC_DOMAIN_SET_VCPUS = 32,
- REMOTE_PROC_DOMAIN_SHUTDOWN = 33,
- REMOTE_PROC_DOMAIN_SUSPEND = 34,
- REMOTE_PROC_DOMAIN_UNDEFINE = 35,
- REMOTE_PROC_LIST_DEFINED_NETWORKS = 36,
- REMOTE_PROC_LIST_DOMAINS = 37,
- REMOTE_PROC_LIST_NETWORKS = 38,
- REMOTE_PROC_NETWORK_CREATE = 39,
- REMOTE_PROC_NETWORK_CREATE_XML = 40,
-
- REMOTE_PROC_NETWORK_DEFINE_XML = 41,
- REMOTE_PROC_NETWORK_DESTROY = 42,
- REMOTE_PROC_NETWORK_DUMP_XML = 43,
- REMOTE_PROC_NETWORK_GET_AUTOSTART = 44,
- REMOTE_PROC_NETWORK_GET_BRIDGE_NAME = 45,
- REMOTE_PROC_NETWORK_LOOKUP_BY_NAME = 46,
- REMOTE_PROC_NETWORK_LOOKUP_BY_UUID = 47,
- REMOTE_PROC_NETWORK_SET_AUTOSTART = 48,
- REMOTE_PROC_NETWORK_UNDEFINE = 49,
- REMOTE_PROC_NUM_OF_DEFINED_NETWORKS = 50,
-
- REMOTE_PROC_NUM_OF_DOMAINS = 51,
- REMOTE_PROC_NUM_OF_NETWORKS = 52,
- REMOTE_PROC_DOMAIN_CORE_DUMP = 53,
- REMOTE_PROC_DOMAIN_RESTORE = 54,
- REMOTE_PROC_DOMAIN_SAVE = 55,
- REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE = 56,
- REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS = 57,
- REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS = 58,
- REMOTE_PROC_GET_HOSTNAME = 59,
- REMOTE_PROC_SUPPORTS_FEATURE = 60,
-
- REMOTE_PROC_DOMAIN_MIGRATE_PREPARE = 61,
- REMOTE_PROC_DOMAIN_MIGRATE_PERFORM = 62,
- REMOTE_PROC_DOMAIN_MIGRATE_FINISH = 63,
- REMOTE_PROC_DOMAIN_BLOCK_STATS = 64,
- REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65,
- REMOTE_PROC_AUTH_LIST = 66,
- REMOTE_PROC_AUTH_SASL_INIT = 67,
- REMOTE_PROC_AUTH_SASL_START = 68,
- REMOTE_PROC_AUTH_SASL_STEP = 69,
- REMOTE_PROC_AUTH_POLKIT = 70,
-
- REMOTE_PROC_NUM_OF_STORAGE_POOLS = 71,
- REMOTE_PROC_LIST_STORAGE_POOLS = 72,
- REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS = 73,
- REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS = 74,
- REMOTE_PROC_FIND_STORAGE_POOL_SOURCES = 75,
- REMOTE_PROC_STORAGE_POOL_CREATE_XML = 76,
- REMOTE_PROC_STORAGE_POOL_DEFINE_XML = 77,
- REMOTE_PROC_STORAGE_POOL_CREATE = 78,
- REMOTE_PROC_STORAGE_POOL_BUILD = 79,
- REMOTE_PROC_STORAGE_POOL_DESTROY = 80,
-
- REMOTE_PROC_STORAGE_POOL_DELETE = 81,
- REMOTE_PROC_STORAGE_POOL_UNDEFINE = 82,
- REMOTE_PROC_STORAGE_POOL_REFRESH = 83,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME = 84,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID = 85,
- REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME = 86,
- REMOTE_PROC_STORAGE_POOL_GET_INFO = 87,
- REMOTE_PROC_STORAGE_POOL_DUMP_XML = 88,
- REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART = 89,
- REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART = 90,
-
- REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES = 91,
- REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES = 92,
- REMOTE_PROC_STORAGE_VOL_CREATE_XML = 93,
- REMOTE_PROC_STORAGE_VOL_DELETE = 94,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME = 95,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY = 96,
- REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH = 97,
- REMOTE_PROC_STORAGE_VOL_GET_INFO = 98,
- REMOTE_PROC_STORAGE_VOL_DUMP_XML = 99,
- REMOTE_PROC_STORAGE_VOL_GET_PATH = 100,
-
- REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY = 101,
- REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
- REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
- REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
- REMOTE_PROC_DOMAIN_EVENTS_REGISTER = 105,
- REMOTE_PROC_DOMAIN_EVENTS_DEREGISTER = 106,
- REMOTE_PROC_DOMAIN_EVENT = 107,
- REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2 = 108,
- REMOTE_PROC_DOMAIN_MIGRATE_FINISH2 = 109,
- REMOTE_PROC_GET_URI = 110,
-
- REMOTE_PROC_NODE_NUM_OF_DEVICES = 111,
- REMOTE_PROC_NODE_LIST_DEVICES = 112,
- REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME = 113,
- REMOTE_PROC_NODE_DEVICE_DUMP_XML = 114,
- REMOTE_PROC_NODE_DEVICE_GET_PARENT = 115,
- REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS = 116,
- REMOTE_PROC_NODE_DEVICE_LIST_CAPS = 117,
- REMOTE_PROC_NODE_DEVICE_DETTACH = 118,
- REMOTE_PROC_NODE_DEVICE_RE_ATTACH = 119,
- REMOTE_PROC_NODE_DEVICE_RESET = 120,
-
- REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL = 121,
- REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
- REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
- REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
- REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM = 125,
- REMOTE_PROC_NUM_OF_INTERFACES = 126,
- REMOTE_PROC_LIST_INTERFACES = 127,
- REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
- REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING = 129,
- REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
-
- REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
- REMOTE_PROC_INTERFACE_UNDEFINE = 132,
- REMOTE_PROC_INTERFACE_CREATE = 133,
- REMOTE_PROC_INTERFACE_DESTROY = 134,
- REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
- REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
-
- REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
- REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
-
- REMOTE_PROC_NUM_OF_SECRETS = 139,
- REMOTE_PROC_LIST_SECRETS = 140,
- REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
- REMOTE_PROC_SECRET_DEFINE_XML = 142,
- REMOTE_PROC_SECRET_GET_XML_DESC = 143,
- REMOTE_PROC_SECRET_SET_VALUE = 144,
- REMOTE_PROC_SECRET_GET_VALUE = 145,
- REMOTE_PROC_SECRET_UNDEFINE = 146,
- REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147
-};
-
-
-/*
- * RPC wire format
- *
- * Each message consists of:
- *
- * Name | Type | Description
- * -----------+-----------------------+------------------
- * Length | int | Total number of bytes in message _including_ length.
- * Header | remote_message_header | Control information about procedure call
- * Payload | - | Variable payload data per procedure
- *
- * In header, the 'serial' field varies according to:
- *
- * - type == REMOTE_CALL
- * * serial is set by client, incrementing by 1 each time
- *
- * - type == REMOTE_REPLY
- * * serial matches that from the corresponding REMOTE_CALL
- *
- * - type == REMOTE_MESSAGE
- * * serial matches that from the corresponding REMOTE_CALL, or zero
- *
- *
- * Payload varies according to type and status:
- *
- * - type == REMOTE_CALL
- * XXX_args for procedure
- *
- * - type == REMOTE_REPLY
- * * status == REMOTE_OK
- * XXX_ret for procedure
- * * status == REMOTE_ERROR
- * remote_error Error information
- *
- * - type == REMOTE_MESSAGE
- * * status == REMOTE_OK
- * XXX_args for procedure
- * * status == REMOTE_ERROR
- * remote_error Error information
- *
- */
-enum remote_message_type {
- /* client -> server. args from a method call */
- REMOTE_CALL = 0,
- /* server -> client. reply/error from a method call */
- REMOTE_REPLY = 1,
- /* either direction. async notification */
- REMOTE_MESSAGE = 2
-};
-
-enum remote_message_status {
- /* Status is always REMOTE_OK for calls.
- * For replies, indicates no error.
- */
- REMOTE_OK = 0,
-
- /* For replies, indicates that an error happened, and a struct
- * remote_error follows.
- */
- REMOTE_ERROR = 1
-};
-
-/* 4 byte length word per header */
-const REMOTE_MESSAGE_HEADER_XDR_LEN = 4;
-
-struct remote_message_header {
- unsigned prog; /* REMOTE_PROGRAM */
- unsigned vers; /* REMOTE_PROTOCOL_VERSION */
- remote_procedure proc; /* REMOTE_PROC_x */
- remote_message_type type;
- unsigned serial; /* Serial number of message. */
- remote_message_status status;
-};
+++ /dev/null
-# 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, $_;
- }
-}
+++ /dev/null
-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" }
+++ /dev/null
-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" }
\ No newline at end of file
-I$(top_srcdir)/gnulib/lib -I../gnulib/lib \
-I../include \
-I@top_srcdir@/include \
- -I@top_srcdir@/qemud \
+ -I@top_srcdir@/daemon \
$(LIBXML_CFLAGS) \
$(LIBSSH2_CFLAGS) \
$(XEN_CFLAGS) \
REMOTE_DRIVER_SOURCES = \
gnutls_1_0_compat.h \
remote_internal.c remote_internal.h \
- ../qemud/remote_protocol.c \
- ../qemud/remote_protocol.h
+ ../daemon/remote_protocol.c \
+ ../daemon/remote_protocol.h
# Mock driver, covering domains, storage, networks, etc
TEST_DRIVER_SOURCES = \
#if HAVE_SASL
/*
- * NB, keep in sync with similar method in qemud/remote.c
+ * NB, keep in sync with similar method in remote/remote.c
*/
static char *addrToString(struct sockaddr_storage *sa, socklen_t salen)
{
TESTS += interfacexml2xmltest
-path_add = $$abs_top_builddir/src$(PATH_SEPARATOR)$$abs_top_builddir/qemud
+path_add = $$abs_top_builddir/src$(PATH_SEPARATOR)$$abs_top_builddir/daemon
# NB, automake < 1.10 does not provide the real
# abs_top_{src/build}dir variables, so don't rely
if WITH_LIBVIRTD
eventtest_SOURCES = \
- eventtest.c testutils.h testutils.c ../qemud/event.c
+ eventtest.c testutils.h testutils.c ../daemon/event.c
eventtest_LDADD = -lrt $(LDADDS)
endif
grep '^#define WITH_QEMU 1' $CONFIG_HEADER > /dev/null ||
skip_test_ "configured without QEMU support"
-conf="$abs_top_srcdir/qemud/libvirtd.conf"
+conf="$abs_top_srcdir/daemon/libvirtd.conf"
# Ensure that each commented out PARAMETER = VALUE line has the expected form.
grep '[a-z_] *= *[^ ]' "$conf" | grep -vE '^#[a-z_]+ = ' \
#include "threads.h"
#include "logging.h"
#include "util.h"
-#include "../qemud/event.h"
+#include "../daemon/event.h"
#define NUM_FDS 5
#define NUM_TIME 5
projects / libvirt.git / commitdiff