From: Daniel P. Berrange Date: Tue, 15 Sep 2009 14:49:29 +0000 (+0100) Subject: Rename qemud/ directory to daemon/ X-Git-Url: http://xenbits.xensource.com/gitweb?a=commitdiff_plain;h=5c2a1ae8760b052caefa2945472d2bacf24b2dfe;p=libvirt.git Rename qemud/ directory to daemon/ * qemud/: Rename to daemon/ * Makefile.am, configure.in, src/Makefile.am, src/remote_internal.c, tests/Makefile.am, tests/eventtest.c: s/qemud/daemon/ where needed --- diff --git a/Makefile.am b/Makefile.am index beddca725c..17fbf439e1 100644 --- a/Makefile.am +++ b/Makefile.am @@ -3,7 +3,7 @@ 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 @@ -40,7 +40,7 @@ tests: 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 diff --git a/configure.in b/configure.in index da0223e141..5d498ae852 100644 --- a/configure.in +++ b/configure.in @@ -1694,7 +1694,7 @@ AC_OUTPUT(Makefile src/Makefile include/Makefile docs/Makefile \ 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 \ diff --git a/daemon/.gitignore b/daemon/.gitignore new file mode 100644 index 0000000000..38cf28dcf6 --- /dev/null +++ b/daemon/.gitignore @@ -0,0 +1,12 @@ +*.gcda +*.gcno +*.la +*.lo +.deps +.libs +Makefile +Makefile.in +libvirt_qemud +libvirtd +libvirtd.init +libvirtd.logrotate diff --git a/daemon/Makefile.am b/daemon/Makefile.am new file mode 100644 index 0000000000..7ebd3caa09 --- /dev/null +++ b/daemon/Makefile.am @@ -0,0 +1,294 @@ +## Process this file with automake to produce Makefile.in + +DAEMON_SOURCES = \ + event.c event.h \ + qemud.c qemud.h \ + remote.c remote.h \ + dispatch.c dispatch.h \ + remote_dispatch_prototypes.h \ + remote_dispatch_table.h \ + remote_dispatch_args.h \ + remote_dispatch_ret.h \ + remote_protocol.h remote_protocol.c + +AVAHI_SOURCES = \ + mdns.c mdns.h + +DISTCLEANFILES = +EXTRA_DIST = \ + default-network.xml \ + remote_generate_stubs.pl rpcgen_fix.pl \ + remote_protocol.x \ + libvirtd.conf \ + libvirtd.init.in \ + libvirtd.policy-0 \ + libvirtd.policy-1 \ + libvirtd.sasl \ + libvirtd.sysconf \ + libvirtd.aug \ + libvirtd_qemu.aug \ + libvirtd.logrotate.in \ + test_libvirtd.aug \ + test_libvirtd_qemu.aug \ + $(AVAHI_SOURCES) \ + $(DAEMON_SOURCES) + +BUILT_SOURCES = + +if HAVE_RPCGEN +# +# Maintainer-only target for re-generating the derived .c/.h source +# files, which are actually derived from the .x file. +# +# For committing protocol changes to CVS, the GLIBC rpcgen *must* +# be used. +# +# Support for non-GLIB rpcgen is here as a convenience for +# non-Linux people needing to test changes during dev. +# +rpcgen: + rm -f rp.c-t rp.h-t rp.c-t1 rp.c-t2 rp.h-t1 + $(RPCGEN) -h -o rp.h-t $(srcdir)/remote_protocol.x + $(RPCGEN) -c -o rp.c-t $(srcdir)/remote_protocol.x +if HAVE_GLIBC_RPCGEN + perl -w $(srcdir)/rpcgen_fix.pl rp.h-t > rp.h-t1 + perl -w $(srcdir)/rpcgen_fix.pl rp.c-t > rp.c-t1 + (echo '#include '; 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,,\n $(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 diff --git a/daemon/THREADING.txt b/daemon/THREADING.txt new file mode 100644 index 0000000000..4c7a616614 --- /dev/null +++ b/daemon/THREADING.txt @@ -0,0 +1,62 @@ + + Threading: the RULES. + ==================== + +If you don't understand this, don't touch the code. Ask for +further advice / explanation on the mailing list first. + + - the top level lock is on 'struct qemud_server'. This must be + held before acquiring any other lock + + - Each 'struct qemud_client' object has a lock. The server lock + must be held before acquiring it. Once the client lock is acquired + the server lock can (optionally) be dropped. + + - The event loop has its own self-contained lock. You can ignore + this as a caller of virEvent APIs. + + +The server lock is only needed / used once the daemon has entered +its main loop, which is the qemudRunLoop() . The initial thread +acquires the lock upon entering this method. + +It immediatelty spawns 'n' worker threads, whose main loop is +the qemudWorker() method. The workers will immediately try to +acquire the server lock, and thus block since its held by the +initial thread. + +When the initial thread enters the poll() call, it drops the +server lock. The worker locks now each wakeup, acquire the +server lock and go into a condition wait on the 'job' condition +variable. The workers are now all 'primed' for incoming RPC +calls. + + + +A file descriptor event now occurrs, causing the initial thread +to exit poll(). It invokes the registered callback associated +with the file descriptors on which the event occurrs. The callbacks +are required to immediately acquire the server lock. + +If the callback is dealing with a client event, it will then +acquire the client lock, and drop the server lock. + +The callback will now handle the I/O event, reading or writing +a RPC message. Once a complete RPC message has been read the +client is marked as being in state QEMUD_MODE_WAIT_DISPATCH, +and the 'job' condition variable is signaled. The callback +now drops the client lock and goes back into the poll() loop +waiting for more I/O events. + +Meanwhile one of the worker threads wakes up from its condition +variable sleep, holding the server lock. It now searches for a +client in state QEMUD_MODE_WAIT_DISPATCH. If it doesn't find +one, it goes back to sleep. If it does find one, then it calls +into the remoteDispatchClientRequest() method de-serialize the +incoming message into an XDR object and invoke the helper method +for the associated RPC call. + +While the helper method is executing, no locks are held on either +the client or server, but the ref count on the 'struct qemud_client' +object is incremented to ensure its not deleted. The helper can +now safely invoke the neccessary libvirt API call. diff --git a/daemon/default-network.xml b/daemon/default-network.xml new file mode 100644 index 0000000000..9cfc01ed78 --- /dev/null +++ b/daemon/default-network.xml @@ -0,0 +1,10 @@ + + default + + + + + + + + diff --git a/daemon/dispatch.c b/daemon/dispatch.c new file mode 100644 index 0000000000..a60f2f47d1 --- /dev/null +++ b/daemon/dispatch.c @@ -0,0 +1,534 @@ +/* + * dispatch.h: RPC message dispatching infrastructure + * + * Copyright (C) 2007, 2008, 2009 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Richard W.M. Jones + * Author: Daniel P. Berrange + */ + +#include + +#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; +} diff --git a/daemon/dispatch.h b/daemon/dispatch.h new file mode 100644 index 0000000000..1d85df9a6b --- /dev/null +++ b/daemon/dispatch.h @@ -0,0 +1,63 @@ +/* + * dispatch.h: RPC message dispatching infrastructure + * + * Copyright (C) 2007, 2008, 2009 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Richard W.M. Jones + * Author: Daniel P. Berrange + */ + +#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__ */ diff --git a/daemon/event.c b/daemon/event.c new file mode 100644 index 0000000000..10847c4049 --- /dev/null +++ b/daemon/event.c @@ -0,0 +1,707 @@ +/* + * event.c: event loop for monitoring file handles + * + * Copyright (C) 2007 Daniel P. Berrange + * Copyright (C) 2007 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange + */ + +#include + +#include +#include +#include +#include +#include +#include + +#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; +} diff --git a/daemon/event.h b/daemon/event.h new file mode 100644 index 0000000000..0992f1cbc8 --- /dev/null +++ b/daemon/event.h @@ -0,0 +1,134 @@ +/* + * event.h: event loop for monitoring file handles + * + * Copyright (C) 2007 Daniel P. Berrange + * Copyright (C) 2007 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange + */ + +#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__ */ diff --git a/daemon/libvirtd.aug b/daemon/libvirtd.aug new file mode 100644 index 0000000000..7406d238f8 --- /dev/null +++ b/daemon/libvirtd.aug @@ -0,0 +1,82 @@ +(* /etc/libvirt/libvirtd.conf *) + +module Libvirtd = + autoload xfm + + let eol = del /[ \t]*\n/ "\n" + let value_sep = del /[ \t]*=[ \t]*/ " = " + let indent = del /[ \t]*/ "" + + let array_sep = del /,[ \t\n]*/ ", " + let array_start = del /\[[ \t\n]*/ "[ " + let array_end = del /\]/ "]" + + let str_val = del /\"/ "\"" . store /[^\"]*/ . del /\"/ "\"" + let bool_val = store /0|1/ + let int_val = store /[0-9]+/ + let str_array_element = [ seq "el" . str_val ] . del /[ \t\n]*/ "" + let str_array_val = counter "el" . array_start . ( str_array_element . ( array_sep . str_array_element ) * ) ? . array_end + + let str_entry (kw:string) = [ key kw . value_sep . str_val ] + let bool_entry (kw:string) = [ key kw . value_sep . bool_val ] + let int_entry (kw:string) = [ key kw . value_sep . int_val ] + let str_array_entry (kw:string) = [ key kw . value_sep . str_array_val ] + + + (* Config entry grouped by function - same order as example config *) + let network_entry = bool_entry "listen_tls" + | bool_entry "listen_tcp" + | str_entry "tls_port" + | str_entry "tcp_port" + | str_entry "listen_addr" + | bool_entry "mdns_adv" + | str_entry "mdns_name" + + let sock_acl_entry = str_entry "unix_sock_group" + | str_entry "unix_sock_ro_perms" + | str_entry "unix_sock_rw_perms" + | str_entry "unix_sock_dir" + + let authentication_entry = str_entry "auth_unix_ro" + | str_entry "auth_unix_rw" + | str_entry "auth_tcp" + | str_entry "auth_tls" + + let certificate_entry = str_entry "key_file" + | str_entry "cert_file" + | str_entry "ca_file" + | str_entry "crl_file" + + let authorization_entry = bool_entry "tls_no_verify_certificate" + | str_array_entry "tls_allowed_dn_list" + | str_array_entry "sasl_allowed_username_list" + + let processing_entry = int_entry "min_workers" + | int_entry "max_workers" + | int_entry "max_clients" + | int_entry "max_requests" + | int_entry "max_client_requests" + + let logging_entry = int_entry "log_level" + | str_entry "log_filters" + | str_entry "log_outputs" + + (* Each enty in the config is one of the following three ... *) + let entry = network_entry + | sock_acl_entry + | authentication_entry + | certificate_entry + | authorization_entry + | processing_entry + | logging_entry + let comment = [ label "#comment" . del /#[ \t]*/ "# " . store /([^ \t\n][^\n]*)?/ . del /\n/ "\n" ] + let empty = [ label "#empty" . eol ] + + let record = indent . entry . eol + + let lns = ( record | comment | empty ) * + + let filter = incl "/etc/libvirt/libvirtd.conf" + . Util.stdexcl + + let xfm = transform lns filter diff --git a/daemon/libvirtd.conf b/daemon/libvirtd.conf new file mode 100644 index 0000000000..49de466349 --- /dev/null +++ b/daemon/libvirtd.conf @@ -0,0 +1,314 @@ +# Master libvirt daemon configuration file +# +# For further information consult http://libvirt.org/format.html +# +# NOTE: the tests/daemon-conf regression test script requires +# that each "PARAMETER = VALUE" line in this file have the parameter +# name just after a leading "#". + +################################################################# +# +# Network connectivity controls +# + +# Flag listening for secure TLS connections on the public TCP/IP port. +# NB, must pass the --listen flag to the libvirtd process for this to +# have any effect. +# +# It is necessary to setup a CA and issue server certificates before +# using this capability. +# +# This is enabled by default, uncomment this to disable it +#listen_tls = 0 + +# Listen for unencrypted TCP connections on the public TCP/IP port. +# NB, must pass the --listen flag to the libvirtd process for this to +# have any effect. +# +# Using the TCP socket requires SASL authentication by default. Only +# SASL mechanisms which support data encryption are allowed. This is +# DIGEST_MD5 and GSSAPI (Kerberos5) +# +# This is disabled by default, uncomment this to enable it. +#listen_tcp = 1 + + + +# Override the port for accepting secure TLS connections +# This can be a port number, or service name +# +#tls_port = "16514" + +# Override the port for accepting insecure TCP connections +# This can be a port number, or service name +# +#tcp_port = "16509" + + +# Override the default configuration which binds to all network +# interfaces. This can be a numeric IPv4/6 address, or hostname +# +#listen_addr = "192.168.0.1" + + +# Flag toggling mDNS advertizement of the libvirt service. +# +# Alternatively can disable for all services on a host by +# stopping the Avahi daemon +# +# This is enabled by default, uncomment this to disable it +#mdns_adv = 0 + +# Override the default mDNS advertizement name. This must be +# unique on the immediate broadcast network. +# +# The default is "Virtualization Host HOSTNAME", where HOSTNAME +# is subsituted for the short hostname of the machine (without domain) +# +#mdns_name = "Virtualization Host Joe Demo" + + +################################################################# +# +# UNIX socket access controls +# + +# Set the UNIX domain socket group ownership. This can be used to +# allow a 'trusted' set of users access to management capabilities +# without becoming root. +# +# This is restricted to 'root' by default. +#unix_sock_group = "libvirt" + +# Set the UNIX socket permissions for the R/O socket. This is used +# for monitoring VM status only +# +# Default allows any user. If setting group ownership may want to +# restrict this to: +#unix_sock_ro_perms = "0777" + +# Set the UNIX socket permissions for the R/W socket. This is used +# for full management of VMs +# +# Default allows only root. If PolicyKit is enabled on the socket, +# the default will change to allow everyone (eg, 0777) +# +# If not using PolicyKit and setting group ownership for access +# control then you may want to relax this to: +#unix_sock_rw_perms = "0770" + +# Set the name of the directory in which sockets will be found/created. +#unix_sock_dir = "/var/run/libvirt" + +################################################################# +# +# Authentication. +# +# - none: do not perform auth checks. If you can connect to the +# socket you are allowed. This is suitable if there are +# restrictions on connecting to the socket (eg, UNIX +# socket permissions), or if there is a lower layer in +# the network providing auth (eg, TLS/x509 certificates) +# +# - sasl: use SASL infrastructure. The actual auth scheme is then +# controlled from /etc/sasl2/libvirt.conf. For the TCP +# socket only GSSAPI & DIGEST-MD5 mechanisms will be used. +# For non-TCP or TLS sockets, any scheme is allowed. +# +# - polkit: use PolicyKit to authenticate. This is only suitable +# for use on the UNIX sockets. The default policy will +# require a user to supply their own password to gain +# full read/write access (aka sudo like), while anyone +# is allowed read/only access. +# +# Set an authentication scheme for UNIX read-only sockets +# By default socket permissions allow anyone to connect +# +# To restrict monitoring of domains you may wish to enable +# an authentication mechanism here +#auth_unix_ro = "none" + +# Set an authentication scheme for UNIX read-write sockets +# By default socket permissions only allow root. If PolicyKit +# support was compiled into libvirt, the default will be to +# use 'polkit' auth. +# +# If the unix_sock_rw_perms are changed you may wish to enable +# an authentication mechanism here +#auth_unix_rw = "none" + +# Change the authentication scheme for TCP sockets. +# +# If you don't enable SASL, then all TCP traffic is cleartext. +# Don't do this outside of a dev/test scenario. For real world +# use, always enable SASL and use the GSSAPI or DIGEST-MD5 +# mechanism in /etc/sasl2/libvirt.conf +#auth_tcp = "sasl" + +# Change the authentication scheme for TLS sockets. +# +# TLS sockets already have encryption provided by the TLS +# layer, and limited authentication is done by certificates +# +# It is possible to make use of any SASL authentication +# mechanism as well, by using 'sasl' for this option +#auth_tls = "none" + + + +################################################################# +# +# TLS x509 certificate configuration +# + + +# Override the default server key file path +# +#key_file = "/etc/pki/libvirt/private/serverkey.pem" + +# Override the default server certificate file path +# +#cert_file = "/etc/pki/libvirt/servercert.pem" + +# Override the default CA certificate path +# +#ca_file = "/etc/pki/CA/cacert.pem" + +# Specify a certificate revocation list. +# +# Defaults to not using a CRL, uncomment to enable it +#crl_file = "/etc/pki/CA/crl.pem" + + + +################################################################# +# +# Authorization controls +# + + +# Flag to disable verification of client certificates +# +# Client certificate verification is the primary authentication mechanism. +# Any client which does not present a certificate signed by the CA +# will be rejected. +# +# Default is to always verify. Uncommenting this will disable +# verification - make sure an IP whitelist is set +#tls_no_verify_certificate = 1 + + +# A whitelist of allowed x509 Distinguished Names +# This list may contain wildcards such as +# +# "C=GB,ST=London,L=London,O=Red Hat,CN=*" +# +# See the POSIX fnmatch function for the format of the wildcards. +# +# NB If this is an empty list, no client can connect, so comment out +# entirely rather than using empty list to disable these checks +# +# By default, no DN's are checked +#tls_allowed_dn_list = ["DN1", "DN2"] + + +# A whitelist of allowed SASL usernames. The format for usernames +# depends on the SASL authentication mechanism. Kerberos usernames +# look like username@REALM +# +# This list may contain wildcards such as +# +# "*@EXAMPLE.COM" +# +# See the POSIX fnmatch function for the format of the wildcards. +# +# NB If this is an empty list, no client can connect, so comment out +# entirely rather than using empty list to disable these checks +# +# By default, no Username's are checked +#sasl_allowed_username_list = ["joe@EXAMPLE.COM", "fred@EXAMPLE.COM" ] + + + +################################################################# +# +# Processing controls +# + +# The maximum number of concurrent client connections to allow +# over all sockets combined. +#max_clients = 20 + + +# The minimum limit sets the number of workers to start up +# initially. If the number of active clients exceeds this, +# then more threads are spawned, upto max_workers limit. +# Typically you'd want max_workers to equal maximum number +# of clients allowed +#min_workers = 5 +#max_workers = 20 + +# Total global limit on concurrent RPC calls. Should be +# at least as large as max_workers. Beyond this, RPC requests +# will be read into memory and queued. This directly impact +# memory usage, currently each request requires 256 KB of +# memory. So by default upto 5 MB of memory is used +# +# XXX this isn't actually enforced yet, only the per-client +# limit is used so far +#max_requests = 20 + +# Limit on concurrent requests from a single client +# connection. To avoid one client monopolizing the server +# this should be a small fraction of the global max_requests +# and max_workers parameter +#max_client_requests = 5 + +################################################################# +# +# Logging controls +# + +# Logging level: 4 errors, 3 warnings, 2 informations, 1 debug +# basically 1 will log everything possible +#log_level = 3 + +# Logging filters: +# A filter allows to select a different logging level for a given category +# of logs +# The format for a filter is: +# x:name +# where name is a match string e.g. remote or qemu +# the x prefix is the minimal level where matching messages should be logged +# 1: DEBUG +# 2: INFO +# 3: WARNING +# 4: ERROR +# +# Multiple filter can be defined in a single @filters, they just need to be +# separated by spaces. +# +# e.g: +# log_filters="3:remote 4:event" +# to only get warning or errors from the remote layer and only errors from +# the event layer. + +# Logging outputs: +# An output is one of the places to save logging informations +# The format for an output can be: +# x:stderr +# output goes to stderr +# x:syslog:name +# use syslog for the output and use the given name as the ident +# x:file:file_path +# output to a file, with the given filepath +# In all case the x prefix is the minimal level, acting as a filter +# 1: DEBUG +# 2: INFO +# 3: WARNING +# 4: ERROR +# +# Multiple output can be defined, they just need to be separated by spaces. +# e.g.: +# log_outputs="3:syslog:libvirtd" +# to log all warnings and errors to syslog under the libvirtd ident diff --git a/daemon/libvirtd.init.in b/daemon/libvirtd.init.in new file mode 100644 index 0000000000..43c2d686a0 --- /dev/null +++ b/daemon/libvirtd.init.in @@ -0,0 +1,115 @@ +#!/bin/sh + +# the following is the LSB init header see +# http://www.linux-foundation.org/spec//booksets/LSB-Core-generic/LSB-Core-generic.html#INITSCRCOMCONV +# +### BEGIN INIT INFO +# Provides: libvirtd +# Required-Start: $network messagebus +# Should-Start: $named +# Should-Start: xend +# Should-Start: hal +# Should-Start: avahi +# Required-Stop: $network messagebus +# Should-Stop: $named +# Default-Start: 3 4 5 +# Short-Description: daemon for libvirt virtualization API +# Description: This is a daemon for managing guest instances +# and libvirt virtual networks +# See http://libvirt.org +### END INIT INFO + +# the following is chkconfig init header +# +# libvirtd: guest and virtual network management daemon +# +# chkconfig: 345 97 03 +# description: This is a daemon for managing guest instances +# and libvirt virtual networks +# See http://libvirt.org +# +# processname: libvirtd +# pidfile: @localstatedir@/run/libvirtd.pid +# + +# Sanity checks. +[ -x @sbindir@/libvirtd ] || exit 0 + +# Source function library. +. @sysconfdir@/rc.d/init.d/functions + +SERVICE=libvirtd +PROCESS=libvirtd + +LIBVIRTD_CONFIG= +LIBVIRTD_ARGS= +KRB5_KTNAME=/etc/libvirt/krb5.tab + +test -f @sysconfdir@/sysconfig/libvirtd && . @sysconfdir@/sysconfig/libvirtd + +LIBVIRTD_CONFIG_ARGS= +if [ -n "$LIBVIRTD_CONFIG" ] +then + LIBVIRTD_CONFIG_ARGS="--config $LIBVIRTD_CONFIG" +fi + +RETVAL=0 + +start() { + echo -n $"Starting $SERVICE daemon: " + mkdir -p @localstatedir@/cache/libvirt + rm -rf @localstatedir@/cache/libvirt/* + KRB5_KTNAME=$KRB5_KTNAME daemon --check $SERVICE $PROCESS --daemon $LIBVIRTD_CONFIG_ARGS $LIBVIRTD_ARGS + RETVAL=$? + echo + [ $RETVAL -eq 0 ] && touch @localstatedir@/lock/subsys/$SERVICE +} + +stop() { + echo -n $"Stopping $SERVICE daemon: " + + killproc $PROCESS + RETVAL=$? + echo + if [ $RETVAL -eq 0 ]; then + rm -f @localstatedir@/lock/subsys/$SERVICE + rm -f @localstatedir@/run/$SERVICE.pid + rm -rf @localstatedir@/cache/libvirt/* + fi +} + +restart() { + stop + start +} + +reload() { + echo -n $"Reloading $SERVICE configuration: " + + killproc $PROCESS -HUP + RETVAL=$? + echo + return $RETVAL +} + +# See how we were called. +case "$1" in + start|stop|restart|reload) + $1 + ;; + status) + status $PROCESS + RETVAL=$? + ;; + force-reload) + reload + ;; + condrestart|try-restart) + [ -f @localstatedir@/lock/subsys/$SERVICE ] && restart || : + ;; + *) + echo $"Usage: $0 {start|stop|status|restart|condrestart|reload}" + exit 1 + ;; +esac +exit $RETVAL diff --git a/daemon/libvirtd.logrotate.in b/daemon/libvirtd.logrotate.in new file mode 100644 index 0000000000..9b42630135 --- /dev/null +++ b/daemon/libvirtd.logrotate.in @@ -0,0 +1,8 @@ +@localstatedir@/log/libvirt/qemu/*.log { + daily + missingok + rotate 7 + compress + delaycompress + copytruncate +} diff --git a/daemon/libvirtd.policy-0 b/daemon/libvirtd.policy-0 new file mode 100644 index 0000000000..b6da94615e --- /dev/null +++ b/daemon/libvirtd.policy-0 @@ -0,0 +1,42 @@ + + + + + + + Monitor local virtualized systems + System policy prevents monitoring of local virtualized systems + + + yes + yes + yes + + + + + Manage local virtualized systems + System policy prevents management of local virtualized systems + + + no + no + auth_admin_keep_session + + + diff --git a/daemon/libvirtd.policy-1 b/daemon/libvirtd.policy-1 new file mode 100644 index 0000000000..6fa3a5e71e --- /dev/null +++ b/daemon/libvirtd.policy-1 @@ -0,0 +1,42 @@ + + + + + + + Monitor local virtualized systems + System policy prevents monitoring of local virtualized systems + + + yes + yes + yes + + + + + Manage local virtualized systems + System policy prevents management of local virtualized systems + + + no + no + auth_admin_keep + + + diff --git a/daemon/libvirtd.sasl b/daemon/libvirtd.sasl new file mode 100644 index 0000000000..e24a130853 --- /dev/null +++ b/daemon/libvirtd.sasl @@ -0,0 +1,28 @@ +# If you want to use the non-TLS socket, then you *must* include +# the GSSAPI or DIGEST-MD5 mechanisms, because they are the only +# ones that can offer session encryption as well as authentication. +# +# If you're only using TLS, then you can turn on any mechanisms +# you like for authentication, because TLS provides the encryption +# +# Default to a simple username+password mechanism +mech_list: digest-md5 + +# Before you can use GSSAPI, you need a service principle on the +# KDC server for libvirt, and that to be exported to the keytab +# file listed below +#mech_list: gssapi +# +# You can also list many mechanisms at once, then the user can choose +# by adding '?auth=sasl.gssapi' to their libvirt URI, eg +# qemu+tcp://hostname/system?auth=sasl.gssapi +#mech_list: digest-md5 gssapi + +# MIT kerberos ignores this option & needs KRB5_KTNAME env var. +# May be useful for other non-Linux OS though.... +keytab: /etc/libvirt/krb5.tab + +# If using digest-md5 for username/passwds, then this is the file +# containing the passwds. Use 'saslpasswd2 -a libvirt [username]' +# to add entries, and 'sasldblistusers2 -a libvirt' to browse it +sasldb_path: /etc/libvirt/passwd.db diff --git a/daemon/libvirtd.sysconf b/daemon/libvirtd.sysconf new file mode 100644 index 0000000000..fe4596a0c4 --- /dev/null +++ b/daemon/libvirtd.sysconf @@ -0,0 +1,9 @@ +# Override the default config file +#LIBVIRTD_CONFIG=/etc/libvirt/libvirtd.conf + +# Listen for TCP/IP connections +# NB. must setup TLS/SSL keys prior to using this +#LIBVIRTD_ARGS="--listen" + +# Override Kerberos service keytab for SASL/GSSAPI +#KRB5_KTNAME=/etc/libvirt/krb5.tab diff --git a/daemon/libvirtd_qemu.aug b/daemon/libvirtd_qemu.aug new file mode 100644 index 0000000000..f0b2a5e3c1 --- /dev/null +++ b/daemon/libvirtd_qemu.aug @@ -0,0 +1,52 @@ +(* /etc/libvirt/qemu.conf *) + +module Libvirtd_qemu = + autoload xfm + + let eol = del /[ \t]*\n/ "\n" + let value_sep = del /[ \t]*=[ \t]*/ " = " + let indent = del /[ \t]*/ "" + + let array_sep = del /,[ \t\n]*/ ", " + let array_start = del /\[[ \t\n]*/ "[ " + let array_end = del /\]/ "]" + + let str_val = del /\"/ "\"" . store /[^\"]*/ . del /\"/ "\"" + let bool_val = store /0|1/ + let str_array_element = [ seq "el" . str_val ] . del /[ \t\n]*/ "" + let str_array_val = counter "el" . array_start . ( str_array_element . ( array_sep . str_array_element ) * ) ? . array_end + + let str_entry (kw:string) = [ key kw . value_sep . str_val ] + let bool_entry (kw:string) = [ key kw . value_sep . bool_val ] + let str_array_entry (kw:string) = [ key kw . value_sep . str_array_val ] + + + (* Config entry grouped by function - same order as example config *) + let vnc_entry = str_entry "vnc_listen" + | bool_entry "vnc_tls" + | str_entry "vnc_tls_x509_cert_dir" + | bool_entry "vnc_tls_x509_verify" + | str_entry "vnc_password" + | bool_entry "vnc_sasl" + | str_entry "vnc_sasl_dir" + | str_entry "security_driver" + | str_entry "user" + | str_entry "group" + | str_array_entry "cgroup_controllers" + | str_array_entry "cgroup_device_acl" + | str_entry "save_image_format" + | str_entry "hugetlbfs_mount" + + (* Each enty in the config is one of the following three ... *) + let entry = vnc_entry + let comment = [ label "#comment" . del /#[ \t]*/ "# " . store /([^ \t\n][^\n]*)?/ . del /\n/ "\n" ] + let empty = [ label "#empty" . eol ] + + let record = indent . entry . eol + + let lns = ( record | comment | empty ) * + + let filter = incl "/etc/libvirt/qemu.conf" + . Util.stdexcl + + let xfm = transform lns filter diff --git a/daemon/mdns.c b/daemon/mdns.c new file mode 100644 index 0000000000..73b7d11fc1 --- /dev/null +++ b/daemon/mdns.c @@ -0,0 +1,510 @@ +/* + * mdns.c: advertise libvirt hypervisor connections + * + * Copyright (C) 2007 Daniel P. Berrange + * + * Derived from Avahi example service provider code. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange + */ + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +#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; +} diff --git a/daemon/mdns.h b/daemon/mdns.h new file mode 100644 index 0000000000..cabcee4b57 --- /dev/null +++ b/daemon/mdns.h @@ -0,0 +1,96 @@ +/* + * mdns.c: advertise libvirt hypervisor connections + * + * Copyright (C) 2007 Daniel P. Berrange + * + * Derived from Avahi example service provider code. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange + */ + +#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__ */ diff --git a/daemon/qemud.c b/daemon/qemud.c new file mode 100644 index 0000000000..00b9859f4d --- /dev/null +++ b/daemon/qemud.c @@ -0,0 +1,3015 @@ +/* + * 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 + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 +#include + +#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 Exit after timeout period.\n\ + -f | --config Configuration file.\n\ + | --version Display version information.\n\ + -p | --pid-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; +} diff --git a/daemon/qemud.h b/daemon/qemud.h new file mode 100644 index 0000000000..e8ce20988e --- /dev/null +++ b/daemon/qemud.h @@ -0,0 +1,284 @@ +/* + * qemud.h: daemon data structure definitions + * + * Copyright (C) 2006-2009 Red Hat, Inc. + * Copyright (C) 2006 Daniel P. Berrange + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Daniel P. Berrange + */ + + +#ifndef QEMUD_INTERNAL_H__ +#define QEMUD_INTERNAL_H__ + +#include + +#include +#include +#include "gnutls_1_0_compat.h" +#if HAVE_SASL +#include +#endif + +#if HAVE_POLKIT0 +#include +#endif + +#ifdef HAVE_SYS_SYSLIMITS_H +#include +#endif + +#include +#include +#include "remote_protocol.h" +#include "logging.h" +#include "threads.h" + +#ifdef __GNUC__ +#ifdef HAVE_ANSIDECL_H +#include +#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 diff --git a/daemon/remote.c b/daemon/remote.c new file mode 100644 index 0000000000..17426cd084 --- /dev/null +++ b/daemon/remote.c @@ -0,0 +1,4905 @@ +/* + * 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 + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "virterror_internal.h" + +#if HAVE_POLKIT0 +#include +#include +#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); +} diff --git a/daemon/remote.h b/daemon/remote.h new file mode 100644 index 0000000000..e3ee6964cc --- /dev/null +++ b/daemon/remote.h @@ -0,0 +1,72 @@ +/* + * remote.h: handlers for RPC method calls + * + * Copyright (C) 2007, 2008, 2009 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Richard W.M. Jones + * Author: Daniel P. Berrange + */ + +#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__ */ diff --git a/daemon/remote_dispatch_args.h b/daemon/remote_dispatch_args.h new file mode 100644 index 0000000000..95f668ad00 --- /dev/null +++ b/daemon/remote_dispatch_args.h @@ -0,0 +1,127 @@ +/* Automatically generated by remote_generate_stubs.pl. + * Do not edit this file. Any changes you make will be lost. + */ + + remote_open_args val_remote_open_args; + remote_get_max_vcpus_args val_remote_get_max_vcpus_args; + remote_domain_attach_device_args val_remote_domain_attach_device_args; + remote_domain_create_args val_remote_domain_create_args; + remote_domain_create_xml_args val_remote_domain_create_xml_args; + remote_domain_define_xml_args val_remote_domain_define_xml_args; + remote_domain_destroy_args val_remote_domain_destroy_args; + remote_domain_detach_device_args val_remote_domain_detach_device_args; + remote_domain_dump_xml_args val_remote_domain_dump_xml_args; + remote_domain_get_autostart_args val_remote_domain_get_autostart_args; + remote_domain_get_info_args val_remote_domain_get_info_args; + remote_domain_get_max_memory_args val_remote_domain_get_max_memory_args; + remote_domain_get_max_vcpus_args val_remote_domain_get_max_vcpus_args; + remote_domain_get_os_type_args val_remote_domain_get_os_type_args; + remote_domain_get_vcpus_args val_remote_domain_get_vcpus_args; + remote_list_defined_domains_args val_remote_list_defined_domains_args; + remote_domain_lookup_by_id_args val_remote_domain_lookup_by_id_args; + remote_domain_lookup_by_name_args val_remote_domain_lookup_by_name_args; + remote_domain_lookup_by_uuid_args val_remote_domain_lookup_by_uuid_args; + remote_domain_pin_vcpu_args val_remote_domain_pin_vcpu_args; + remote_domain_reboot_args val_remote_domain_reboot_args; + remote_domain_resume_args val_remote_domain_resume_args; + remote_domain_set_autostart_args val_remote_domain_set_autostart_args; + remote_domain_set_max_memory_args val_remote_domain_set_max_memory_args; + remote_domain_set_memory_args val_remote_domain_set_memory_args; + remote_domain_set_vcpus_args val_remote_domain_set_vcpus_args; + remote_domain_shutdown_args val_remote_domain_shutdown_args; + remote_domain_suspend_args val_remote_domain_suspend_args; + remote_domain_undefine_args val_remote_domain_undefine_args; + remote_list_defined_networks_args val_remote_list_defined_networks_args; + remote_list_domains_args val_remote_list_domains_args; + remote_list_networks_args val_remote_list_networks_args; + remote_network_create_args val_remote_network_create_args; + remote_network_create_xml_args val_remote_network_create_xml_args; + remote_network_define_xml_args val_remote_network_define_xml_args; + remote_network_destroy_args val_remote_network_destroy_args; + remote_network_dump_xml_args val_remote_network_dump_xml_args; + remote_network_get_autostart_args val_remote_network_get_autostart_args; + remote_network_get_bridge_name_args val_remote_network_get_bridge_name_args; + remote_network_lookup_by_name_args val_remote_network_lookup_by_name_args; + remote_network_lookup_by_uuid_args val_remote_network_lookup_by_uuid_args; + remote_network_set_autostart_args val_remote_network_set_autostart_args; + remote_network_undefine_args val_remote_network_undefine_args; + remote_domain_core_dump_args val_remote_domain_core_dump_args; + remote_domain_restore_args val_remote_domain_restore_args; + remote_domain_save_args val_remote_domain_save_args; + remote_domain_get_scheduler_type_args val_remote_domain_get_scheduler_type_args; + remote_domain_get_scheduler_parameters_args val_remote_domain_get_scheduler_parameters_args; + remote_domain_set_scheduler_parameters_args val_remote_domain_set_scheduler_parameters_args; + remote_supports_feature_args val_remote_supports_feature_args; + remote_domain_migrate_prepare_args val_remote_domain_migrate_prepare_args; + remote_domain_migrate_perform_args val_remote_domain_migrate_perform_args; + remote_domain_migrate_finish_args val_remote_domain_migrate_finish_args; + remote_domain_block_stats_args val_remote_domain_block_stats_args; + remote_domain_interface_stats_args val_remote_domain_interface_stats_args; + remote_auth_sasl_start_args val_remote_auth_sasl_start_args; + remote_auth_sasl_step_args val_remote_auth_sasl_step_args; + remote_list_storage_pools_args val_remote_list_storage_pools_args; + remote_list_defined_storage_pools_args val_remote_list_defined_storage_pools_args; + remote_find_storage_pool_sources_args val_remote_find_storage_pool_sources_args; + remote_storage_pool_create_xml_args val_remote_storage_pool_create_xml_args; + remote_storage_pool_define_xml_args val_remote_storage_pool_define_xml_args; + remote_storage_pool_create_args val_remote_storage_pool_create_args; + remote_storage_pool_build_args val_remote_storage_pool_build_args; + remote_storage_pool_destroy_args val_remote_storage_pool_destroy_args; + remote_storage_pool_delete_args val_remote_storage_pool_delete_args; + remote_storage_pool_undefine_args val_remote_storage_pool_undefine_args; + remote_storage_pool_refresh_args val_remote_storage_pool_refresh_args; + remote_storage_pool_lookup_by_name_args val_remote_storage_pool_lookup_by_name_args; + remote_storage_pool_lookup_by_uuid_args val_remote_storage_pool_lookup_by_uuid_args; + remote_storage_pool_lookup_by_volume_args val_remote_storage_pool_lookup_by_volume_args; + remote_storage_pool_get_info_args val_remote_storage_pool_get_info_args; + remote_storage_pool_dump_xml_args val_remote_storage_pool_dump_xml_args; + remote_storage_pool_get_autostart_args val_remote_storage_pool_get_autostart_args; + remote_storage_pool_set_autostart_args val_remote_storage_pool_set_autostart_args; + remote_storage_pool_num_of_volumes_args val_remote_storage_pool_num_of_volumes_args; + remote_storage_pool_list_volumes_args val_remote_storage_pool_list_volumes_args; + remote_storage_vol_create_xml_args val_remote_storage_vol_create_xml_args; + remote_storage_vol_delete_args val_remote_storage_vol_delete_args; + remote_storage_vol_lookup_by_name_args val_remote_storage_vol_lookup_by_name_args; + remote_storage_vol_lookup_by_key_args val_remote_storage_vol_lookup_by_key_args; + remote_storage_vol_lookup_by_path_args val_remote_storage_vol_lookup_by_path_args; + remote_storage_vol_get_info_args val_remote_storage_vol_get_info_args; + remote_storage_vol_dump_xml_args val_remote_storage_vol_dump_xml_args; + remote_storage_vol_get_path_args val_remote_storage_vol_get_path_args; + remote_node_get_cells_free_memory_args val_remote_node_get_cells_free_memory_args; + remote_domain_block_peek_args val_remote_domain_block_peek_args; + remote_domain_memory_peek_args val_remote_domain_memory_peek_args; + remote_domain_migrate_prepare2_args val_remote_domain_migrate_prepare2_args; + remote_domain_migrate_finish2_args val_remote_domain_migrate_finish2_args; + remote_node_num_of_devices_args val_remote_node_num_of_devices_args; + remote_node_list_devices_args val_remote_node_list_devices_args; + remote_node_device_lookup_by_name_args val_remote_node_device_lookup_by_name_args; + remote_node_device_dump_xml_args val_remote_node_device_dump_xml_args; + remote_node_device_get_parent_args val_remote_node_device_get_parent_args; + remote_node_device_num_of_caps_args val_remote_node_device_num_of_caps_args; + remote_node_device_list_caps_args val_remote_node_device_list_caps_args; + remote_node_device_dettach_args val_remote_node_device_dettach_args; + remote_node_device_re_attach_args val_remote_node_device_re_attach_args; + remote_node_device_reset_args val_remote_node_device_reset_args; + remote_domain_get_security_label_args val_remote_domain_get_security_label_args; + remote_node_device_create_xml_args val_remote_node_device_create_xml_args; + remote_node_device_destroy_args val_remote_node_device_destroy_args; + remote_storage_vol_create_xml_from_args val_remote_storage_vol_create_xml_from_args; + remote_list_interfaces_args val_remote_list_interfaces_args; + remote_interface_lookup_by_name_args val_remote_interface_lookup_by_name_args; + remote_interface_lookup_by_mac_string_args val_remote_interface_lookup_by_mac_string_args; + remote_interface_get_xml_desc_args val_remote_interface_get_xml_desc_args; + remote_interface_define_xml_args val_remote_interface_define_xml_args; + remote_interface_undefine_args val_remote_interface_undefine_args; + remote_interface_create_args val_remote_interface_create_args; + remote_interface_destroy_args val_remote_interface_destroy_args; + remote_domain_xml_from_native_args val_remote_domain_xml_from_native_args; + remote_domain_xml_to_native_args val_remote_domain_xml_to_native_args; + remote_list_defined_interfaces_args val_remote_list_defined_interfaces_args; + remote_list_secrets_args val_remote_list_secrets_args; + remote_secret_lookup_by_uuid_args val_remote_secret_lookup_by_uuid_args; + remote_secret_define_xml_args val_remote_secret_define_xml_args; + remote_secret_get_xml_desc_args val_remote_secret_get_xml_desc_args; + remote_secret_set_value_args val_remote_secret_set_value_args; + remote_secret_get_value_args val_remote_secret_get_value_args; + remote_secret_undefine_args val_remote_secret_undefine_args; + remote_secret_lookup_by_usage_args val_remote_secret_lookup_by_usage_args; diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h new file mode 100644 index 0000000000..0605542015 --- /dev/null +++ b/daemon/remote_dispatch_prototypes.h @@ -0,0 +1,1026 @@ +/* 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); diff --git a/daemon/remote_dispatch_ret.h b/daemon/remote_dispatch_ret.h new file mode 100644 index 0000000000..6ced13a2e8 --- /dev/null +++ b/daemon/remote_dispatch_ret.h @@ -0,0 +1,108 @@ +/* Automatically generated by remote_generate_stubs.pl. + * Do not edit this file. Any changes you make will be lost. + */ + + remote_get_type_ret val_remote_get_type_ret; + remote_get_version_ret val_remote_get_version_ret; + remote_get_max_vcpus_ret val_remote_get_max_vcpus_ret; + remote_node_get_info_ret val_remote_node_get_info_ret; + remote_get_capabilities_ret val_remote_get_capabilities_ret; + remote_domain_create_xml_ret val_remote_domain_create_xml_ret; + remote_domain_define_xml_ret val_remote_domain_define_xml_ret; + remote_domain_dump_xml_ret val_remote_domain_dump_xml_ret; + remote_domain_get_autostart_ret val_remote_domain_get_autostart_ret; + remote_domain_get_info_ret val_remote_domain_get_info_ret; + remote_domain_get_max_memory_ret val_remote_domain_get_max_memory_ret; + remote_domain_get_max_vcpus_ret val_remote_domain_get_max_vcpus_ret; + remote_domain_get_os_type_ret val_remote_domain_get_os_type_ret; + remote_domain_get_vcpus_ret val_remote_domain_get_vcpus_ret; + remote_list_defined_domains_ret val_remote_list_defined_domains_ret; + remote_domain_lookup_by_id_ret val_remote_domain_lookup_by_id_ret; + remote_domain_lookup_by_name_ret val_remote_domain_lookup_by_name_ret; + remote_domain_lookup_by_uuid_ret val_remote_domain_lookup_by_uuid_ret; + remote_num_of_defined_domains_ret val_remote_num_of_defined_domains_ret; + remote_list_defined_networks_ret val_remote_list_defined_networks_ret; + remote_list_domains_ret val_remote_list_domains_ret; + remote_list_networks_ret val_remote_list_networks_ret; + remote_network_create_xml_ret val_remote_network_create_xml_ret; + remote_network_define_xml_ret val_remote_network_define_xml_ret; + remote_network_dump_xml_ret val_remote_network_dump_xml_ret; + remote_network_get_autostart_ret val_remote_network_get_autostart_ret; + remote_network_get_bridge_name_ret val_remote_network_get_bridge_name_ret; + remote_network_lookup_by_name_ret val_remote_network_lookup_by_name_ret; + remote_network_lookup_by_uuid_ret val_remote_network_lookup_by_uuid_ret; + remote_num_of_defined_networks_ret val_remote_num_of_defined_networks_ret; + remote_num_of_domains_ret val_remote_num_of_domains_ret; + remote_num_of_networks_ret val_remote_num_of_networks_ret; + remote_domain_get_scheduler_type_ret val_remote_domain_get_scheduler_type_ret; + remote_domain_get_scheduler_parameters_ret val_remote_domain_get_scheduler_parameters_ret; + remote_get_hostname_ret val_remote_get_hostname_ret; + remote_supports_feature_ret val_remote_supports_feature_ret; + remote_domain_migrate_prepare_ret val_remote_domain_migrate_prepare_ret; + remote_domain_migrate_finish_ret val_remote_domain_migrate_finish_ret; + remote_domain_block_stats_ret val_remote_domain_block_stats_ret; + remote_domain_interface_stats_ret val_remote_domain_interface_stats_ret; + remote_auth_list_ret val_remote_auth_list_ret; + remote_auth_sasl_init_ret val_remote_auth_sasl_init_ret; + remote_auth_sasl_start_ret val_remote_auth_sasl_start_ret; + remote_auth_sasl_step_ret val_remote_auth_sasl_step_ret; + remote_auth_polkit_ret val_remote_auth_polkit_ret; + remote_num_of_storage_pools_ret val_remote_num_of_storage_pools_ret; + remote_list_storage_pools_ret val_remote_list_storage_pools_ret; + remote_num_of_defined_storage_pools_ret val_remote_num_of_defined_storage_pools_ret; + remote_list_defined_storage_pools_ret val_remote_list_defined_storage_pools_ret; + remote_find_storage_pool_sources_ret val_remote_find_storage_pool_sources_ret; + remote_storage_pool_create_xml_ret val_remote_storage_pool_create_xml_ret; + remote_storage_pool_define_xml_ret val_remote_storage_pool_define_xml_ret; + remote_storage_pool_lookup_by_name_ret val_remote_storage_pool_lookup_by_name_ret; + remote_storage_pool_lookup_by_uuid_ret val_remote_storage_pool_lookup_by_uuid_ret; + remote_storage_pool_lookup_by_volume_ret val_remote_storage_pool_lookup_by_volume_ret; + remote_storage_pool_get_info_ret val_remote_storage_pool_get_info_ret; + remote_storage_pool_dump_xml_ret val_remote_storage_pool_dump_xml_ret; + remote_storage_pool_get_autostart_ret val_remote_storage_pool_get_autostart_ret; + remote_storage_pool_num_of_volumes_ret val_remote_storage_pool_num_of_volumes_ret; + remote_storage_pool_list_volumes_ret val_remote_storage_pool_list_volumes_ret; + remote_storage_vol_create_xml_ret val_remote_storage_vol_create_xml_ret; + remote_storage_vol_lookup_by_name_ret val_remote_storage_vol_lookup_by_name_ret; + remote_storage_vol_lookup_by_key_ret val_remote_storage_vol_lookup_by_key_ret; + remote_storage_vol_lookup_by_path_ret val_remote_storage_vol_lookup_by_path_ret; + remote_storage_vol_get_info_ret val_remote_storage_vol_get_info_ret; + remote_storage_vol_dump_xml_ret val_remote_storage_vol_dump_xml_ret; + remote_storage_vol_get_path_ret val_remote_storage_vol_get_path_ret; + remote_node_get_cells_free_memory_ret val_remote_node_get_cells_free_memory_ret; + remote_node_get_free_memory_ret val_remote_node_get_free_memory_ret; + remote_domain_block_peek_ret val_remote_domain_block_peek_ret; + remote_domain_memory_peek_ret val_remote_domain_memory_peek_ret; + remote_domain_events_register_ret val_remote_domain_events_register_ret; + remote_domain_events_deregister_ret val_remote_domain_events_deregister_ret; + remote_domain_migrate_prepare2_ret val_remote_domain_migrate_prepare2_ret; + remote_domain_migrate_finish2_ret val_remote_domain_migrate_finish2_ret; + remote_get_uri_ret val_remote_get_uri_ret; + remote_node_num_of_devices_ret val_remote_node_num_of_devices_ret; + remote_node_list_devices_ret val_remote_node_list_devices_ret; + remote_node_device_lookup_by_name_ret val_remote_node_device_lookup_by_name_ret; + remote_node_device_dump_xml_ret val_remote_node_device_dump_xml_ret; + remote_node_device_get_parent_ret val_remote_node_device_get_parent_ret; + remote_node_device_num_of_caps_ret val_remote_node_device_num_of_caps_ret; + remote_node_device_list_caps_ret val_remote_node_device_list_caps_ret; + remote_domain_get_security_label_ret val_remote_domain_get_security_label_ret; + remote_node_get_security_model_ret val_remote_node_get_security_model_ret; + remote_node_device_create_xml_ret val_remote_node_device_create_xml_ret; + remote_storage_vol_create_xml_from_ret val_remote_storage_vol_create_xml_from_ret; + remote_num_of_interfaces_ret val_remote_num_of_interfaces_ret; + remote_list_interfaces_ret val_remote_list_interfaces_ret; + remote_interface_lookup_by_name_ret val_remote_interface_lookup_by_name_ret; + remote_interface_lookup_by_mac_string_ret val_remote_interface_lookup_by_mac_string_ret; + remote_interface_get_xml_desc_ret val_remote_interface_get_xml_desc_ret; + remote_interface_define_xml_ret val_remote_interface_define_xml_ret; + remote_domain_xml_from_native_ret val_remote_domain_xml_from_native_ret; + remote_domain_xml_to_native_ret val_remote_domain_xml_to_native_ret; + remote_num_of_defined_interfaces_ret val_remote_num_of_defined_interfaces_ret; + remote_list_defined_interfaces_ret val_remote_list_defined_interfaces_ret; + remote_num_of_secrets_ret val_remote_num_of_secrets_ret; + remote_list_secrets_ret val_remote_list_secrets_ret; + remote_secret_lookup_by_uuid_ret val_remote_secret_lookup_by_uuid_ret; + remote_secret_define_xml_ret val_remote_secret_define_xml_ret; + remote_secret_get_xml_desc_ret val_remote_secret_get_xml_desc_ret; + remote_secret_get_value_ret val_remote_secret_get_value_ret; + remote_secret_lookup_by_usage_ret val_remote_secret_lookup_by_usage_ret; diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h new file mode 100644 index 0000000000..6b5df80657 --- /dev/null +++ b/daemon/remote_dispatch_table.h @@ -0,0 +1,744 @@ +/* Automatically generated by remote_generate_stubs.pl. + * Do not edit this file. Any changes you make will be lost. + */ + +{ /* (unused) => 0 */ + .fn = NULL, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* Open => 1 */ + .fn = (dispatch_fn) remoteDispatchOpen, + .args_filter = (xdrproc_t) xdr_remote_open_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* Close => 2 */ + .fn = (dispatch_fn) remoteDispatchClose, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* GetType => 3 */ + .fn = (dispatch_fn) remoteDispatchGetType, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_get_type_ret, +}, +{ /* GetVersion => 4 */ + .fn = (dispatch_fn) remoteDispatchGetVersion, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_get_version_ret, +}, +{ /* GetMaxVcpus => 5 */ + .fn = (dispatch_fn) remoteDispatchGetMaxVcpus, + .args_filter = (xdrproc_t) xdr_remote_get_max_vcpus_args, + .ret_filter = (xdrproc_t) xdr_remote_get_max_vcpus_ret, +}, +{ /* NodeGetInfo => 6 */ + .fn = (dispatch_fn) remoteDispatchNodeGetInfo, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_node_get_info_ret, +}, +{ /* GetCapabilities => 7 */ + .fn = (dispatch_fn) remoteDispatchGetCapabilities, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_get_capabilities_ret, +}, +{ /* DomainAttachDevice => 8 */ + .fn = (dispatch_fn) remoteDispatchDomainAttachDevice, + .args_filter = (xdrproc_t) xdr_remote_domain_attach_device_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainCreate => 9 */ + .fn = (dispatch_fn) remoteDispatchDomainCreate, + .args_filter = (xdrproc_t) xdr_remote_domain_create_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainCreateXml => 10 */ + .fn = (dispatch_fn) remoteDispatchDomainCreateXml, + .args_filter = (xdrproc_t) xdr_remote_domain_create_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_create_xml_ret, +}, +{ /* DomainDefineXml => 11 */ + .fn = (dispatch_fn) remoteDispatchDomainDefineXml, + .args_filter = (xdrproc_t) xdr_remote_domain_define_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_define_xml_ret, +}, +{ /* DomainDestroy => 12 */ + .fn = (dispatch_fn) remoteDispatchDomainDestroy, + .args_filter = (xdrproc_t) xdr_remote_domain_destroy_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainDetachDevice => 13 */ + .fn = (dispatch_fn) remoteDispatchDomainDetachDevice, + .args_filter = (xdrproc_t) xdr_remote_domain_detach_device_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainDumpXml => 14 */ + .fn = (dispatch_fn) remoteDispatchDomainDumpXml, + .args_filter = (xdrproc_t) xdr_remote_domain_dump_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_dump_xml_ret, +}, +{ /* DomainGetAutostart => 15 */ + .fn = (dispatch_fn) remoteDispatchDomainGetAutostart, + .args_filter = (xdrproc_t) xdr_remote_domain_get_autostart_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_autostart_ret, +}, +{ /* DomainGetInfo => 16 */ + .fn = (dispatch_fn) remoteDispatchDomainGetInfo, + .args_filter = (xdrproc_t) xdr_remote_domain_get_info_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_info_ret, +}, +{ /* DomainGetMaxMemory => 17 */ + .fn = (dispatch_fn) remoteDispatchDomainGetMaxMemory, + .args_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_ret, +}, +{ /* DomainGetMaxVcpus => 18 */ + .fn = (dispatch_fn) remoteDispatchDomainGetMaxVcpus, + .args_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret, +}, +{ /* DomainGetOsType => 19 */ + .fn = (dispatch_fn) remoteDispatchDomainGetOsType, + .args_filter = (xdrproc_t) xdr_remote_domain_get_os_type_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_os_type_ret, +}, +{ /* DomainGetVcpus => 20 */ + .fn = (dispatch_fn) remoteDispatchDomainGetVcpus, + .args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_ret, +}, +{ /* ListDefinedDomains => 21 */ + .fn = (dispatch_fn) remoteDispatchListDefinedDomains, + .args_filter = (xdrproc_t) xdr_remote_list_defined_domains_args, + .ret_filter = (xdrproc_t) xdr_remote_list_defined_domains_ret, +}, +{ /* DomainLookupById => 22 */ + .fn = (dispatch_fn) remoteDispatchDomainLookupById, + .args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_ret, +}, +{ /* DomainLookupByName => 23 */ + .fn = (dispatch_fn) remoteDispatchDomainLookupByName, + .args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_ret, +}, +{ /* DomainLookupByUuid => 24 */ + .fn = (dispatch_fn) remoteDispatchDomainLookupByUuid, + .args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret, +}, +{ /* NumOfDefinedDomains => 25 */ + .fn = (dispatch_fn) remoteDispatchNumOfDefinedDomains, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_defined_domains_ret, +}, +{ /* DomainPinVcpu => 26 */ + .fn = (dispatch_fn) remoteDispatchDomainPinVcpu, + .args_filter = (xdrproc_t) xdr_remote_domain_pin_vcpu_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainReboot => 27 */ + .fn = (dispatch_fn) remoteDispatchDomainReboot, + .args_filter = (xdrproc_t) xdr_remote_domain_reboot_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainResume => 28 */ + .fn = (dispatch_fn) remoteDispatchDomainResume, + .args_filter = (xdrproc_t) xdr_remote_domain_resume_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSetAutostart => 29 */ + .fn = (dispatch_fn) remoteDispatchDomainSetAutostart, + .args_filter = (xdrproc_t) xdr_remote_domain_set_autostart_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSetMaxMemory => 30 */ + .fn = (dispatch_fn) remoteDispatchDomainSetMaxMemory, + .args_filter = (xdrproc_t) xdr_remote_domain_set_max_memory_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSetMemory => 31 */ + .fn = (dispatch_fn) remoteDispatchDomainSetMemory, + .args_filter = (xdrproc_t) xdr_remote_domain_set_memory_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSetVcpus => 32 */ + .fn = (dispatch_fn) remoteDispatchDomainSetVcpus, + .args_filter = (xdrproc_t) xdr_remote_domain_set_vcpus_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainShutdown => 33 */ + .fn = (dispatch_fn) remoteDispatchDomainShutdown, + .args_filter = (xdrproc_t) xdr_remote_domain_shutdown_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSuspend => 34 */ + .fn = (dispatch_fn) remoteDispatchDomainSuspend, + .args_filter = (xdrproc_t) xdr_remote_domain_suspend_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainUndefine => 35 */ + .fn = (dispatch_fn) remoteDispatchDomainUndefine, + .args_filter = (xdrproc_t) xdr_remote_domain_undefine_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* ListDefinedNetworks => 36 */ + .fn = (dispatch_fn) remoteDispatchListDefinedNetworks, + .args_filter = (xdrproc_t) xdr_remote_list_defined_networks_args, + .ret_filter = (xdrproc_t) xdr_remote_list_defined_networks_ret, +}, +{ /* ListDomains => 37 */ + .fn = (dispatch_fn) remoteDispatchListDomains, + .args_filter = (xdrproc_t) xdr_remote_list_domains_args, + .ret_filter = (xdrproc_t) xdr_remote_list_domains_ret, +}, +{ /* ListNetworks => 38 */ + .fn = (dispatch_fn) remoteDispatchListNetworks, + .args_filter = (xdrproc_t) xdr_remote_list_networks_args, + .ret_filter = (xdrproc_t) xdr_remote_list_networks_ret, +}, +{ /* NetworkCreate => 39 */ + .fn = (dispatch_fn) remoteDispatchNetworkCreate, + .args_filter = (xdrproc_t) xdr_remote_network_create_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NetworkCreateXml => 40 */ + .fn = (dispatch_fn) remoteDispatchNetworkCreateXml, + .args_filter = (xdrproc_t) xdr_remote_network_create_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_network_create_xml_ret, +}, +{ /* NetworkDefineXml => 41 */ + .fn = (dispatch_fn) remoteDispatchNetworkDefineXml, + .args_filter = (xdrproc_t) xdr_remote_network_define_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_network_define_xml_ret, +}, +{ /* NetworkDestroy => 42 */ + .fn = (dispatch_fn) remoteDispatchNetworkDestroy, + .args_filter = (xdrproc_t) xdr_remote_network_destroy_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NetworkDumpXml => 43 */ + .fn = (dispatch_fn) remoteDispatchNetworkDumpXml, + .args_filter = (xdrproc_t) xdr_remote_network_dump_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_network_dump_xml_ret, +}, +{ /* NetworkGetAutostart => 44 */ + .fn = (dispatch_fn) remoteDispatchNetworkGetAutostart, + .args_filter = (xdrproc_t) xdr_remote_network_get_autostart_args, + .ret_filter = (xdrproc_t) xdr_remote_network_get_autostart_ret, +}, +{ /* NetworkGetBridgeName => 45 */ + .fn = (dispatch_fn) remoteDispatchNetworkGetBridgeName, + .args_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_args, + .ret_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_ret, +}, +{ /* NetworkLookupByName => 46 */ + .fn = (dispatch_fn) remoteDispatchNetworkLookupByName, + .args_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_ret, +}, +{ /* NetworkLookupByUuid => 47 */ + .fn = (dispatch_fn) remoteDispatchNetworkLookupByUuid, + .args_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_args, + .ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret, +}, +{ /* NetworkSetAutostart => 48 */ + .fn = (dispatch_fn) remoteDispatchNetworkSetAutostart, + .args_filter = (xdrproc_t) xdr_remote_network_set_autostart_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NetworkUndefine => 49 */ + .fn = (dispatch_fn) remoteDispatchNetworkUndefine, + .args_filter = (xdrproc_t) xdr_remote_network_undefine_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NumOfDefinedNetworks => 50 */ + .fn = (dispatch_fn) remoteDispatchNumOfDefinedNetworks, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_defined_networks_ret, +}, +{ /* NumOfDomains => 51 */ + .fn = (dispatch_fn) remoteDispatchNumOfDomains, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret, +}, +{ /* NumOfNetworks => 52 */ + .fn = (dispatch_fn) remoteDispatchNumOfNetworks, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_networks_ret, +}, +{ /* DomainCoreDump => 53 */ + .fn = (dispatch_fn) remoteDispatchDomainCoreDump, + .args_filter = (xdrproc_t) xdr_remote_domain_core_dump_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainRestore => 54 */ + .fn = (dispatch_fn) remoteDispatchDomainRestore, + .args_filter = (xdrproc_t) xdr_remote_domain_restore_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainSave => 55 */ + .fn = (dispatch_fn) remoteDispatchDomainSave, + .args_filter = (xdrproc_t) xdr_remote_domain_save_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainGetSchedulerType => 56 */ + .fn = (dispatch_fn) remoteDispatchDomainGetSchedulerType, + .args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_type_ret, +}, +{ /* DomainGetSchedulerParameters => 57 */ + .fn = (dispatch_fn) remoteDispatchDomainGetSchedulerParameters, + .args_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_scheduler_parameters_ret, +}, +{ /* DomainSetSchedulerParameters => 58 */ + .fn = (dispatch_fn) remoteDispatchDomainSetSchedulerParameters, + .args_filter = (xdrproc_t) xdr_remote_domain_set_scheduler_parameters_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* GetHostname => 59 */ + .fn = (dispatch_fn) remoteDispatchGetHostname, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_get_hostname_ret, +}, +{ /* SupportsFeature => 60 */ + .fn = (dispatch_fn) remoteDispatchSupportsFeature, + .args_filter = (xdrproc_t) xdr_remote_supports_feature_args, + .ret_filter = (xdrproc_t) xdr_remote_supports_feature_ret, +}, +{ /* DomainMigratePrepare => 61 */ + .fn = (dispatch_fn) remoteDispatchDomainMigratePrepare, + .args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_ret, +}, +{ /* DomainMigratePerform => 62 */ + .fn = (dispatch_fn) remoteDispatchDomainMigratePerform, + .args_filter = (xdrproc_t) xdr_remote_domain_migrate_perform_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainMigrateFinish => 63 */ + .fn = (dispatch_fn) remoteDispatchDomainMigrateFinish, + .args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish_ret, +}, +{ /* DomainBlockStats => 64 */ + .fn = (dispatch_fn) remoteDispatchDomainBlockStats, + .args_filter = (xdrproc_t) xdr_remote_domain_block_stats_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_block_stats_ret, +}, +{ /* DomainInterfaceStats => 65 */ + .fn = (dispatch_fn) remoteDispatchDomainInterfaceStats, + .args_filter = (xdrproc_t) xdr_remote_domain_interface_stats_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_interface_stats_ret, +}, +{ /* AuthList => 66 */ + .fn = (dispatch_fn) remoteDispatchAuthList, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_auth_list_ret, +}, +{ /* AuthSaslInit => 67 */ + .fn = (dispatch_fn) remoteDispatchAuthSaslInit, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_auth_sasl_init_ret, +}, +{ /* AuthSaslStart => 68 */ + .fn = (dispatch_fn) remoteDispatchAuthSaslStart, + .args_filter = (xdrproc_t) xdr_remote_auth_sasl_start_args, + .ret_filter = (xdrproc_t) xdr_remote_auth_sasl_start_ret, +}, +{ /* AuthSaslStep => 69 */ + .fn = (dispatch_fn) remoteDispatchAuthSaslStep, + .args_filter = (xdrproc_t) xdr_remote_auth_sasl_step_args, + .ret_filter = (xdrproc_t) xdr_remote_auth_sasl_step_ret, +}, +{ /* AuthPolkit => 70 */ + .fn = (dispatch_fn) remoteDispatchAuthPolkit, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_auth_polkit_ret, +}, +{ /* NumOfStoragePools => 71 */ + .fn = (dispatch_fn) remoteDispatchNumOfStoragePools, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_storage_pools_ret, +}, +{ /* ListStoragePools => 72 */ + .fn = (dispatch_fn) remoteDispatchListStoragePools, + .args_filter = (xdrproc_t) xdr_remote_list_storage_pools_args, + .ret_filter = (xdrproc_t) xdr_remote_list_storage_pools_ret, +}, +{ /* NumOfDefinedStoragePools => 73 */ + .fn = (dispatch_fn) remoteDispatchNumOfDefinedStoragePools, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret, +}, +{ /* ListDefinedStoragePools => 74 */ + .fn = (dispatch_fn) remoteDispatchListDefinedStoragePools, + .args_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_args, + .ret_filter = (xdrproc_t) xdr_remote_list_defined_storage_pools_ret, +}, +{ /* FindStoragePoolSources => 75 */ + .fn = (dispatch_fn) remoteDispatchFindStoragePoolSources, + .args_filter = (xdrproc_t) xdr_remote_find_storage_pool_sources_args, + .ret_filter = (xdrproc_t) xdr_remote_find_storage_pool_sources_ret, +}, +{ /* StoragePoolCreateXml => 76 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolCreateXml, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_create_xml_ret, +}, +{ /* StoragePoolDefineXml => 77 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolDefineXml, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_define_xml_ret, +}, +{ /* StoragePoolCreate => 78 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolCreate, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_create_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolBuild => 79 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolBuild, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_build_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolDestroy => 80 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolDestroy, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_destroy_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolDelete => 81 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolDelete, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_delete_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolUndefine => 82 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolUndefine, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_undefine_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolRefresh => 83 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolRefresh, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_refresh_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolLookupByName => 84 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolLookupByName, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret, +}, +{ /* StoragePoolLookupByUuid => 85 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolLookupByUuid, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret, +}, +{ /* StoragePoolLookupByVolume => 86 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolLookupByVolume, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret, +}, +{ /* StoragePoolGetInfo => 87 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolGetInfo, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_info_ret, +}, +{ /* StoragePoolDumpXml => 88 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolDumpXml, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret, +}, +{ /* StoragePoolGetAutostart => 89 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolGetAutostart, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_get_autostart_ret, +}, +{ /* StoragePoolSetAutostart => 90 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolSetAutostart, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_set_autostart_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StoragePoolNumOfVolumes => 91 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolNumOfVolumes, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret, +}, +{ /* StoragePoolListVolumes => 92 */ + .fn = (dispatch_fn) remoteDispatchStoragePoolListVolumes, + .args_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, +}, +{ /* StorageVolCreateXml => 93 */ + .fn = (dispatch_fn) remoteDispatchStorageVolCreateXml, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_ret, +}, +{ /* StorageVolDelete => 94 */ + .fn = (dispatch_fn) remoteDispatchStorageVolDelete, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_delete_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StorageVolLookupByName => 95 */ + .fn = (dispatch_fn) remoteDispatchStorageVolLookupByName, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret, +}, +{ /* StorageVolLookupByKey => 96 */ + .fn = (dispatch_fn) remoteDispatchStorageVolLookupByKey, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret, +}, +{ /* StorageVolLookupByPath => 97 */ + .fn = (dispatch_fn) remoteDispatchStorageVolLookupByPath, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret, +}, +{ /* StorageVolGetInfo => 98 */ + .fn = (dispatch_fn) remoteDispatchStorageVolGetInfo, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_info_ret, +}, +{ /* StorageVolDumpXml => 99 */ + .fn = (dispatch_fn) remoteDispatchStorageVolDumpXml, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret, +}, +{ /* StorageVolGetPath => 100 */ + .fn = (dispatch_fn) remoteDispatchStorageVolGetPath, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_get_path_ret, +}, +{ /* NodeGetCellsFreeMemory => 101 */ + .fn = (dispatch_fn) remoteDispatchNodeGetCellsFreeMemory, + .args_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_args, + .ret_filter = (xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, +}, +{ /* NodeGetFreeMemory => 102 */ + .fn = (dispatch_fn) remoteDispatchNodeGetFreeMemory, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_node_get_free_memory_ret, +}, +{ /* DomainBlockPeek => 103 */ + .fn = (dispatch_fn) remoteDispatchDomainBlockPeek, + .args_filter = (xdrproc_t) xdr_remote_domain_block_peek_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_block_peek_ret, +}, +{ /* DomainMemoryPeek => 104 */ + .fn = (dispatch_fn) remoteDispatchDomainMemoryPeek, + .args_filter = (xdrproc_t) xdr_remote_domain_memory_peek_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_memory_peek_ret, +}, +{ /* DomainEventsRegister => 105 */ + .fn = (dispatch_fn) remoteDispatchDomainEventsRegister, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_domain_events_register_ret, +}, +{ /* DomainEventsDeregister => 106 */ + .fn = (dispatch_fn) remoteDispatchDomainEventsDeregister, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_domain_events_deregister_ret, +}, +{ /* Async event DomainEvent => 107 */ + .fn = NULL, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainMigratePrepare2 => 108 */ + .fn = (dispatch_fn) remoteDispatchDomainMigratePrepare2, + .args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare2_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare2_ret, +}, +{ /* DomainMigrateFinish2 => 109 */ + .fn = (dispatch_fn) remoteDispatchDomainMigrateFinish2, + .args_filter = (xdrproc_t) xdr_remote_domain_migrate_finish2_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_migrate_finish2_ret, +}, +{ /* GetUri => 110 */ + .fn = (dispatch_fn) remoteDispatchGetUri, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_get_uri_ret, +}, +{ /* NodeNumOfDevices => 111 */ + .fn = (dispatch_fn) remoteDispatchNodeNumOfDevices, + .args_filter = (xdrproc_t) xdr_remote_node_num_of_devices_args, + .ret_filter = (xdrproc_t) xdr_remote_node_num_of_devices_ret, +}, +{ /* NodeListDevices => 112 */ + .fn = (dispatch_fn) remoteDispatchNodeListDevices, + .args_filter = (xdrproc_t) xdr_remote_node_list_devices_args, + .ret_filter = (xdrproc_t) xdr_remote_node_list_devices_ret, +}, +{ /* NodeDeviceLookupByName => 113 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceLookupByName, + .args_filter = (xdrproc_t) xdr_remote_node_device_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_lookup_by_name_ret, +}, +{ /* NodeDeviceDumpXml => 114 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceDumpXml, + .args_filter = (xdrproc_t) xdr_remote_node_device_dump_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_dump_xml_ret, +}, +{ /* NodeDeviceGetParent => 115 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceGetParent, + .args_filter = (xdrproc_t) xdr_remote_node_device_get_parent_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_get_parent_ret, +}, +{ /* NodeDeviceNumOfCaps => 116 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceNumOfCaps, + .args_filter = (xdrproc_t) xdr_remote_node_device_num_of_caps_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_num_of_caps_ret, +}, +{ /* NodeDeviceListCaps => 117 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceListCaps, + .args_filter = (xdrproc_t) xdr_remote_node_device_list_caps_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_list_caps_ret, +}, +{ /* NodeDeviceDettach => 118 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceDettach, + .args_filter = (xdrproc_t) xdr_remote_node_device_dettach_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NodeDeviceReAttach => 119 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceReAttach, + .args_filter = (xdrproc_t) xdr_remote_node_device_re_attach_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* NodeDeviceReset => 120 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceReset, + .args_filter = (xdrproc_t) xdr_remote_node_device_reset_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainGetSecurityLabel => 121 */ + .fn = (dispatch_fn) remoteDispatchDomainGetSecurityLabel, + .args_filter = (xdrproc_t) xdr_remote_domain_get_security_label_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_security_label_ret, +}, +{ /* NodeGetSecurityModel => 122 */ + .fn = (dispatch_fn) remoteDispatchNodeGetSecurityModel, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_node_get_security_model_ret, +}, +{ /* NodeDeviceCreateXml => 123 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceCreateXml, + .args_filter = (xdrproc_t) xdr_remote_node_device_create_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_node_device_create_xml_ret, +}, +{ /* NodeDeviceDestroy => 124 */ + .fn = (dispatch_fn) remoteDispatchNodeDeviceDestroy, + .args_filter = (xdrproc_t) xdr_remote_node_device_destroy_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* StorageVolCreateXmlFrom => 125 */ + .fn = (dispatch_fn) remoteDispatchStorageVolCreateXmlFrom, + .args_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_from_args, + .ret_filter = (xdrproc_t) xdr_remote_storage_vol_create_xml_from_ret, +}, +{ /* NumOfInterfaces => 126 */ + .fn = (dispatch_fn) remoteDispatchNumOfInterfaces, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_interfaces_ret, +}, +{ /* ListInterfaces => 127 */ + .fn = (dispatch_fn) remoteDispatchListInterfaces, + .args_filter = (xdrproc_t) xdr_remote_list_interfaces_args, + .ret_filter = (xdrproc_t) xdr_remote_list_interfaces_ret, +}, +{ /* InterfaceLookupByName => 128 */ + .fn = (dispatch_fn) remoteDispatchInterfaceLookupByName, + .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_args, + .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_ret, +}, +{ /* InterfaceLookupByMacString => 129 */ + .fn = (dispatch_fn) remoteDispatchInterfaceLookupByMacString, + .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_args, + .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_ret, +}, +{ /* InterfaceGetXmlDesc => 130 */ + .fn = (dispatch_fn) remoteDispatchInterfaceGetXmlDesc, + .args_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_args, + .ret_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_ret, +}, +{ /* InterfaceDefineXml => 131 */ + .fn = (dispatch_fn) remoteDispatchInterfaceDefineXml, + .args_filter = (xdrproc_t) xdr_remote_interface_define_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_interface_define_xml_ret, +}, +{ /* InterfaceUndefine => 132 */ + .fn = (dispatch_fn) remoteDispatchInterfaceUndefine, + .args_filter = (xdrproc_t) xdr_remote_interface_undefine_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* InterfaceCreate => 133 */ + .fn = (dispatch_fn) remoteDispatchInterfaceCreate, + .args_filter = (xdrproc_t) xdr_remote_interface_create_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* InterfaceDestroy => 134 */ + .fn = (dispatch_fn) remoteDispatchInterfaceDestroy, + .args_filter = (xdrproc_t) xdr_remote_interface_destroy_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* DomainXmlFromNative => 135 */ + .fn = (dispatch_fn) remoteDispatchDomainXmlFromNative, + .args_filter = (xdrproc_t) xdr_remote_domain_xml_from_native_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_xml_from_native_ret, +}, +{ /* DomainXmlToNative => 136 */ + .fn = (dispatch_fn) remoteDispatchDomainXmlToNative, + .args_filter = (xdrproc_t) xdr_remote_domain_xml_to_native_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_xml_to_native_ret, +}, +{ /* NumOfDefinedInterfaces => 137 */ + .fn = (dispatch_fn) remoteDispatchNumOfDefinedInterfaces, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_defined_interfaces_ret, +}, +{ /* ListDefinedInterfaces => 138 */ + .fn = (dispatch_fn) remoteDispatchListDefinedInterfaces, + .args_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_args, + .ret_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_ret, +}, +{ /* NumOfSecrets => 139 */ + .fn = (dispatch_fn) remoteDispatchNumOfSecrets, + .args_filter = (xdrproc_t) xdr_void, + .ret_filter = (xdrproc_t) xdr_remote_num_of_secrets_ret, +}, +{ /* ListSecrets => 140 */ + .fn = (dispatch_fn) remoteDispatchListSecrets, + .args_filter = (xdrproc_t) xdr_remote_list_secrets_args, + .ret_filter = (xdrproc_t) xdr_remote_list_secrets_ret, +}, +{ /* SecretLookupByUuid => 141 */ + .fn = (dispatch_fn) remoteDispatchSecretLookupByUuid, + .args_filter = (xdrproc_t) xdr_remote_secret_lookup_by_uuid_args, + .ret_filter = (xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret, +}, +{ /* SecretDefineXml => 142 */ + .fn = (dispatch_fn) remoteDispatchSecretDefineXml, + .args_filter = (xdrproc_t) xdr_remote_secret_define_xml_args, + .ret_filter = (xdrproc_t) xdr_remote_secret_define_xml_ret, +}, +{ /* SecretGetXmlDesc => 143 */ + .fn = (dispatch_fn) remoteDispatchSecretGetXmlDesc, + .args_filter = (xdrproc_t) xdr_remote_secret_get_xml_desc_args, + .ret_filter = (xdrproc_t) xdr_remote_secret_get_xml_desc_ret, +}, +{ /* SecretSetValue => 144 */ + .fn = (dispatch_fn) remoteDispatchSecretSetValue, + .args_filter = (xdrproc_t) xdr_remote_secret_set_value_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* SecretGetValue => 145 */ + .fn = (dispatch_fn) remoteDispatchSecretGetValue, + .args_filter = (xdrproc_t) xdr_remote_secret_get_value_args, + .ret_filter = (xdrproc_t) xdr_remote_secret_get_value_ret, +}, +{ /* SecretUndefine => 146 */ + .fn = (dispatch_fn) remoteDispatchSecretUndefine, + .args_filter = (xdrproc_t) xdr_remote_secret_undefine_args, + .ret_filter = (xdrproc_t) xdr_void, +}, +{ /* SecretLookupByUsage => 147 */ + .fn = (dispatch_fn) remoteDispatchSecretLookupByUsage, + .args_filter = (xdrproc_t) xdr_remote_secret_lookup_by_usage_args, + .ret_filter = (xdrproc_t) xdr_remote_secret_lookup_by_usage_ret, +}, diff --git a/daemon/remote_generate_stubs.pl b/daemon/remote_generate_stubs.pl new file mode 100755 index 0000000000..9bca0ccfd5 --- /dev/null +++ b/daemon/remote_generate_stubs.pl @@ -0,0 +1,178 @@ +#!/usr/bin/perl -w +# +# This script parses remote_protocol.x and produces lots of boilerplate +# code for both ends of the remote connection. +# +# By Richard Jones + +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"; + } + } +} diff --git a/daemon/remote_protocol.c b/daemon/remote_protocol.c new file mode 100644 index 0000000000..1d2d242148 --- /dev/null +++ b/daemon/remote_protocol.c @@ -0,0 +1,2744 @@ +#include +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#include "remote_protocol.h" +#include "internal.h" +#include + +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; +} diff --git a/daemon/remote_protocol.h b/daemon/remote_protocol.h new file mode 100644 index 0000000000..ceaf82c907 --- /dev/null +++ b/daemon/remote_protocol.h @@ -0,0 +1,2223 @@ +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#ifndef _RP_H_RPCGEN +#define _RP_H_RPCGEN + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + +#include "internal.h" +#include +#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 */ diff --git a/daemon/remote_protocol.x b/daemon/remote_protocol.x new file mode 100644 index 0000000000..29abdb7df8 --- /dev/null +++ b/daemon/remote_protocol.x @@ -0,0 +1,1596 @@ +/* -*- 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 + */ + +/* 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 + +/*----- 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; + +/* 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 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 (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; +}; + +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; +}; + +struct remote_domain_set_scheduler_parameters_args { + remote_nonnull_domain dom; + remote_sched_param params; +}; + +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; +}; + +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; +}; + +struct remote_list_domains_args { + int maxids; +}; + +struct remote_list_domains_ret { + int ids; +}; + +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_string uri_out; +}; + +struct remote_domain_migrate_perform_args { + remote_nonnull_domain dom; + opaque cookie; + 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_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_string uri_out; +}; + +struct remote_domain_migrate_finish2_args { + remote_nonnull_string dname; + opaque cookie; + 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; +}; + +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; +}; + +struct remote_domain_get_vcpus_args { + remote_nonnull_domain dom; + int maxinfo; + int maplen; +}; + +struct remote_domain_get_vcpus_ret { + remote_vcpu_info info; + opaque cpumaps; +}; + +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; + int enforcing; +}; + +struct remote_node_get_security_model_ret { + char model; + char doi; +}; + +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; +}; + +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; +}; + +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; +}; + +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; +}; + +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; +}; + +struct remote_auth_sasl_init_ret { + remote_nonnull_string mechlist; +}; + +struct remote_auth_sasl_start_args { + remote_nonnull_string mech; + int nil; + char data; +}; + +struct remote_auth_sasl_start_ret { + int complete; + int nil; + char data; +}; + +struct remote_auth_sasl_step_args { + int nil; + char data; +}; + +struct remote_auth_sasl_step_ret { + int complete; + int nil; + char data; +}; + +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; +}; + +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; +}; + +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; +}; + + + +/* 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; +}; + +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; +}; + +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; +}; + +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; + unsigned flags; +}; + +struct remote_secret_get_value_args { + remote_nonnull_secret secret; + unsigned flags; +}; + +struct remote_secret_get_value_ret { + opaque value; +}; + +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; +}; diff --git a/daemon/rpcgen_fix.pl b/daemon/rpcgen_fix.pl new file mode 100644 index 0000000000..4943765f6d --- /dev/null +++ b/daemon/rpcgen_fix.pl @@ -0,0 +1,91 @@ +# Fix XDR code (generated by rpcgen) so that it compiles +# with warnings turned on. +# +# This code is evil. Arguably better would be just to compile +# without -Werror. Update: The IXDR_PUT_LONG replacements are +# actually fixes for 64 bit, so this file is necessary. Arguably +# so is the type-punning fix. +# +# Copyright (C) 2007 Red Hat, Inc. +# +# See COPYING for the license of this software. +# +# Richard Jones + +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, $_; + } +} diff --git a/daemon/test_libvirtd.aug b/daemon/test_libvirtd.aug new file mode 100644 index 0000000000..b8da28e012 --- /dev/null +++ b/daemon/test_libvirtd.aug @@ -0,0 +1,545 @@ +module Test_libvirtd = + let conf = "# Master libvirt daemon configuration file +# +# For further information consult http://libvirt.org/format.html + + +################################################################# +# +# Network connectivity controls +# + +# Flag listening for secure TLS connections on the public TCP/IP port. +# NB, must pass the --listen flag to the libvirtd process for this to +# have any effect. +# +# It is necessary to setup a CA and issue server certificates before +# using this capability. +# +# This is enabled by default, uncomment this to disable it +listen_tls = 0 + +# Listen for unencrypted TCP connections on the public TCP/IP port. +# NB, must pass the --listen flag to the libvirtd process for this to +# have any effect. +# +# Using the TCP socket requires SASL authentication by default. Only +# SASL mechanisms which support data encryption are allowed. This is +# DIGEST_MD5 and GSSAPI (Kerberos5) +# +# This is disabled by default, uncomment this to enable it. +listen_tcp = 1 + + + +# Override the port for accepting secure TLS connections +# This can be a port number, or service name +# +tls_port = \"16514\" + +# Override the port for accepting insecure TCP connections +# This can be a port number, or service name +# +tcp_port = \"16509\" + + +# Override the default configuration which binds to all network +# interfaces. This can be a numeric IPv4/6 address, or hostname +# +listen_addr = \"192.168.0.1\" + + +# Flag toggling mDNS advertizement of the libvirt service. +# +# Alternatively can disable for all services on a host by +# stopping the Avahi daemon +# +# This is enabled by default, uncomment this to disable it +mdns_adv = 0 + +# Override the default mDNS advertizement name. This must be +# unique on the immediate broadcast network. +# +# The default is \"Virtualization Host HOSTNAME\", where HOSTNAME +# is subsituted for the short hostname of the machine (without domain) +# +mdns_name = \"Virtualization Host Joe Demo\" + + +################################################################# +# +# UNIX socket access controls +# + +# Set the UNIX domain socket group ownership. This can be used to +# allow a 'trusted' set of users access to management capabilities +# without becoming root. +# +# This is restricted to 'root' by default. +unix_sock_group = \"libvirt\" + +# Set the UNIX socket permissions for the R/O socket. This is used +# for monitoring VM status only +# +# Default allows any user. If setting group ownership may want to +# restrict this to: +unix_sock_ro_perms = \"0777\" + +# Set the UNIX socket permissions for the R/W socket. This is used +# for full management of VMs +# +# Default allows only root. If PolicyKit is enabled on the socket, +# the default will change to allow everyone (eg, 0777) +# +# If not using PolicyKit and setting group ownership for access +# control then you may want to relax this to: +unix_sock_rw_perms = \"0770\" + + + +################################################################# +# +# Authentication. +# +# - none: do not perform auth checks. If you can connect to the +# socket you are allowed. This is suitable if there are +# restrictions on connecting to the socket (eg, UNIX +# socket permissions), or if there is a lower layer in +# the network providing auth (eg, TLS/x509 certificates) +# +# - sasl: use SASL infrastructure. The actual auth scheme is then +# controlled from /etc/sasl2/libvirt.conf. For the TCP +# socket only GSSAPI & DIGEST-MD5 mechanisms will be used. +# For non-TCP or TLS sockets, any scheme is allowed. +# +# - polkit: use PolicyKit to authenticate. This is only suitable +# for use on the UNIX sockets. The default policy will +# require a user to supply their own password to gain +# full read/write access (aka sudo like), while anyone +# is allowed read/only access. +# +# Set an authentication scheme for UNIX read-only sockets +# By default socket permissions allow anyone to connect +# +# To restrict monitoring of domains you may wish to enable +# an authentication mechanism here +auth_unix_ro = \"none\" + +# Set an authentication scheme for UNIX read-write sockets +# By default socket permissions only allow root. If PolicyKit +# support was compiled into libvirt, the default will be to +# use 'polkit' auth. +# +# If the unix_sock_rw_perms are changed you may wish to enable +# an authentication mechanism here +auth_unix_rw = \"none\" + +# Change the authentication scheme for TCP sockets. +# +# If you don't enable SASL, then all TCP traffic is cleartext. +# Don't do this outside of a dev/test scenario. For real world +# use, always enable SASL and use the GSSAPI or DIGEST-MD5 +# mechanism in /etc/sasl2/libvirt.conf +auth_tcp = \"sasl\" + +# Change the authentication scheme for TLS sockets. +# +# TLS sockets already have encryption provided by the TLS +# layer, and limited authentication is done by certificates +# +# It is possible to make use of any SASL authentication +# mechanism as well, by using 'sasl' for this option +auth_tls = \"none\" + + + +################################################################# +# +# TLS x509 certificate configuration +# + + +# Override the default server key file path +# +key_file = \"/etc/pki/libvirt/private/serverkey.pem\" + +# Override the default server certificate file path +# +cert_file = \"/etc/pki/libvirt/servercert.pem\" + +# Override the default CA certificate path +# +ca_file = \"/etc/pki/CA/cacert.pem\" + +# Specify a certificate revocation list. +# +# Defaults to not using a CRL, uncomment to enable it +crl_file = \"/etc/pki/CA/crl.pem\" + + + +################################################################# +# +# Authorization controls +# + + +# Flag to disable verification of client certificates +# +# Client certificate verification is the primary authentication mechanism. +# Any client which does not present a certificate signed by the CA +# will be rejected. +# +# Default is to always verify. Uncommenting this will disable +# verification - make sure an IP whitelist is set +tls_no_verify_certificate = 1 + + +# A whitelist of allowed x509 Distinguished Names +# This list may contain wildcards such as +# +# \"C=GB,ST=London,L=London,O=Red Hat,CN=*\" +# +# See the POSIX fnmatch function for the format of the wildcards. +# +# NB If this is an empty list, no client can connect, so comment out +# entirely rather than using empty list to disable these checks +# +# By default, no DN's are checked + tls_allowed_dn_list = [\"DN1\", \"DN2\"] + + +# A whitelist of allowed SASL usernames. The format for usernames +# depends on the SASL authentication mechanism. Kerberos usernames +# look like username@REALM +# +# This list may contain wildcards such as +# +# \"*@EXAMPLE.COM\" +# +# See the POSIX fnmatch function for the format of the wildcards. +# +# NB If this is an empty list, no client can connect, so comment out +# entirely rather than using empty list to disable these checks +# +# By default, no Username's are checked +sasl_allowed_username_list = [ + \"joe@EXAMPLE.COM\", + \"fred@EXAMPLE.COM\" +] + + +################################################################# +# +# Processing controls +# + +# The maximum number of concurrent client connections to allow +# over all sockets combined. +max_clients = 20 + + +# The minimum limit sets the number of workers to start up +# initially. If the number of active clients exceeds this, +# then more threads are spawned, upto max_workers limit. +# Typically you'd want max_workers to equal maximum number +# of clients allowed +min_workers = 5 +max_workers = 20 + +# Total global limit on concurrent RPC calls. Should be +# at least as large as max_workers. Beyond this, RPC requests +# will be read into memory and queued. This directly impact +# memory usage, currently each request requires 256 KB of +# memory. So by default upto 5 MB of memory is used +max_requests = 20 + +# Limit on concurrent requests from a single client +# connection. To avoid one client monopolizing the server +# this should be a small fraction of the global max_requests +# and max_workers parameter +max_client_requests = 5 + +# Logging level: +log_level = 4 + +# Logging outputs: +log_outputs=\"4:stderr\" + +# Logging filters: +log_filters=\"a\" +" + + test Libvirtd.lns get conf = + { "#comment" = "Master libvirt daemon configuration file" } + { "#comment" = "" } + { "#comment" = "For further information consult http://libvirt.org/format.html" } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################" } + { "#comment" = "" } + { "#comment" = "Network connectivity controls" } + { "#comment" = "" } + { "#empty" } + { "#comment" = "Flag listening for secure TLS connections on the public TCP/IP port." } + { "#comment" = "NB, must pass the --listen flag to the libvirtd process for this to" } + { "#comment" = "have any effect." } + { "#comment" = "" } + { "#comment" = "It is necessary to setup a CA and issue server certificates before" } + { "#comment" = "using this capability." } + { "#comment" = "" } + { "#comment" = "This is enabled by default, uncomment this to disable it" } + { "listen_tls" = "0" } + { "#empty" } + { "#comment" = "Listen for unencrypted TCP connections on the public TCP/IP port." } + { "#comment" = "NB, must pass the --listen flag to the libvirtd process for this to" } + { "#comment" = "have any effect." } + { "#comment" = "" } + { "#comment" = "Using the TCP socket requires SASL authentication by default. Only" } + { "#comment" = "SASL mechanisms which support data encryption are allowed. This is" } + { "#comment" = "DIGEST_MD5 and GSSAPI (Kerberos5)" } + { "#comment" = "" } + { "#comment" = "This is disabled by default, uncomment this to enable it." } + { "listen_tcp" = "1" } + { "#empty" } + { "#empty" } + { "#empty" } + { "#comment" = "Override the port for accepting secure TLS connections" } + { "#comment" = "This can be a port number, or service name" } + { "#comment" = "" } + { "tls_port" = "16514" } + { "#empty" } + { "#comment" = "Override the port for accepting insecure TCP connections" } + { "#comment" = "This can be a port number, or service name" } + { "#comment" = "" } + { "tcp_port" = "16509" } + { "#empty" } + { "#empty" } + { "#comment" = "Override the default configuration which binds to all network" } + { "#comment" = "interfaces. This can be a numeric IPv4/6 address, or hostname" } + { "#comment" = "" } + { "listen_addr" = "192.168.0.1" } + { "#empty" } + { "#empty" } + { "#comment" = "Flag toggling mDNS advertizement of the libvirt service." } + { "#comment" = "" } + { "#comment" = "Alternatively can disable for all services on a host by" } + { "#comment" = "stopping the Avahi daemon" } + { "#comment" = "" } + { "#comment" = "This is enabled by default, uncomment this to disable it" } + { "mdns_adv" = "0" } + { "#empty" } + { "#comment" = "Override the default mDNS advertizement name. This must be" } + { "#comment" = "unique on the immediate broadcast network." } + { "#comment" = "" } + { "#comment" = "The default is \"Virtualization Host HOSTNAME\", where HOSTNAME" } + { "#comment" = "is subsituted for the short hostname of the machine (without domain)" } + { "#comment" = "" } + { "mdns_name" = "Virtualization Host Joe Demo" } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################" } + { "#comment" = "" } + { "#comment" = "UNIX socket access controls" } + { "#comment" = "" } + { "#empty" } + { "#comment" = "Set the UNIX domain socket group ownership. This can be used to" } + { "#comment" = "allow a 'trusted' set of users access to management capabilities" } + { "#comment" = "without becoming root." } + { "#comment" = "" } + { "#comment" = "This is restricted to 'root' by default." } + { "unix_sock_group" = "libvirt" } + { "#empty" } + { "#comment" = "Set the UNIX socket permissions for the R/O socket. This is used" } + { "#comment" = "for monitoring VM status only" } + { "#comment" = "" } + { "#comment" = "Default allows any user. If setting group ownership may want to" } + { "#comment" = "restrict this to:" } + { "unix_sock_ro_perms" = "0777" } + { "#empty" } + { "#comment" = "Set the UNIX socket permissions for the R/W socket. This is used" } + { "#comment" = "for full management of VMs" } + { "#comment" = "" } + { "#comment" = "Default allows only root. If PolicyKit is enabled on the socket," } + { "#comment" = "the default will change to allow everyone (eg, 0777)" } + { "#comment" = "" } + { "#comment" = "If not using PolicyKit and setting group ownership for access" } + { "#comment" = "control then you may want to relax this to:" } + { "unix_sock_rw_perms" = "0770" } + { "#empty" } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################" } + { "#comment" = "" } + { "#comment" = "Authentication." } + { "#comment" = "" } + { "#comment" = "- none: do not perform auth checks. If you can connect to the" } + { "#comment" = "socket you are allowed. This is suitable if there are" } + { "#comment" = "restrictions on connecting to the socket (eg, UNIX" } + { "#comment" = "socket permissions), or if there is a lower layer in" } + { "#comment" = "the network providing auth (eg, TLS/x509 certificates)" } + { "#comment" = "" } + { "#comment" = "- sasl: use SASL infrastructure. The actual auth scheme is then" } + { "#comment" = "controlled from /etc/sasl2/libvirt.conf. For the TCP" } + { "#comment" = "socket only GSSAPI & DIGEST-MD5 mechanisms will be used." } + { "#comment" = "For non-TCP or TLS sockets, any scheme is allowed." } + { "#comment" = "" } + { "#comment" = "- polkit: use PolicyKit to authenticate. This is only suitable" } + { "#comment" = "for use on the UNIX sockets. The default policy will" } + { "#comment" = "require a user to supply their own password to gain" } + { "#comment" = "full read/write access (aka sudo like), while anyone" } + { "#comment" = "is allowed read/only access." } + { "#comment" = "" } + { "#comment" = "Set an authentication scheme for UNIX read-only sockets" } + { "#comment" = "By default socket permissions allow anyone to connect" } + { "#comment" = "" } + { "#comment" = "To restrict monitoring of domains you may wish to enable" } + { "#comment" = "an authentication mechanism here" } + { "auth_unix_ro" = "none" } + { "#empty" } + { "#comment" = "Set an authentication scheme for UNIX read-write sockets" } + { "#comment" = "By default socket permissions only allow root. If PolicyKit" } + { "#comment" = "support was compiled into libvirt, the default will be to" } + { "#comment" = "use 'polkit' auth." } + { "#comment" = "" } + { "#comment" = "If the unix_sock_rw_perms are changed you may wish to enable" } + { "#comment" = "an authentication mechanism here" } + { "auth_unix_rw" = "none" } + { "#empty" } + { "#comment" = "Change the authentication scheme for TCP sockets." } + { "#comment" = "" } + { "#comment" = "If you don't enable SASL, then all TCP traffic is cleartext." } + { "#comment" = "Don't do this outside of a dev/test scenario. For real world" } + { "#comment" = "use, always enable SASL and use the GSSAPI or DIGEST-MD5" } + { "#comment" = "mechanism in /etc/sasl2/libvirt.conf" } + { "auth_tcp" = "sasl" } + { "#empty" } + { "#comment" = "Change the authentication scheme for TLS sockets." } + { "#comment" = "" } + { "#comment" = "TLS sockets already have encryption provided by the TLS" } + { "#comment" = "layer, and limited authentication is done by certificates" } + { "#comment" = "" } + { "#comment" = "It is possible to make use of any SASL authentication" } + { "#comment" = "mechanism as well, by using 'sasl' for this option" } + { "auth_tls" = "none" } + { "#empty" } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################" } + { "#comment" = "" } + { "#comment" = "TLS x509 certificate configuration" } + { "#comment" = "" } + { "#empty" } + { "#empty" } + { "#comment" = "Override the default server key file path" } + { "#comment" = "" } + { "key_file" = "/etc/pki/libvirt/private/serverkey.pem" } + { "#empty" } + { "#comment" = "Override the default server certificate file path" } + { "#comment" = "" } + { "cert_file" = "/etc/pki/libvirt/servercert.pem" } + { "#empty" } + { "#comment" = "Override the default CA certificate path" } + { "#comment" = "" } + { "ca_file" = "/etc/pki/CA/cacert.pem" } + { "#empty" } + { "#comment" = "Specify a certificate revocation list." } + { "#comment" = "" } + { "#comment" = "Defaults to not using a CRL, uncomment to enable it" } + { "crl_file" = "/etc/pki/CA/crl.pem" } + { "#empty" } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################" } + { "#comment" = "" } + { "#comment" = "Authorization controls" } + { "#comment" = "" } + { "#empty" } + { "#empty" } + { "#comment" = "Flag to disable verification of client certificates" } + { "#comment" = "" } + { "#comment" = "Client certificate verification is the primary authentication mechanism." } + { "#comment" = "Any client which does not present a certificate signed by the CA" } + { "#comment" = "will be rejected." } + { "#comment" = "" } + { "#comment" = "Default is to always verify. Uncommenting this will disable" } + { "#comment" = "verification - make sure an IP whitelist is set" } + { "tls_no_verify_certificate" = "1" } + { "#empty" } + { "#empty" } + { "#comment" = "A whitelist of allowed x509 Distinguished Names" } + { "#comment" = "This list may contain wildcards such as" } + { "#comment" = "" } + { "#comment" = "\"C=GB,ST=London,L=London,O=Red Hat,CN=*\"" } + { "#comment" = "" } + { "#comment" = "See the POSIX fnmatch function for the format of the wildcards." } + { "#comment" = "" } + { "#comment" = "NB If this is an empty list, no client can connect, so comment out" } + { "#comment" = "entirely rather than using empty list to disable these checks" } + { "#comment" = "" } + { "#comment" = "By default, no DN's are checked" } + { "tls_allowed_dn_list" + { "1" = "DN1"} + { "2" = "DN2"} + } + { "#empty" } + { "#empty" } + { "#comment" = "A whitelist of allowed SASL usernames. The format for usernames" } + { "#comment" = "depends on the SASL authentication mechanism. Kerberos usernames" } + { "#comment" = "look like username@REALM" } + { "#comment" = "" } + { "#comment" = "This list may contain wildcards such as" } + { "#comment" = "" } + { "#comment" = "\"*@EXAMPLE.COM\"" } + { "#comment" = "" } + { "#comment" = "See the POSIX fnmatch function for the format of the wildcards." } + { "#comment" = "" } + { "#comment" = "NB If this is an empty list, no client can connect, so comment out" } + { "#comment" = "entirely rather than using empty list to disable these checks" } + { "#comment" = "" } + { "#comment" = "By default, no Username's are checked" } + { "sasl_allowed_username_list" + { "1" = "joe@EXAMPLE.COM" } + { "2" = "fred@EXAMPLE.COM" } + } + { "#empty" } + { "#empty" } + { "#comment" = "################################################################"} + { "#comment" = ""} + { "#comment" = "Processing controls"} + { "#comment" = ""} + { "#empty" } + { "#comment" = "The maximum number of concurrent client connections to allow"} + { "#comment" = "over all sockets combined."} + { "max_clients" = "20" } + { "#empty" } + { "#empty" } + { "#comment" = "The minimum limit sets the number of workers to start up"} + { "#comment" = "initially. If the number of active clients exceeds this,"} + { "#comment" = "then more threads are spawned, upto max_workers limit."} + { "#comment" = "Typically you'd want max_workers to equal maximum number"} + { "#comment" = "of clients allowed"} + { "min_workers" = "5" } + { "max_workers" = "20" } + { "#empty" } + { "#comment" = "Total global limit on concurrent RPC calls. Should be" } + { "#comment" = "at least as large as max_workers. Beyond this, RPC requests" } + { "#comment" = "will be read into memory and queued. This directly impact" } + { "#comment" = "memory usage, currently each request requires 256 KB of" } + { "#comment" = "memory. So by default upto 5 MB of memory is used" } + { "max_requests" = "20" } + { "#empty" } + { "#comment" = "Limit on concurrent requests from a single client" } + { "#comment" = "connection. To avoid one client monopolizing the server" } + { "#comment" = "this should be a small fraction of the global max_requests" } + { "#comment" = "and max_workers parameter" } + { "max_client_requests" = "5" } + { "#empty" } + { "#comment" = "Logging level:" } + { "log_level" = "4" } + { "#empty" } + { "#comment" = "Logging outputs:" } + { "log_outputs" = "4:stderr" } + { "#empty" } + { "#comment" = "Logging filters:" } + { "log_filters" = "a" } diff --git a/daemon/test_libvirtd_qemu.aug b/daemon/test_libvirtd_qemu.aug new file mode 100644 index 0000000000..ac89438651 --- /dev/null +++ b/daemon/test_libvirtd_qemu.aug @@ -0,0 +1,198 @@ +module Test_libvirtd_qemu = + + let conf = "# Master configuration file for the QEMU driver. +# All settings described here are optional - if omitted, sensible +# defaults are used. + +# VNC is configured to listen on 127.0.0.1 by default. +# To make it listen on all public interfaces, uncomment +# this next option. +# +# NB, strong recommendation to enable TLS + x509 certificate +# verification when allowing public access +# +vnc_listen = \"0.0.0.0\" + + +# Enable use of TLS encryption on the VNC server. This requires +# a VNC client which supports the VeNCrypt protocol extension. +# Examples include vinagre, virt-viewer, virt-manager and vencrypt +# itself. UltraVNC, RealVNC, TightVNC do not support this +# +# It is necessary to setup CA and issue a server certificate +# before enabling this. +# +vnc_tls = 1 + + +# Use of TLS requires that x509 certificates be issued. The +# default it to keep them in /etc/pki/libvirt-vnc. This directory +# must contain +# +# ca-cert.pem - the CA master certificate +# server-cert.pem - the server certificate signed with ca-cert.pem +# server-key.pem - the server private key +# +# This option allows the certificate directory to be changed +# +vnc_tls_x509_cert_dir = \"/etc/pki/libvirt-vnc\" + + +# The default TLS configuration only uses certificates for the server +# allowing the client to verify the server's identity and establish +# and encrypted channel. +# +# It is possible to use x509 certificates for authentication too, by +# issuing a x509 certificate to every client who needs to connect. +# +# Enabling this option will reject any client who does not have a +# certificate signed by the CA in /etc/pki/libvirt-vnc/ca-cert.pem +# +vnc_tls_x509_verify = 1 + + +# The default VNC password. Only 8 letters are significant for +# VNC passwords. This parameter is only used if the per-domain +# XML config does not already provide a password. To allow +# access without passwords, leave this commented out. An empty +# string will still enable passwords, but be rejected by QEMU +# effectively preventing any use of VNC. Obviously change this +# example here before you set this +# +vnc_password = \"XYZ12345\" + + +# Enable use of SASL encryption on the VNC server. This requires +# a VNC client which supports the SASL protocol extension. +# Examples include vinagre, virt-viewer and virt-manager +# itself. UltraVNC, RealVNC, TightVNC do not support this +# +# It is necessary to configure /etc/sasl2/qemu.conf to choose +# the desired SASL plugin (eg, GSSPI for Kerberos) +# +vnc_sasl = 1 + + +# The default SASL configuration file is located in /etc/sasl2/ +# When running libvirtd unprivileged, it may be desirable to +# override the configs in this location. Set this parameter to +# point to the directory, and create a qemu.conf in that location +# +vnc_sasl_dir = \"/some/directory/sasl2\" + +security_driver = \"selinux\" + +user = \"root\" + +group = \"root\" + +cgroup_controllers = [ \"cpu\", \"devices\" ] + +cgroup_device_acl = [ \"/dev/null\", \"/dev/full\", \"/dev/zero\" ] + +save_image_format = \"gzip\" + +hugetlbfs_mount = \"/dev/hugepages\" +" + + test Libvirtd_qemu.lns get conf = +{ "#comment" = "Master configuration file for the QEMU driver." } +{ "#comment" = "All settings described here are optional - if omitted, sensible" } +{ "#comment" = "defaults are used." } +{ "#empty" } +{ "#comment" = "VNC is configured to listen on 127.0.0.1 by default." } +{ "#comment" = "To make it listen on all public interfaces, uncomment" } +{ "#comment" = "this next option." } +{ "#comment" = "" } +{ "#comment" = "NB, strong recommendation to enable TLS + x509 certificate" } +{ "#comment" = "verification when allowing public access" } +{ "#comment" = "" } +{ "vnc_listen" = "0.0.0.0" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "Enable use of TLS encryption on the VNC server. This requires" } +{ "#comment" = "a VNC client which supports the VeNCrypt protocol extension." } +{ "#comment" = "Examples include vinagre, virt-viewer, virt-manager and vencrypt" } +{ "#comment" = "itself. UltraVNC, RealVNC, TightVNC do not support this" } +{ "#comment" = "" } +{ "#comment" = "It is necessary to setup CA and issue a server certificate" } +{ "#comment" = "before enabling this." } +{ "#comment" = "" } +{ "vnc_tls" = "1" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "Use of TLS requires that x509 certificates be issued. The" } +{ "#comment" = "default it to keep them in /etc/pki/libvirt-vnc. This directory" } +{ "#comment" = "must contain" } +{ "#comment" = "" } +{ "#comment" = "ca-cert.pem - the CA master certificate" } +{ "#comment" = "server-cert.pem - the server certificate signed with ca-cert.pem" } +{ "#comment" = "server-key.pem - the server private key" } +{ "#comment" = "" } +{ "#comment" = "This option allows the certificate directory to be changed" } +{ "#comment" = "" } +{ "vnc_tls_x509_cert_dir" = "/etc/pki/libvirt-vnc" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "The default TLS configuration only uses certificates for the server" } +{ "#comment" = "allowing the client to verify the server's identity and establish" } +{ "#comment" = "and encrypted channel." } +{ "#comment" = "" } +{ "#comment" = "It is possible to use x509 certificates for authentication too, by" } +{ "#comment" = "issuing a x509 certificate to every client who needs to connect." } +{ "#comment" = "" } +{ "#comment" = "Enabling this option will reject any client who does not have a" } +{ "#comment" = "certificate signed by the CA in /etc/pki/libvirt-vnc/ca-cert.pem" } +{ "#comment" = "" } +{ "vnc_tls_x509_verify" = "1" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "The default VNC password. Only 8 letters are significant for" } +{ "#comment" = "VNC passwords. This parameter is only used if the per-domain" } +{ "#comment" = "XML config does not already provide a password. To allow" } +{ "#comment" = "access without passwords, leave this commented out. An empty" } +{ "#comment" = "string will still enable passwords, but be rejected by QEMU" } +{ "#comment" = "effectively preventing any use of VNC. Obviously change this" } +{ "#comment" = "example here before you set this" } +{ "#comment" = "" } +{ "vnc_password" = "XYZ12345" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "Enable use of SASL encryption on the VNC server. This requires" } +{ "#comment" = "a VNC client which supports the SASL protocol extension." } +{ "#comment" = "Examples include vinagre, virt-viewer and virt-manager" } +{ "#comment" = "itself. UltraVNC, RealVNC, TightVNC do not support this" } +{ "#comment" = "" } +{ "#comment" = "It is necessary to configure /etc/sasl2/qemu.conf to choose" } +{ "#comment" = "the desired SASL plugin (eg, GSSPI for Kerberos)" } +{ "#comment" = "" } +{ "vnc_sasl" = "1" } +{ "#empty" } +{ "#empty" } +{ "#comment" = "The default SASL configuration file is located in /etc/sasl2/" } +{ "#comment" = "When running libvirtd unprivileged, it may be desirable to" } +{ "#comment" = "override the configs in this location. Set this parameter to" } +{ "#comment" = "point to the directory, and create a qemu.conf in that location" } +{ "#comment" = "" } +{ "vnc_sasl_dir" = "/some/directory/sasl2" } +{ "#empty" } +{ "security_driver" = "selinux" } +{ "#empty" } +{ "user" = "root" } +{ "#empty" } +{ "group" = "root" } +{ "#empty" } +{ "cgroup_controllers" + { "1" = "cpu" } + { "2" = "devices" } +} +{ "#empty" } +{ "cgroup_device_acl" + { "1" = "/dev/null" } + { "2" = "/dev/full" } + { "3" = "/dev/zero" } +} +{ "#empty" } +{ "save_image_format" = "gzip" } +{ "#empty" } +{ "hugetlbfs_mount" = "/dev/hugepages" } \ No newline at end of file diff --git a/qemud/.gitignore b/qemud/.gitignore deleted file mode 100644 index 38cf28dcf6..0000000000 --- a/qemud/.gitignore +++ /dev/null @@ -1,12 +0,0 @@ -*.gcda -*.gcno -*.la -*.lo -.deps -.libs -Makefile -Makefile.in -libvirt_qemud -libvirtd -libvirtd.init -libvirtd.logrotate diff --git a/qemud/Makefile.am b/qemud/Makefile.am deleted file mode 100644 index 7ebd3caa09..0000000000 --- a/qemud/Makefile.am +++ /dev/null @@ -1,294 +0,0 @@ -## 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 '; 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,,\n $(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 diff --git a/qemud/THREADING.txt b/qemud/THREADING.txt deleted file mode 100644 index 4c7a616614..0000000000 --- a/qemud/THREADING.txt +++ /dev/null @@ -1,62 +0,0 @@ - - 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. diff --git a/qemud/default-network.xml b/qemud/default-network.xml deleted file mode 100644 index 9cfc01ed78..0000000000 --- a/qemud/default-network.xml +++ /dev/null @@ -1,10 +0,0 @@ - - default - - - - - - - - diff --git a/qemud/dispatch.c b/qemud/dispatch.c deleted file mode 100644 index a60f2f47d1..0000000000 --- a/qemud/dispatch.c +++ /dev/null @@ -1,534 +0,0 @@ -/* - * 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 - * Author: Daniel P. Berrange - */ - -#include - -#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; -} diff --git a/qemud/dispatch.h b/qemud/dispatch.h deleted file mode 100644 index 1d85df9a6b..0000000000 --- a/qemud/dispatch.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * 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 - * Author: Daniel P. Berrange - */ - -#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__ */ diff --git a/qemud/event.c b/qemud/event.c deleted file mode 100644 index 10847c4049..0000000000 --- a/qemud/event.c +++ /dev/null @@ -1,707 +0,0 @@ -/* - * 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 - */ - -#include - -#include -#include -#include -#include -#include -#include - -#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; -} diff --git a/qemud/event.h b/qemud/event.h deleted file mode 100644 index 0992f1cbc8..0000000000 --- a/qemud/event.h +++ /dev/null @@ -1,134 +0,0 @@ -/* - * 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 - */ - -#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__ */ diff --git a/qemud/libvirtd.aug b/qemud/libvirtd.aug deleted file mode 100644 index 7406d238f8..0000000000 --- a/qemud/libvirtd.aug +++ /dev/null @@ -1,82 +0,0 @@ -(* /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 diff --git a/qemud/libvirtd.conf b/qemud/libvirtd.conf deleted file mode 100644 index 49de466349..0000000000 --- a/qemud/libvirtd.conf +++ /dev/null @@ -1,314 +0,0 @@ -# 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 diff --git a/qemud/libvirtd.init.in b/qemud/libvirtd.init.in deleted file mode 100644 index 43c2d686a0..0000000000 --- a/qemud/libvirtd.init.in +++ /dev/null @@ -1,115 +0,0 @@ -#!/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 diff --git a/qemud/libvirtd.logrotate.in b/qemud/libvirtd.logrotate.in deleted file mode 100644 index 9b42630135..0000000000 --- a/qemud/libvirtd.logrotate.in +++ /dev/null @@ -1,8 +0,0 @@ -@localstatedir@/log/libvirt/qemu/*.log { - daily - missingok - rotate 7 - compress - delaycompress - copytruncate -} diff --git a/qemud/libvirtd.policy-0 b/qemud/libvirtd.policy-0 deleted file mode 100644 index b6da94615e..0000000000 --- a/qemud/libvirtd.policy-0 +++ /dev/null @@ -1,42 +0,0 @@ - - - - - - - Monitor local virtualized systems - System policy prevents monitoring of local virtualized systems - - - yes - yes - yes - - - - - Manage local virtualized systems - System policy prevents management of local virtualized systems - - - no - no - auth_admin_keep_session - - - diff --git a/qemud/libvirtd.policy-1 b/qemud/libvirtd.policy-1 deleted file mode 100644 index 6fa3a5e71e..0000000000 --- a/qemud/libvirtd.policy-1 +++ /dev/null @@ -1,42 +0,0 @@ - - - - - - - Monitor local virtualized systems - System policy prevents monitoring of local virtualized systems - - - yes - yes - yes - - - - - Manage local virtualized systems - System policy prevents management of local virtualized systems - - - no - no - auth_admin_keep - - - diff --git a/qemud/libvirtd.sasl b/qemud/libvirtd.sasl deleted file mode 100644 index e24a130853..0000000000 --- a/qemud/libvirtd.sasl +++ /dev/null @@ -1,28 +0,0 @@ -# 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 diff --git a/qemud/libvirtd.sysconf b/qemud/libvirtd.sysconf deleted file mode 100644 index fe4596a0c4..0000000000 --- a/qemud/libvirtd.sysconf +++ /dev/null @@ -1,9 +0,0 @@ -# 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 diff --git a/qemud/libvirtd_qemu.aug b/qemud/libvirtd_qemu.aug deleted file mode 100644 index f0b2a5e3c1..0000000000 --- a/qemud/libvirtd_qemu.aug +++ /dev/null @@ -1,52 +0,0 @@ -(* /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 diff --git a/qemud/mdns.c b/qemud/mdns.c deleted file mode 100644 index 73b7d11fc1..0000000000 --- a/qemud/mdns.c +++ /dev/null @@ -1,510 +0,0 @@ -/* - * 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 - */ - -#include - -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include - -#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; -} diff --git a/qemud/mdns.h b/qemud/mdns.h deleted file mode 100644 index cabcee4b57..0000000000 --- a/qemud/mdns.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * 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 - */ - -#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__ */ diff --git a/qemud/qemud.c b/qemud/qemud.c deleted file mode 100644 index 00b9859f4d..0000000000 --- a/qemud/qemud.c +++ /dev/null @@ -1,3015 +0,0 @@ -/* - * 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 - */ - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#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 -#include - -#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 Exit after timeout period.\n\ - -f | --config Configuration file.\n\ - | --version Display version information.\n\ - -p | --pid-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; -} diff --git a/qemud/qemud.h b/qemud/qemud.h deleted file mode 100644 index e8ce20988e..0000000000 --- a/qemud/qemud.h +++ /dev/null @@ -1,284 +0,0 @@ -/* - * 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 - */ - - -#ifndef QEMUD_INTERNAL_H__ -#define QEMUD_INTERNAL_H__ - -#include - -#include -#include -#include "gnutls_1_0_compat.h" -#if HAVE_SASL -#include -#endif - -#if HAVE_POLKIT0 -#include -#endif - -#ifdef HAVE_SYS_SYSLIMITS_H -#include -#endif - -#include -#include -#include "remote_protocol.h" -#include "logging.h" -#include "threads.h" - -#ifdef __GNUC__ -#ifdef HAVE_ANSIDECL_H -#include -#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 diff --git a/qemud/remote.c b/qemud/remote.c deleted file mode 100644 index 17426cd084..0000000000 --- a/qemud/remote.c +++ /dev/null @@ -1,4905 +0,0 @@ -/* - * 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 - */ - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "virterror_internal.h" - -#if HAVE_POLKIT0 -#include -#include -#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); -} diff --git a/qemud/remote.h b/qemud/remote.h deleted file mode 100644 index e3ee6964cc..0000000000 --- a/qemud/remote.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * 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 - * Author: Daniel P. Berrange - */ - -#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__ */ diff --git a/qemud/remote_dispatch_args.h b/qemud/remote_dispatch_args.h deleted file mode 100644 index 95f668ad00..0000000000 --- a/qemud/remote_dispatch_args.h +++ /dev/null @@ -1,127 +0,0 @@ -/* 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; diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h deleted file mode 100644 index 0605542015..0000000000 --- a/qemud/remote_dispatch_prototypes.h +++ /dev/null @@ -1,1026 +0,0 @@ -/* 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); diff --git a/qemud/remote_dispatch_ret.h b/qemud/remote_dispatch_ret.h deleted file mode 100644 index 6ced13a2e8..0000000000 --- a/qemud/remote_dispatch_ret.h +++ /dev/null @@ -1,108 +0,0 @@ -/* 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; diff --git a/qemud/remote_dispatch_table.h b/qemud/remote_dispatch_table.h deleted file mode 100644 index 6b5df80657..0000000000 --- a/qemud/remote_dispatch_table.h +++ /dev/null @@ -1,744 +0,0 @@ -/* 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, -}, diff --git a/qemud/remote_generate_stubs.pl b/qemud/remote_generate_stubs.pl deleted file mode 100755 index 9bca0ccfd5..0000000000 --- a/qemud/remote_generate_stubs.pl +++ /dev/null @@ -1,178 +0,0 @@ -#!/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 - -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"; - } - } -} diff --git a/qemud/remote_protocol.c b/qemud/remote_protocol.c deleted file mode 100644 index 1d2d242148..0000000000 --- a/qemud/remote_protocol.c +++ /dev/null @@ -1,2744 +0,0 @@ -#include -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "remote_protocol.h" -#include "internal.h" -#include - -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; -} diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h deleted file mode 100644 index ceaf82c907..0000000000 --- a/qemud/remote_protocol.h +++ /dev/null @@ -1,2223 +0,0 @@ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _RP_H_RPCGEN -#define _RP_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#include "internal.h" -#include -#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 */ diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x deleted file mode 100644 index 29abdb7df8..0000000000 --- a/qemud/remote_protocol.x +++ /dev/null @@ -1,1596 +0,0 @@ -/* -*- 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 - */ - -/* 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 - -/*----- 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; - -/* 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 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 (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; -}; - -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; -}; - -struct remote_domain_set_scheduler_parameters_args { - remote_nonnull_domain dom; - remote_sched_param params; -}; - -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; -}; - -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; -}; - -struct remote_list_domains_args { - int maxids; -}; - -struct remote_list_domains_ret { - int ids; -}; - -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_string uri_out; -}; - -struct remote_domain_migrate_perform_args { - remote_nonnull_domain dom; - opaque cookie; - 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_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_string uri_out; -}; - -struct remote_domain_migrate_finish2_args { - remote_nonnull_string dname; - opaque cookie; - 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; -}; - -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; -}; - -struct remote_domain_get_vcpus_args { - remote_nonnull_domain dom; - int maxinfo; - int maplen; -}; - -struct remote_domain_get_vcpus_ret { - remote_vcpu_info info; - opaque cpumaps; -}; - -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; - int enforcing; -}; - -struct remote_node_get_security_model_ret { - char model; - char doi; -}; - -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; -}; - -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; -}; - -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; -}; - -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; -}; - -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; -}; - -struct remote_auth_sasl_init_ret { - remote_nonnull_string mechlist; -}; - -struct remote_auth_sasl_start_args { - remote_nonnull_string mech; - int nil; - char data; -}; - -struct remote_auth_sasl_start_ret { - int complete; - int nil; - char data; -}; - -struct remote_auth_sasl_step_args { - int nil; - char data; -}; - -struct remote_auth_sasl_step_ret { - int complete; - int nil; - char data; -}; - -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; -}; - -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; -}; - -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; -}; - - - -/* 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; -}; - -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; -}; - -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; -}; - -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; - unsigned flags; -}; - -struct remote_secret_get_value_args { - remote_nonnull_secret secret; - unsigned flags; -}; - -struct remote_secret_get_value_ret { - opaque value; -}; - -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; -}; diff --git a/qemud/rpcgen_fix.pl b/qemud/rpcgen_fix.pl deleted file mode 100644 index 4943765f6d..0000000000 --- a/qemud/rpcgen_fix.pl +++ /dev/null @@ -1,91 +0,0 @@ -# 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 - -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, $_; - } -} diff --git a/qemud/test_libvirtd.aug b/qemud/test_libvirtd.aug deleted file mode 100644 index b8da28e012..0000000000 --- a/qemud/test_libvirtd.aug +++ /dev/null @@ -1,545 +0,0 @@ -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" } diff --git a/qemud/test_libvirtd_qemu.aug b/qemud/test_libvirtd_qemu.aug deleted file mode 100644 index ac89438651..0000000000 --- a/qemud/test_libvirtd_qemu.aug +++ /dev/null @@ -1,198 +0,0 @@ -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 diff --git a/src/Makefile.am b/src/Makefile.am index 463252e320..b1d01ba42f 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -4,7 +4,7 @@ INCLUDES = \ -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) \ @@ -100,8 +100,8 @@ SECRET_CONF_SOURCES = \ 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 = \ diff --git a/src/remote_internal.c b/src/remote_internal.c index dd7b31e8aa..3ffda35c94 100644 --- a/src/remote_internal.c +++ b/src/remote_internal.c @@ -5650,7 +5650,7 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv, int in_open, #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) { diff --git a/tests/Makefile.am b/tests/Makefile.am index 74e98d113a..5b99c5dfde 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -147,7 +147,7 @@ TESTS += nodedevxml2xmltest 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 @@ -261,7 +261,7 @@ qparamtest_LDADD = $(LDADDS) 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 diff --git a/tests/daemon-conf b/tests/daemon-conf index 4fa82a42ec..071497e1e4 100755 --- a/tests/daemon-conf +++ b/tests/daemon-conf @@ -13,7 +13,7 @@ test -z "$abs_top_srcdir" && abs_top_srcdir=$(pwd)/.. 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_]+ = ' \ diff --git a/tests/eventtest.c b/tests/eventtest.c index da34388285..90c60bb9ad 100644 --- a/tests/eventtest.c +++ b/tests/eventtest.c @@ -31,7 +31,7 @@ #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