[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[Libvir] [PATCH] Remote 4/8: Server-side call dispatch



4 Server-side call dispatch
---------------------------

A qemud/remote.c
A qemud/remote_generate_stubs.pl
A qemud/remote_dispatch_localvars.h
A qemud/remote_dispatch_proc_switch.h
A qemud/remote_dispatch_prototypes.h

As with the client side, the server side dispatch consists mainly of a long and rather tedious list of calls which deal with deserialising the args, calling the appropriate function, and serialising the result back to the client.

In remote.c we enter from the QEMU daemon at remoteDispatchClientRequest with a full request which has been read in but not decoded yet. This function deserialises the request header (remote_message_header defined in remote_protocol.x) and dispatches the request to the correct remoteDispatch* function. This function is arranged so that the remoteDispatch* functions need to do as little as possible -- in particular error handling is handled transparently as far as they are concerned. The function then serialises the reply (or error) and returns it up to the QEMU daemon to be sent out.

You may notice in remoteDispatchClientRequest that parts are generated automatically, eg. the dispatch switch statement:

    switch (req.proc) {
#include "remote_dispatch_proc_switch.h"

    default:
        remoteDispatchError (client, &req, "unknown procedure: %d",
                             req.proc);
        xdr_destroy (&xdr);
        return;
    }

This is to remove the need to write this tedious and error-prone code by hand.

Each remoteDispatch* function can be as small as possible and deals only with deserialising the remote_foo_args (parameters), calling the appropriate libvirt function, then serialising the remote_foo_ret (return value). Error cases are handled entirely by remoteDispatchClientRequest in order to remove duplicated code.

The remoteDispatch* functions may return one of the following values:

 0 = OK

-1 = The libvirt function returned an error (remoteDispatchClientRequest will pick up and serialise the error)

-2 = There was an error in the dispatch function itself, something to do with the mechanics of RPC. In this case the function has already set up an error buffer using remoteDispatchError directly.

The four other attached files are the script used to generate the automatically generated code for remoteDispatchClientRequest, and the 3 files of generated code that it creates, which I suggest we put in EXTRA_DIST.

Rich.

--
Emerging Technologies, Red Hat  http://et.redhat.com/~rjones/
64 Baker Street, London, W1U 7DF     Mobile: +44 7866 314 421

Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod
Street, Windsor, Berkshire, SL4 1TE, United Kingdom.
Registered in England and Wales under Company Registration No. 3798903
Directors: Michael Cunningham (USA), Charlie Peters (USA) and David
Owens (Ireland)
/*
 * remote.c: code handling remote requests (from remote_internal.c)
 *
 * 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: Richard W.M. Jones <rjones redhat com>
 */

#include <config.h>

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <paths.h>
#include <limits.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/poll.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <pwd.h>
#include <stdio.h>
#include <stdarg.h>
#include <syslog.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <ctype.h>
#include <assert.h>

#include <libvirt/virterror.h>

#include "internal.h"
#include "../src/internal.h"
#include "dispatch.h"
#include "driver.h"
#include "conf.h"
#include "iptables.h"

#define DEBUG 0

static void remoteDispatchError (struct qemud_client *client,
                                 remote_message_header *req,
                                 const char *fmt, ...);
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
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);

#include "remote_dispatch_prototypes.h"

typedef int (*dispatch_fn) (struct qemud_client *client, remote_message_header *req, char *args, char *ret);

/* This function gets called from qemud when it detects an incoming
 * remote protocol message.  At this point, client->buffer contains
 * the full call message (including length word which we skip).
 */
void
remoteDispatchClientRequest (struct qemud_server *server ATTRIBUTE_UNUSED,
                             struct qemud_client *client)
{
    XDR xdr;
    remote_message_header req, rep;
    dispatch_fn fn;
    xdrproc_t args_filter = (xdrproc_t) xdr_void;
    xdrproc_t ret_filter = (xdrproc_t) xdr_void;
    char *args = NULL, *ret = NULL;
    int rv, len;

#include "remote_dispatch_localvars.h"

    /* Parse the header. */
    xdrmem_create (&xdr, client->buffer+4, client->bufferLength-4, XDR_DECODE);

    if (!xdr_remote_message_header (&xdr, &req)) {
        remoteDispatchError (client, NULL, "xdr_remote_message_header");
        xdr_destroy (&xdr);
        return;
    }

    /* Check version, etc. */
    if (req.prog != REMOTE_PROGRAM) {
        remoteDispatchError (client, &req, "program mismatch (actual %x, expected %x)",
                             req.prog, REMOTE_PROGRAM);
        xdr_destroy (&xdr);
        return;
    }
    if (req.vers != REMOTE_PROTOCOL_VERSION) {
        remoteDispatchError (client, &req, "version mismatch (actual %x, expected %x)",
                             req.vers, REMOTE_PROTOCOL_VERSION);
        xdr_destroy (&xdr);
        return;
    }
    if (req.direction != REMOTE_CALL) {
        remoteDispatchError (client, &req, "direction (%d) != REMOTE_CALL",
                             (int) req.direction);
        xdr_destroy (&xdr);
        return;
    }
    if (req.status != REMOTE_OK) {
        remoteDispatchError (client, &req, "status (%d) != REMOTE_OK",
                             (int) req.status);
        xdr_destroy (&xdr);
        return;
    }

    /* Based on the procedure number, dispatch.  In future we may base
     * this on the version number as well.
     */
    switch (req.proc) {
#include "remote_dispatch_proc_switch.h"

    default:
        remoteDispatchError (client, &req, "unknown procedure: %d",
                             req.proc);
        xdr_destroy (&xdr);
        return;
    }

    /* Parse args. */
    if (!(*args_filter) (&xdr, args)) {
        remoteDispatchError (client, &req, "parse args failed");
        xdr_destroy (&xdr);
        return;
    }

    xdr_destroy (&xdr);

    /* Call function. */
    rv = fn (client, &req, args, ret);
    xdr_free (args_filter, args);

    /* Dispatch function must return -2, -1 or 0.  Anything else is
     * an internal error.
     */
    if (rv < -2 || rv > 0) {
        remoteDispatchError (client, &req, "internal error - dispatch function returned invalid code %d", rv);
        return;
    }

    /* Dispatch error?  If so then the function has already set up the
     * return buffer, so just return immediately.
     */
    if (rv == -2) return;

    /* Return header. */
    rep.prog = req.prog;
    rep.vers = req.vers;
    rep.proc = req.proc;
    rep.direction = REMOTE_REPLY;
    rep.serial = req.serial;
    rep.status = rv == 0 ? REMOTE_OK : REMOTE_ERROR;

    /* Serialise the return header. */
    xdrmem_create (&xdr, client->buffer, sizeof client->buffer, XDR_ENCODE);

    len = 0; /* We'll come back and write this later. */
    if (!xdr_int (&xdr, &len)) {
        remoteDispatchError (client, &req, "dummy length");
        xdr_destroy (&xdr);
        if (rv == 0) xdr_free (ret_filter, ret);
        return;
    }

    if (!xdr_remote_message_header (&xdr, &rep)) {
        remoteDispatchError (client, &req, "serialise reply header");
        xdr_destroy (&xdr);
        if (rv == 0) xdr_free (ret_filter, ret);
        return;
    }

    /* If OK, serialise return structure, if error serialise error. */
    if (rv == 0) {
        if (!(*ret_filter) (&xdr, ret)) {
            remoteDispatchError (client, &req, "serialise return struct");
            xdr_destroy (&xdr);
            return;
        }
        xdr_free (ret_filter, ret);
    } else /* error */ {
        virErrorPtr verr;
        remote_error error;
        remote_nonnull_domain dom;
        remote_nonnull_network net;

        verr = client->conn
            ? virConnGetLastError (client->conn)
            : virGetLastError ();

        if (verr) {
            error.code = verr->code;
            error.domain = verr->domain;
            error.message = verr->message ? &verr->message : NULL;
            error.level = verr->level;
            if (verr->dom) {
                dom.name = verr->dom->name;
                memcpy (dom.uuid, verr->dom->uuid, VIR_UUID_BUFLEN);
                dom.id = verr->dom->id;
            }
            error.dom = verr->dom ? &dom : NULL;
            error.str1 = verr->str1 ? &verr->str1 : NULL;
            error.str2 = verr->str2 ? &verr->str2 : NULL;
            error.str3 = verr->str3 ? &verr->str3 : NULL;
            error.int1 = verr->int1;
            error.int2 = verr->int2;
            if (verr->net) {
                net.name = verr->net->name;
                memcpy (net.uuid, verr->net->uuid, VIR_UUID_BUFLEN);
            }
            error.net = verr->net ? &net : NULL;
        } else {
            /* Error was NULL so synthesize an error. */
            char msgbuf[] = "remoteDispatchClientRequest: internal error: library function returned error but did not set virterror";
            char *msg = msgbuf;

            error.code = VIR_ERR_RPC;
            error.domain = VIR_FROM_REMOTE;
            error.message = &msg;
            error.level = VIR_ERR_ERROR;
            error.dom = NULL;
            error.str1 = &msg;
            error.str2 = NULL;
            error.str3 = NULL;
            error.int1 = 0;
            error.int2 = 0;
            error.net = NULL;
        }

        if (!xdr_remote_error (&xdr, &error)) {
            remoteDispatchError (client, &req, "serialise return error");
            xdr_destroy (&xdr);
            return;
        }
    }

    /* Write the length word. */
    len = xdr_getpos (&xdr);
    if (xdr_setpos (&xdr, 0) == 0) {
        remoteDispatchError (client, &req, "xdr_setpos");
        xdr_destroy (&xdr);
        return;
    }

    if (!xdr_int (&xdr, &len)) {
        remoteDispatchError (client, &req, "serialise return length");
        xdr_destroy (&xdr);
        return;
    }

    xdr_destroy (&xdr);

    /* Set up the output buffer. */
    client->mode = QEMUD_MODE_TX_PACKET;
    client->bufferLength = len;
    client->bufferOffset = 0;
    if (client->tls) client->direction = QEMUD_TLS_DIRECTION_WRITE;
}

/* An error occurred during the dispatching process itself (ie. not
 * an error from the function being called).  We return an error
 * reply.
 */
static void
remoteDispatchError (struct qemud_client *client,
                     remote_message_header *req,
                     const char *fmt, ...)
{
    remote_message_header rep;
    remote_error error;
    va_list args;
    char msgbuf[1024];
    char *msg = msgbuf;
    XDR xdr;
    int len;

    va_start (args, fmt);
    vsnprintf (msgbuf, sizeof msgbuf, fmt, args);
    va_end (args);

    qemudDebug ("%s", msgbuf);

    /* Future versions of the protocol may use different vers or prog.  Try
     * our hardest to send back a message that such clients could see.
     */
    if (req) {
        rep.prog = req->prog;
        rep.vers = req->vers;
        rep.proc = req->proc;
        rep.direction = REMOTE_REPLY;
        rep.serial = req->serial;
        rep.status = REMOTE_ERROR;
    } else {
        rep.prog = REMOTE_PROGRAM;
        rep.vers = REMOTE_PROTOCOL_VERSION;
        rep.proc = REMOTE_PROC_OPEN;
        rep.direction = REMOTE_REPLY;
        rep.serial = 1;
        rep.status = REMOTE_ERROR;
    }

    /* Construct the error. */
    error.code = VIR_ERR_RPC;
    error.domain = VIR_FROM_REMOTE;
    error.message = &msg;
    error.level = VIR_ERR_ERROR;
    error.dom = NULL;
    error.str1 = &msg;
    error.str2 = NULL;
    error.str3 = NULL;
    error.int1 = 0;
    error.int2 = 0;
    error.net = NULL;

    /* Serialise the return header and error. */
    xdrmem_create (&xdr, client->buffer, sizeof client->buffer, XDR_ENCODE);

    len = 0; /* We'll come back and write this later. */
    if (!xdr_int (&xdr, &len)) {
        xdr_destroy (&xdr);
        return;
    }

    if (!xdr_remote_message_header (&xdr, &rep)) {
        xdr_destroy (&xdr);
        return;
    }

    if (!xdr_remote_error (&xdr, &error)) {
        xdr_destroy (&xdr);
        return;
    }

    len = xdr_getpos (&xdr);
    if (xdr_setpos (&xdr, 0) == 0) {
        xdr_destroy (&xdr);
        return;
    }

    if (!xdr_int (&xdr, &len)) {
        xdr_destroy (&xdr);
        return;
    }

    xdr_destroy (&xdr);

    /* Send it. */
    client->mode = QEMUD_MODE_TX_PACKET;
    client->bufferLength = len;
    client->bufferOffset = 0;
    if (client->tls) client->direction = QEMUD_TLS_DIRECTION_WRITE;
}

/*----- Functions. -----*/

static int
remoteDispatchOpen (struct qemud_client *client, remote_message_header *req,
                    struct remote_open_args *args, void *ret ATTRIBUTE_UNUSED)
{
    const char *name;
    int flags;

    /* Already opened? */
    if (client->conn) {
        remoteDispatchError (client, req, "connection already open");
        return -2;
    }

    name = args->name ? *args->name : NULL;

#if DEBUG
    fprintf (stderr, "remoteDispatchOpen: name = %s\n", name);
#endif

    /* 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);

    return client->conn ? 0 : -1;
}

#define CHECK_CONN                              \
    if (!client->conn) {                        \
        remoteDispatchError (client, req, "connection not open");   \
        return -2;                                                  \
    }

static int
remoteDispatchClose (struct qemud_client *client, remote_message_header *req,
                     void *args ATTRIBUTE_UNUSED, void *ret ATTRIBUTE_UNUSED)
{
    int rv;
    CHECK_CONN;

    rv = virConnectClose (client->conn);
    if (rv == 0) client->conn = NULL;

    return rv;
}

static int
remoteDispatchGetType (struct qemud_client *client, remote_message_header *req,
                       void *args ATTRIBUTE_UNUSED, remote_get_type_ret *ret)
{
    const char *type;
    CHECK_CONN;

    type = virConnectGetType (client->conn);
    if (type == NULL) return -1;

    /* We have to strdup because remoteDispatchClientRequest will
     * free this string after it's been serialised.
     */
    ret->type = strdup (type);
    if (!ret->type) {
        remoteDispatchError (client, req, "out of memory in strdup");
        return -2;
    }

    return 0;
}

static int
remoteDispatchGetVersion (struct qemud_client *client,
                          remote_message_header *req,
                          void *args ATTRIBUTE_UNUSED,
                          remote_get_version_ret *ret)
{
    unsigned long hvVer;
    CHECK_CONN;

    if (virConnectGetVersion (client->conn, &hvVer) == -1)
        return -1;

    ret->hv_ver = hvVer;
    return 0;
}

static int
remoteDispatchGetMaxVcpus (struct qemud_client *client,
                           remote_message_header *req,
                           remote_get_max_vcpus_args *args,
                           remote_get_max_vcpus_ret *ret)
{
    char *type;
    CHECK_CONN;

    type = args->type ? *args->type : NULL;
    ret->max_vcpus = virConnectGetMaxVcpus (client->conn, type);
    if (ret->max_vcpus == -1) return -1;

    return 0;
}

static int
remoteDispatchNodeGetInfo (struct qemud_client *client,
                           remote_message_header *req,
                           void *args ATTRIBUTE_UNUSED,
                           remote_node_get_info_ret *ret)
{
    virNodeInfo info;
    CHECK_CONN;

    if (virNodeGetInfo (client->conn, &info) == -1)
        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_client *client,
                               remote_message_header *req,
                               void *args ATTRIBUTE_UNUSED,
                               remote_get_capabilities_ret *ret)
{
    char *caps;
    CHECK_CONN;

    caps = virConnectGetCapabilities (client->conn);
    if (caps == NULL) return -1;

    ret->capabilities = caps;
    return 0;
}

static int
remoteDispatchDomainAttachDevice (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_attach_device_args *args,
                                  void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainAttachDevice (dom, args->xml) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainCreate (struct qemud_client *client,
                            remote_message_header *req,
                            remote_domain_create_args *args,
                            void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainCreate (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainCreateLinux (struct qemud_client *client,
                                 remote_message_header *req,
                                 remote_domain_create_linux_args *args,
                                 remote_domain_create_linux_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = virDomainCreateLinux (client->conn, args->xml_desc, args->flags);
    if (dom == NULL) return -1;

    make_nonnull_domain (&ret->dom, dom);

    return 0;
}

static int
remoteDispatchDomainDefineXml (struct qemud_client *client,
                               remote_message_header *req,
                               remote_domain_define_xml_args *args,
                               remote_domain_define_xml_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = virDomainDefineXML (client->conn, args->xml);
    if (dom == NULL) return -1;

    make_nonnull_domain (&ret->dom, dom);

    return 0;
}

static int
remoteDispatchDomainDestroy (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_destroy_args *args,
                             void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainDestroy (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainDetachDevice (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_detach_device_args *args,
                                  void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainDetachDevice (dom, args->xml) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainDumpXml (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_dump_xml_args *args,
                             remote_domain_dump_xml_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    /* remoteDispatchClientRequest will free this. */
    ret->xml = virDomainGetXMLDesc (dom, args->flags);
    if (!ret->xml) return -1;

    return 0;
}

static int
remoteDispatchDomainGetAutostart (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_get_autostart_args *args,
                                  remote_domain_get_autostart_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainGetAutostart (dom, &ret->autostart) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainGetInfo (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_get_info_args *args,
                             remote_domain_get_info_ret *ret)
{
    virDomainPtr dom;
    virDomainInfo info;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainGetInfo (dom, &info) == -1)
        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;

    return 0;
}

static int
remoteDispatchDomainGetMaxMemory (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_get_max_memory_args *args,
                                  remote_domain_get_max_memory_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    ret->memory = virDomainGetMaxMemory (dom);
    if (ret->memory == 0) return -1;

    return 0;
}

static int
remoteDispatchDomainGetMaxVcpus (struct qemud_client *client,
                                 remote_message_header *req,
                                 remote_domain_get_max_vcpus_args *args,
                                 remote_domain_get_max_vcpus_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    ret->num = virDomainGetMaxVcpus (dom);
    if (ret->num == -1) return -1;

    return 0;
}

static int
remoteDispatchDomainGetOsType (struct qemud_client *client,
                               remote_message_header *req,
                               remote_domain_get_os_type_args *args,
                               remote_domain_get_os_type_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    /* remoteDispatchClientRequest will free this */
    ret->type = virDomainGetOSType (dom);
    if (ret->type == NULL) return -1;

    return 0;
}

static int
remoteDispatchDomainGetVcpus (struct qemud_client *client,
                              remote_message_header *req,
                              remote_domain_get_vcpus_args *args,
                              remote_domain_get_vcpus_ret *ret)
{
    virDomainPtr dom;
    virVcpuInfoPtr info;
    unsigned char *cpumaps;
    int info_len, i;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (args->maxinfo > REMOTE_VCPUINFO_MAX) {
        remoteDispatchError (client, req, "maxinfo > REMOTE_VCPUINFO_MAX");
        return -2;
    }

    if (args->maplen > REMOTE_CPUMAPS_MAX) {
        remoteDispatchError (client, req, "maplen > REMOTE_CPUMAPS_MAX");
        return -2;
    }

    /* Allocate buffers to take the results. */
    info = calloc (args->maxinfo, sizeof (virVcpuInfo));
    cpumaps = calloc (args->maplen, sizeof (unsigned char));

    info_len = virDomainGetVcpus (dom,
                                  info, args->maxinfo,
                                  cpumaps, args->maplen);
    if (info_len == -1) return -1;

    /* Allocate the return buffer for info. */
    ret->info.info_len = info_len;
    ret->info.info_val = calloc (info_len, sizeof (remote_vcpu_info));

    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->maplen;
    ret->cpumaps.cpumaps_val = (char *) cpumaps;

    return 0;
}

static int
remoteDispatchListDefinedDomains (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_list_defined_domains_args *args,
                                  remote_list_defined_domains_ret *ret)
{
    CHECK_CONN;

    if (args->maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
        remoteDispatchError (client, req,
                             "maxnames > REMOTE_DOMAIN_NAME_LIST_MAX");
        return -2;
    }

    /* Allocate return buffer. */
    ret->names.names_val = calloc (args->maxnames, sizeof (char *));

    ret->names.names_len =
        virConnectListDefinedDomains (client->conn,
                                      ret->names.names_val, args->maxnames);
    if (ret->names.names_len == -1) return -1;

    return 0;
}

static int
remoteDispatchDomainLookupById (struct qemud_client *client,
                                remote_message_header *req,
                                remote_domain_lookup_by_id_args *args,
                                remote_domain_lookup_by_id_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = virDomainLookupByID (client->conn, args->id);
    if (dom == NULL) return -1;

    make_nonnull_domain (&ret->dom, dom);

    return 0;
}

static int
remoteDispatchDomainLookupByName (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_lookup_by_name_args *args,
                                  remote_domain_lookup_by_name_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = virDomainLookupByName (client->conn, args->name);
    if (dom == NULL) return -1;

    make_nonnull_domain (&ret->dom, dom);

    return 0;
}

static int
remoteDispatchDomainLookupByUuid (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_lookup_by_uuid_args *args,
                                  remote_domain_lookup_by_uuid_ret *ret)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = virDomainLookupByUUID (client->conn, (unsigned char *) args->uuid);
    if (dom == NULL) return -1;

    make_nonnull_domain (&ret->dom, dom);

    return 0;
}

static int
remoteDispatchNumOfDefinedDomains (struct qemud_client *client,
                                   remote_message_header *req,
                                   void *args ATTRIBUTE_UNUSED,
                                   remote_num_of_defined_domains_ret *ret)
{
    CHECK_CONN;

    ret->num = virConnectNumOfDefinedDomains (client->conn);
    if (ret->num == -1) return -1;

    return 0;
}

static int
remoteDispatchDomainPinVcpu (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_pin_vcpu_args *args,
                             void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    int rv;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (args->cpumap.cpumap_len > REMOTE_CPUMAP_MAX) {
        remoteDispatchError (client, req, "cpumap_len > REMOTE_CPUMAP_MAX");
        return -2;
    }

    rv = virDomainPinVcpu (dom, args->vcpu,
                           (unsigned char *) args->cpumap.cpumap_val,
                           args->cpumap.cpumap_len);
    if (rv == -1) return -1;

    return 0;
}

static int
remoteDispatchDomainReboot (struct qemud_client *client,
                            remote_message_header *req,
                            remote_domain_reboot_args *args,
                            void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainReboot (dom, args->flags) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainRestore (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_restore_args *args,
                             void *ret ATTRIBUTE_UNUSED)
{
    CHECK_CONN;

    if (virDomainRestore (client->conn, args->from) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainResume (struct qemud_client *client,
                            remote_message_header *req,
                            remote_domain_resume_args *args,
                            void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainResume (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSave (struct qemud_client *client,
                          remote_message_header *req,
                          remote_domain_save_args *args,
                          void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSave (dom, args->to) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainCoreDump (struct qemud_client *client,
                              remote_message_header *req,
                              remote_domain_core_dump_args *args,
                              void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainCoreDump (dom, args->to, args->flags) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSetAutostart (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_set_autostart_args *args,
                                  void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSetAutostart (dom, args->autostart) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSetMaxMemory (struct qemud_client *client,
                                  remote_message_header *req,
                                  remote_domain_set_max_memory_args *args,
                                  void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSetMaxMemory (dom, args->memory) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSetMemory (struct qemud_client *client,
                               remote_message_header *req,
                               remote_domain_set_memory_args *args,
                               void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSetMemory (dom, args->memory) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSetVcpus (struct qemud_client *client,
                              remote_message_header *req,
                              remote_domain_set_vcpus_args *args,
                              void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSetVcpus (dom, args->nvcpus) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainShutdown (struct qemud_client *client,
                              remote_message_header *req,
                              remote_domain_shutdown_args *args,
                              void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainShutdown (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainSuspend (struct qemud_client *client,
                             remote_message_header *req,
                             remote_domain_suspend_args *args,
                             void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainSuspend (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchDomainUndefine (struct qemud_client *client,
                              remote_message_header *req,
                              remote_domain_undefine_args *args,
                              void *ret ATTRIBUTE_UNUSED)
{
    virDomainPtr dom;
    CHECK_CONN;

    dom = get_nonnull_domain (client->conn, args->dom);
    if (dom == NULL) {
        remoteDispatchError (client, req, "domain not found");
        return -2;
    }

    if (virDomainUndefine (dom) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchListDefinedNetworks (struct qemud_client *client,
                                   remote_message_header *req,
                                   remote_list_defined_networks_args *args,
                                   remote_list_defined_networks_ret *ret)
{
    CHECK_CONN;

    if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
        remoteDispatchError (client, req,
                             "maxnames > REMOTE_NETWORK_NAME_LIST_MAX");
        return -2;
    }

    /* Allocate return buffer. */
    ret->names.names_val = calloc (args->maxnames, sizeof (char *));

    ret->names.names_len =
        virConnectListDefinedNetworks (client->conn,
                                       ret->names.names_val, args->maxnames);
    if (ret->names.names_len == -1) return -1;

    return 0;
}

static int
remoteDispatchListDomains (struct qemud_client *client,
                           remote_message_header *req,
                           remote_list_domains_args *args,
                           remote_list_domains_ret *ret)
{
    CHECK_CONN;

    if (args->maxids > REMOTE_DOMAIN_ID_LIST_MAX) {
        remoteDispatchError (client, req,
                             "maxids > REMOTE_DOMAIN_ID_LIST_MAX");
        return -2;
    }

    /* Allocate return buffer. */
    ret->ids.ids_val = calloc (args->maxids, sizeof (int));

    ret->ids.ids_len = virConnectListDomains (client->conn,
                                              ret->ids.ids_val, args->maxids);
    if (ret->ids.ids_len == -1) return -1;

    return 0;
}

static int
remoteDispatchListNetworks (struct qemud_client *client,
                            remote_message_header *req,
                            remote_list_networks_args *args,
                            remote_list_networks_ret *ret)
{
    CHECK_CONN;

    if (args->maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
        remoteDispatchError (client, req,
                             "maxnames > REMOTE_NETWORK_NAME_LIST_MAX");
        return -2;
    }

    /* Allocate return buffer. */
    ret->names.names_val = calloc (args->maxnames, sizeof (char *));

    ret->names.names_len =
        virConnectListNetworks (client->conn,
                                ret->names.names_val, args->maxnames);
    if (ret->names.names_len == -1) return -1;

    return 0;
}

static int
remoteDispatchNetworkCreate (struct qemud_client *client,
                             remote_message_header *req,
                             remote_network_create_args *args,
                             void *ret ATTRIBUTE_UNUSED)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    if (virNetworkCreate (net) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchNetworkCreateXml (struct qemud_client *client,
                                remote_message_header *req,
                                remote_network_create_xml_args *args,
                                remote_network_create_xml_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = virNetworkCreateXML (client->conn, args->xml);
    if (net == NULL) return -1;

    make_nonnull_network (&ret->net, net);

    return 0;
}

static int
remoteDispatchNetworkDefineXml (struct qemud_client *client,
                                remote_message_header *req,
                                remote_network_define_xml_args *args,
                                remote_network_define_xml_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = virNetworkDefineXML (client->conn, args->xml);
    if (net == NULL) return -1;

    make_nonnull_network (&ret->net, net);

    return 0;
}

static int
remoteDispatchNetworkDestroy (struct qemud_client *client,
                              remote_message_header *req,
                              remote_network_destroy_args *args,
                              void *ret ATTRIBUTE_UNUSED)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    if (virNetworkDestroy (net) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchNetworkDumpXml (struct qemud_client *client,
                              remote_message_header *req,
                              remote_network_dump_xml_args *args,
                              remote_network_dump_xml_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    /* remoteDispatchClientRequest will free this. */
    ret->xml = virNetworkGetXMLDesc (net, args->flags);
    if (!ret->xml) return -1;

    return 0;
}

static int
remoteDispatchNetworkGetAutostart (struct qemud_client *client,
                                   remote_message_header *req,
                                   remote_network_get_autostart_args *args,
                                   remote_network_get_autostart_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    if (virNetworkGetAutostart (net, &ret->autostart) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchNetworkGetBridgeName (struct qemud_client *client,
                                    remote_message_header *req,
                                    remote_network_get_bridge_name_args *args,
                                    remote_network_get_bridge_name_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    /* remoteDispatchClientRequest will free this. */
    ret->name = virNetworkGetBridgeName (net);
    if (!ret->name) return -1;

    return 0;
}

static int
remoteDispatchNetworkLookupByName (struct qemud_client *client,
                                   remote_message_header *req,
                                   remote_network_lookup_by_name_args *args,
                                   remote_network_lookup_by_name_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = virNetworkLookupByName (client->conn, args->name);
    if (net == NULL) return -1;

    make_nonnull_network (&ret->net, net);

    return 0;
}

static int
remoteDispatchNetworkLookupByUuid (struct qemud_client *client,
                                   remote_message_header *req,
                                   remote_network_lookup_by_uuid_args *args,
                                   remote_network_lookup_by_uuid_ret *ret)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = virNetworkLookupByUUID (client->conn, (unsigned char *) args->uuid);
    if (net == NULL) return -1;

    make_nonnull_network (&ret->net, net);

    return 0;
}

static int
remoteDispatchNetworkSetAutostart (struct qemud_client *client,
                                   remote_message_header *req,
                                   remote_network_set_autostart_args *args,
                                   void *ret ATTRIBUTE_UNUSED)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    if (virNetworkSetAutostart (net, args->autostart) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchNetworkUndefine (struct qemud_client *client,
                               remote_message_header *req,
                               remote_network_undefine_args *args,
                               void *ret ATTRIBUTE_UNUSED)
{
    virNetworkPtr net;
    CHECK_CONN;

    net = get_nonnull_network (client->conn, args->net);
    if (net == NULL) {
        remoteDispatchError (client, req, "network not found");
        return -2;
    }

    if (virNetworkUndefine (net) == -1)
        return -1;

    return 0;
}

static int
remoteDispatchNumOfDefinedNetworks (struct qemud_client *client,
                                    remote_message_header *req,
                                    void *args ATTRIBUTE_UNUSED,
                                    remote_num_of_defined_networks_ret *ret)
{
    CHECK_CONN;

    ret->num = virConnectNumOfDefinedNetworks (client->conn);
    if (ret->num == -1) return -1;

    return 0;
}

static int
remoteDispatchNumOfDomains (struct qemud_client *client,
                            remote_message_header *req,
                            void *args ATTRIBUTE_UNUSED,
                            remote_num_of_domains_ret *ret)
{
    CHECK_CONN;

    ret->num = virConnectNumOfDomains (client->conn);
    if (ret->num == -1) return -1;

    return 0;
}

static int
remoteDispatchNumOfNetworks (struct qemud_client *client,
                             remote_message_header *req,
                             void *args ATTRIBUTE_UNUSED,
                             remote_num_of_networks_ret *ret)
{
    CHECK_CONN;

    ret->num = virConnectNumOfNetworks (client->conn);
    if (ret->num == -1) return -1;

    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);
}

/* 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);
}

/*
 * Local variables:
 *  indent-tabs-mode: nil
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 4
 * End:
 */

Attachment: remote_generate_stubs.pl
Description: Perl program

/* Automatically generated by remote_generate_stubs.pl.
 * Do not edit this file.  Any changes you make will be lost.
 */

remote_network_lookup_by_name_args lv_remote_network_lookup_by_name_args;
remote_network_lookup_by_name_ret lv_remote_network_lookup_by_name_ret;
remote_domain_lookup_by_uuid_args lv_remote_domain_lookup_by_uuid_args;
remote_domain_lookup_by_uuid_ret lv_remote_domain_lookup_by_uuid_ret;
remote_num_of_defined_domains_ret lv_remote_num_of_defined_domains_ret;
remote_domain_detach_device_args lv_remote_domain_detach_device_args;
remote_domain_save_args lv_remote_domain_save_args;
remote_domain_shutdown_args lv_remote_domain_shutdown_args;
remote_list_defined_domains_args lv_remote_list_defined_domains_args;
remote_list_defined_domains_ret lv_remote_list_defined_domains_ret;
remote_get_capabilities_ret lv_remote_get_capabilities_ret;
remote_domain_set_max_memory_args lv_remote_domain_set_max_memory_args;
remote_domain_undefine_args lv_remote_domain_undefine_args;
remote_domain_get_os_type_args lv_remote_domain_get_os_type_args;
remote_domain_get_os_type_ret lv_remote_domain_get_os_type_ret;
remote_domain_get_autostart_args lv_remote_domain_get_autostart_args;
remote_domain_get_autostart_ret lv_remote_domain_get_autostart_ret;
remote_domain_set_vcpus_args lv_remote_domain_set_vcpus_args;
remote_network_undefine_args lv_remote_network_undefine_args;
remote_domain_create_args lv_remote_domain_create_args;
remote_domain_suspend_args lv_remote_domain_suspend_args;
remote_get_version_ret lv_remote_get_version_ret;
remote_network_destroy_args lv_remote_network_destroy_args;
remote_network_set_autostart_args lv_remote_network_set_autostart_args;
remote_network_get_autostart_args lv_remote_network_get_autostart_args;
remote_network_get_autostart_ret lv_remote_network_get_autostart_ret;
remote_domain_pin_vcpu_args lv_remote_domain_pin_vcpu_args;
remote_list_defined_networks_args lv_remote_list_defined_networks_args;
remote_list_defined_networks_ret lv_remote_list_defined_networks_ret;
remote_network_create_xml_args lv_remote_network_create_xml_args;
remote_network_create_xml_ret lv_remote_network_create_xml_ret;
remote_domain_core_dump_args lv_remote_domain_core_dump_args;
remote_open_args lv_remote_open_args;
remote_list_domains_args lv_remote_list_domains_args;
remote_list_domains_ret lv_remote_list_domains_ret;
remote_network_define_xml_args lv_remote_network_define_xml_args;
remote_network_define_xml_ret lv_remote_network_define_xml_ret;
remote_domain_get_max_memory_args lv_remote_domain_get_max_memory_args;
remote_domain_get_max_memory_ret lv_remote_domain_get_max_memory_ret;
remote_get_type_ret lv_remote_get_type_ret;
remote_num_of_domains_ret lv_remote_num_of_domains_ret;
remote_list_networks_args lv_remote_list_networks_args;
remote_list_networks_ret lv_remote_list_networks_ret;
remote_network_dump_xml_args lv_remote_network_dump_xml_args;
remote_network_dump_xml_ret lv_remote_network_dump_xml_ret;
remote_domain_set_autostart_args lv_remote_domain_set_autostart_args;
remote_domain_reboot_args lv_remote_domain_reboot_args;
remote_domain_set_memory_args lv_remote_domain_set_memory_args;
remote_domain_create_linux_args lv_remote_domain_create_linux_args;
remote_domain_create_linux_ret lv_remote_domain_create_linux_ret;
remote_domain_attach_device_args lv_remote_domain_attach_device_args;
remote_domain_lookup_by_id_args lv_remote_domain_lookup_by_id_args;
remote_domain_lookup_by_id_ret lv_remote_domain_lookup_by_id_ret;
remote_num_of_networks_ret lv_remote_num_of_networks_ret;
remote_domain_restore_args lv_remote_domain_restore_args;
remote_domain_get_max_vcpus_args lv_remote_domain_get_max_vcpus_args;
remote_domain_get_max_vcpus_ret lv_remote_domain_get_max_vcpus_ret;
remote_domain_get_info_args lv_remote_domain_get_info_args;
remote_domain_get_info_ret lv_remote_domain_get_info_ret;
remote_network_create_args lv_remote_network_create_args;
remote_num_of_defined_networks_ret lv_remote_num_of_defined_networks_ret;
remote_domain_lookup_by_name_args lv_remote_domain_lookup_by_name_args;
remote_domain_lookup_by_name_ret lv_remote_domain_lookup_by_name_ret;
remote_network_lookup_by_uuid_args lv_remote_network_lookup_by_uuid_args;
remote_network_lookup_by_uuid_ret lv_remote_network_lookup_by_uuid_ret;
remote_domain_resume_args lv_remote_domain_resume_args;
remote_network_get_bridge_name_args lv_remote_network_get_bridge_name_args;
remote_network_get_bridge_name_ret lv_remote_network_get_bridge_name_ret;
remote_domain_destroy_args lv_remote_domain_destroy_args;
remote_domain_define_xml_args lv_remote_domain_define_xml_args;
remote_domain_define_xml_ret lv_remote_domain_define_xml_ret;
remote_domain_get_vcpus_args lv_remote_domain_get_vcpus_args;
remote_domain_get_vcpus_ret lv_remote_domain_get_vcpus_ret;
remote_domain_dump_xml_args lv_remote_domain_dump_xml_args;
remote_domain_dump_xml_ret lv_remote_domain_dump_xml_ret;
remote_get_max_vcpus_args lv_remote_get_max_vcpus_args;
remote_get_max_vcpus_ret lv_remote_get_max_vcpus_ret;
remote_node_get_info_ret lv_remote_node_get_info_ret;
/* Automatically generated by remote_generate_stubs.pl.
 * Do not edit this file.  Any changes you make will be lost.
 */

case REMOTE_PROC_CLOSE:
	fn = (dispatch_fn) remoteDispatchClose;
	break;
case REMOTE_PROC_DOMAIN_ATTACH_DEVICE:
	fn = (dispatch_fn) remoteDispatchDomainAttachDevice;
	args_filter = (xdrproc_t) xdr_remote_domain_attach_device_args;
	args = (char *) &lv_remote_domain_attach_device_args;
	memset (&lv_remote_domain_attach_device_args, 0, sizeof lv_remote_domain_attach_device_args);
	break;
case REMOTE_PROC_DOMAIN_CORE_DUMP:
	fn = (dispatch_fn) remoteDispatchDomainCoreDump;
	args_filter = (xdrproc_t) xdr_remote_domain_core_dump_args;
	args = (char *) &lv_remote_domain_core_dump_args;
	memset (&lv_remote_domain_core_dump_args, 0, sizeof lv_remote_domain_core_dump_args);
	break;
case REMOTE_PROC_DOMAIN_CREATE:
	fn = (dispatch_fn) remoteDispatchDomainCreate;
	args_filter = (xdrproc_t) xdr_remote_domain_create_args;
	args = (char *) &lv_remote_domain_create_args;
	memset (&lv_remote_domain_create_args, 0, sizeof lv_remote_domain_create_args);
	break;
case REMOTE_PROC_DOMAIN_CREATE_LINUX:
	fn = (dispatch_fn) remoteDispatchDomainCreateLinux;
	args_filter = (xdrproc_t) xdr_remote_domain_create_linux_args;
	args = (char *) &lv_remote_domain_create_linux_args;
	memset (&lv_remote_domain_create_linux_args, 0, sizeof lv_remote_domain_create_linux_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_create_linux_ret;
	ret = (char *) &lv_remote_domain_create_linux_ret;
	memset (&lv_remote_domain_create_linux_ret, 0, sizeof lv_remote_domain_create_linux_ret);
	break;
case REMOTE_PROC_DOMAIN_DEFINE_XML:
	fn = (dispatch_fn) remoteDispatchDomainDefineXml;
	args_filter = (xdrproc_t) xdr_remote_domain_define_xml_args;
	args = (char *) &lv_remote_domain_define_xml_args;
	memset (&lv_remote_domain_define_xml_args, 0, sizeof lv_remote_domain_define_xml_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_define_xml_ret;
	ret = (char *) &lv_remote_domain_define_xml_ret;
	memset (&lv_remote_domain_define_xml_ret, 0, sizeof lv_remote_domain_define_xml_ret);
	break;
case REMOTE_PROC_DOMAIN_DESTROY:
	fn = (dispatch_fn) remoteDispatchDomainDestroy;
	args_filter = (xdrproc_t) xdr_remote_domain_destroy_args;
	args = (char *) &lv_remote_domain_destroy_args;
	memset (&lv_remote_domain_destroy_args, 0, sizeof lv_remote_domain_destroy_args);
	break;
case REMOTE_PROC_DOMAIN_DETACH_DEVICE:
	fn = (dispatch_fn) remoteDispatchDomainDetachDevice;
	args_filter = (xdrproc_t) xdr_remote_domain_detach_device_args;
	args = (char *) &lv_remote_domain_detach_device_args;
	memset (&lv_remote_domain_detach_device_args, 0, sizeof lv_remote_domain_detach_device_args);
	break;
case REMOTE_PROC_DOMAIN_DUMP_XML:
	fn = (dispatch_fn) remoteDispatchDomainDumpXml;
	args_filter = (xdrproc_t) xdr_remote_domain_dump_xml_args;
	args = (char *) &lv_remote_domain_dump_xml_args;
	memset (&lv_remote_domain_dump_xml_args, 0, sizeof lv_remote_domain_dump_xml_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_dump_xml_ret;
	ret = (char *) &lv_remote_domain_dump_xml_ret;
	memset (&lv_remote_domain_dump_xml_ret, 0, sizeof lv_remote_domain_dump_xml_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_AUTOSTART:
	fn = (dispatch_fn) remoteDispatchDomainGetAutostart;
	args_filter = (xdrproc_t) xdr_remote_domain_get_autostart_args;
	args = (char *) &lv_remote_domain_get_autostart_args;
	memset (&lv_remote_domain_get_autostart_args, 0, sizeof lv_remote_domain_get_autostart_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_autostart_ret;
	ret = (char *) &lv_remote_domain_get_autostart_ret;
	memset (&lv_remote_domain_get_autostart_ret, 0, sizeof lv_remote_domain_get_autostart_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_INFO:
	fn = (dispatch_fn) remoteDispatchDomainGetInfo;
	args_filter = (xdrproc_t) xdr_remote_domain_get_info_args;
	args = (char *) &lv_remote_domain_get_info_args;
	memset (&lv_remote_domain_get_info_args, 0, sizeof lv_remote_domain_get_info_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_info_ret;
	ret = (char *) &lv_remote_domain_get_info_ret;
	memset (&lv_remote_domain_get_info_ret, 0, sizeof lv_remote_domain_get_info_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_MAX_MEMORY:
	fn = (dispatch_fn) remoteDispatchDomainGetMaxMemory;
	args_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_args;
	args = (char *) &lv_remote_domain_get_max_memory_args;
	memset (&lv_remote_domain_get_max_memory_args, 0, sizeof lv_remote_domain_get_max_memory_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_max_memory_ret;
	ret = (char *) &lv_remote_domain_get_max_memory_ret;
	memset (&lv_remote_domain_get_max_memory_ret, 0, sizeof lv_remote_domain_get_max_memory_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_MAX_VCPUS:
	fn = (dispatch_fn) remoteDispatchDomainGetMaxVcpus;
	args_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_args;
	args = (char *) &lv_remote_domain_get_max_vcpus_args;
	memset (&lv_remote_domain_get_max_vcpus_args, 0, sizeof lv_remote_domain_get_max_vcpus_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret;
	ret = (char *) &lv_remote_domain_get_max_vcpus_ret;
	memset (&lv_remote_domain_get_max_vcpus_ret, 0, sizeof lv_remote_domain_get_max_vcpus_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_OS_TYPE:
	fn = (dispatch_fn) remoteDispatchDomainGetOsType;
	args_filter = (xdrproc_t) xdr_remote_domain_get_os_type_args;
	args = (char *) &lv_remote_domain_get_os_type_args;
	memset (&lv_remote_domain_get_os_type_args, 0, sizeof lv_remote_domain_get_os_type_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_os_type_ret;
	ret = (char *) &lv_remote_domain_get_os_type_ret;
	memset (&lv_remote_domain_get_os_type_ret, 0, sizeof lv_remote_domain_get_os_type_ret);
	break;
case REMOTE_PROC_DOMAIN_GET_VCPUS:
	fn = (dispatch_fn) remoteDispatchDomainGetVcpus;
	args_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_args;
	args = (char *) &lv_remote_domain_get_vcpus_args;
	memset (&lv_remote_domain_get_vcpus_args, 0, sizeof lv_remote_domain_get_vcpus_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_get_vcpus_ret;
	ret = (char *) &lv_remote_domain_get_vcpus_ret;
	memset (&lv_remote_domain_get_vcpus_ret, 0, sizeof lv_remote_domain_get_vcpus_ret);
	break;
case REMOTE_PROC_DOMAIN_LOOKUP_BY_ID:
	fn = (dispatch_fn) remoteDispatchDomainLookupById;
	args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_args;
	args = (char *) &lv_remote_domain_lookup_by_id_args;
	memset (&lv_remote_domain_lookup_by_id_args, 0, sizeof lv_remote_domain_lookup_by_id_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_id_ret;
	ret = (char *) &lv_remote_domain_lookup_by_id_ret;
	memset (&lv_remote_domain_lookup_by_id_ret, 0, sizeof lv_remote_domain_lookup_by_id_ret);
	break;
case REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME:
	fn = (dispatch_fn) remoteDispatchDomainLookupByName;
	args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_args;
	args = (char *) &lv_remote_domain_lookup_by_name_args;
	memset (&lv_remote_domain_lookup_by_name_args, 0, sizeof lv_remote_domain_lookup_by_name_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_name_ret;
	ret = (char *) &lv_remote_domain_lookup_by_name_ret;
	memset (&lv_remote_domain_lookup_by_name_ret, 0, sizeof lv_remote_domain_lookup_by_name_ret);
	break;
case REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID:
	fn = (dispatch_fn) remoteDispatchDomainLookupByUuid;
	args_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args;
	args = (char *) &lv_remote_domain_lookup_by_uuid_args;
	memset (&lv_remote_domain_lookup_by_uuid_args, 0, sizeof lv_remote_domain_lookup_by_uuid_args);
	ret_filter = (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret;
	ret = (char *) &lv_remote_domain_lookup_by_uuid_ret;
	memset (&lv_remote_domain_lookup_by_uuid_ret, 0, sizeof lv_remote_domain_lookup_by_uuid_ret);
	break;
case REMOTE_PROC_DOMAIN_PIN_VCPU:
	fn = (dispatch_fn) remoteDispatchDomainPinVcpu;
	args_filter = (xdrproc_t) xdr_remote_domain_pin_vcpu_args;
	args = (char *) &lv_remote_domain_pin_vcpu_args;
	memset (&lv_remote_domain_pin_vcpu_args, 0, sizeof lv_remote_domain_pin_vcpu_args);
	break;
case REMOTE_PROC_DOMAIN_REBOOT:
	fn = (dispatch_fn) remoteDispatchDomainReboot;
	args_filter = (xdrproc_t) xdr_remote_domain_reboot_args;
	args = (char *) &lv_remote_domain_reboot_args;
	memset (&lv_remote_domain_reboot_args, 0, sizeof lv_remote_domain_reboot_args);
	break;
case REMOTE_PROC_DOMAIN_RESTORE:
	fn = (dispatch_fn) remoteDispatchDomainRestore;
	args_filter = (xdrproc_t) xdr_remote_domain_restore_args;
	args = (char *) &lv_remote_domain_restore_args;
	memset (&lv_remote_domain_restore_args, 0, sizeof lv_remote_domain_restore_args);
	break;
case REMOTE_PROC_DOMAIN_RESUME:
	fn = (dispatch_fn) remoteDispatchDomainResume;
	args_filter = (xdrproc_t) xdr_remote_domain_resume_args;
	args = (char *) &lv_remote_domain_resume_args;
	memset (&lv_remote_domain_resume_args, 0, sizeof lv_remote_domain_resume_args);
	break;
case REMOTE_PROC_DOMAIN_SAVE:
	fn = (dispatch_fn) remoteDispatchDomainSave;
	args_filter = (xdrproc_t) xdr_remote_domain_save_args;
	args = (char *) &lv_remote_domain_save_args;
	memset (&lv_remote_domain_save_args, 0, sizeof lv_remote_domain_save_args);
	break;
case REMOTE_PROC_DOMAIN_SET_AUTOSTART:
	fn = (dispatch_fn) remoteDispatchDomainSetAutostart;
	args_filter = (xdrproc_t) xdr_remote_domain_set_autostart_args;
	args = (char *) &lv_remote_domain_set_autostart_args;
	memset (&lv_remote_domain_set_autostart_args, 0, sizeof lv_remote_domain_set_autostart_args);
	break;
case REMOTE_PROC_DOMAIN_SET_MAX_MEMORY:
	fn = (dispatch_fn) remoteDispatchDomainSetMaxMemory;
	args_filter = (xdrproc_t) xdr_remote_domain_set_max_memory_args;
	args = (char *) &lv_remote_domain_set_max_memory_args;
	memset (&lv_remote_domain_set_max_memory_args, 0, sizeof lv_remote_domain_set_max_memory_args);
	break;
case REMOTE_PROC_DOMAIN_SET_MEMORY:
	fn = (dispatch_fn) remoteDispatchDomainSetMemory;
	args_filter = (xdrproc_t) xdr_remote_domain_set_memory_args;
	args = (char *) &lv_remote_domain_set_memory_args;
	memset (&lv_remote_domain_set_memory_args, 0, sizeof lv_remote_domain_set_memory_args);
	break;
case REMOTE_PROC_DOMAIN_SET_VCPUS:
	fn = (dispatch_fn) remoteDispatchDomainSetVcpus;
	args_filter = (xdrproc_t) xdr_remote_domain_set_vcpus_args;
	args = (char *) &lv_remote_domain_set_vcpus_args;
	memset (&lv_remote_domain_set_vcpus_args, 0, sizeof lv_remote_domain_set_vcpus_args);
	break;
case REMOTE_PROC_DOMAIN_SHUTDOWN:
	fn = (dispatch_fn) remoteDispatchDomainShutdown;
	args_filter = (xdrproc_t) xdr_remote_domain_shutdown_args;
	args = (char *) &lv_remote_domain_shutdown_args;
	memset (&lv_remote_domain_shutdown_args, 0, sizeof lv_remote_domain_shutdown_args);
	break;
case REMOTE_PROC_DOMAIN_SUSPEND:
	fn = (dispatch_fn) remoteDispatchDomainSuspend;
	args_filter = (xdrproc_t) xdr_remote_domain_suspend_args;
	args = (char *) &lv_remote_domain_suspend_args;
	memset (&lv_remote_domain_suspend_args, 0, sizeof lv_remote_domain_suspend_args);
	break;
case REMOTE_PROC_DOMAIN_UNDEFINE:
	fn = (dispatch_fn) remoteDispatchDomainUndefine;
	args_filter = (xdrproc_t) xdr_remote_domain_undefine_args;
	args = (char *) &lv_remote_domain_undefine_args;
	memset (&lv_remote_domain_undefine_args, 0, sizeof lv_remote_domain_undefine_args);
	break;
case REMOTE_PROC_GET_CAPABILITIES:
	fn = (dispatch_fn) remoteDispatchGetCapabilities;
	ret_filter = (xdrproc_t) xdr_remote_get_capabilities_ret;
	ret = (char *) &lv_remote_get_capabilities_ret;
	memset (&lv_remote_get_capabilities_ret, 0, sizeof lv_remote_get_capabilities_ret);
	break;
case REMOTE_PROC_GET_MAX_VCPUS:
	fn = (dispatch_fn) remoteDispatchGetMaxVcpus;
	args_filter = (xdrproc_t) xdr_remote_get_max_vcpus_args;
	args = (char *) &lv_remote_get_max_vcpus_args;
	memset (&lv_remote_get_max_vcpus_args, 0, sizeof lv_remote_get_max_vcpus_args);
	ret_filter = (xdrproc_t) xdr_remote_get_max_vcpus_ret;
	ret = (char *) &lv_remote_get_max_vcpus_ret;
	memset (&lv_remote_get_max_vcpus_ret, 0, sizeof lv_remote_get_max_vcpus_ret);
	break;
case REMOTE_PROC_GET_TYPE:
	fn = (dispatch_fn) remoteDispatchGetType;
	ret_filter = (xdrproc_t) xdr_remote_get_type_ret;
	ret = (char *) &lv_remote_get_type_ret;
	memset (&lv_remote_get_type_ret, 0, sizeof lv_remote_get_type_ret);
	break;
case REMOTE_PROC_GET_VERSION:
	fn = (dispatch_fn) remoteDispatchGetVersion;
	ret_filter = (xdrproc_t) xdr_remote_get_version_ret;
	ret = (char *) &lv_remote_get_version_ret;
	memset (&lv_remote_get_version_ret, 0, sizeof lv_remote_get_version_ret);
	break;
case REMOTE_PROC_LIST_DEFINED_DOMAINS:
	fn = (dispatch_fn) remoteDispatchListDefinedDomains;
	args_filter = (xdrproc_t) xdr_remote_list_defined_domains_args;
	args = (char *) &lv_remote_list_defined_domains_args;
	memset (&lv_remote_list_defined_domains_args, 0, sizeof lv_remote_list_defined_domains_args);
	ret_filter = (xdrproc_t) xdr_remote_list_defined_domains_ret;
	ret = (char *) &lv_remote_list_defined_domains_ret;
	memset (&lv_remote_list_defined_domains_ret, 0, sizeof lv_remote_list_defined_domains_ret);
	break;
case REMOTE_PROC_LIST_DEFINED_NETWORKS:
	fn = (dispatch_fn) remoteDispatchListDefinedNetworks;
	args_filter = (xdrproc_t) xdr_remote_list_defined_networks_args;
	args = (char *) &lv_remote_list_defined_networks_args;
	memset (&lv_remote_list_defined_networks_args, 0, sizeof lv_remote_list_defined_networks_args);
	ret_filter = (xdrproc_t) xdr_remote_list_defined_networks_ret;
	ret = (char *) &lv_remote_list_defined_networks_ret;
	memset (&lv_remote_list_defined_networks_ret, 0, sizeof lv_remote_list_defined_networks_ret);
	break;
case REMOTE_PROC_LIST_DOMAINS:
	fn = (dispatch_fn) remoteDispatchListDomains;
	args_filter = (xdrproc_t) xdr_remote_list_domains_args;
	args = (char *) &lv_remote_list_domains_args;
	memset (&lv_remote_list_domains_args, 0, sizeof lv_remote_list_domains_args);
	ret_filter = (xdrproc_t) xdr_remote_list_domains_ret;
	ret = (char *) &lv_remote_list_domains_ret;
	memset (&lv_remote_list_domains_ret, 0, sizeof lv_remote_list_domains_ret);
	break;
case REMOTE_PROC_LIST_NETWORKS:
	fn = (dispatch_fn) remoteDispatchListNetworks;
	args_filter = (xdrproc_t) xdr_remote_list_networks_args;
	args = (char *) &lv_remote_list_networks_args;
	memset (&lv_remote_list_networks_args, 0, sizeof lv_remote_list_networks_args);
	ret_filter = (xdrproc_t) xdr_remote_list_networks_ret;
	ret = (char *) &lv_remote_list_networks_ret;
	memset (&lv_remote_list_networks_ret, 0, sizeof lv_remote_list_networks_ret);
	break;
case REMOTE_PROC_NETWORK_CREATE:
	fn = (dispatch_fn) remoteDispatchNetworkCreate;
	args_filter = (xdrproc_t) xdr_remote_network_create_args;
	args = (char *) &lv_remote_network_create_args;
	memset (&lv_remote_network_create_args, 0, sizeof lv_remote_network_create_args);
	break;
case REMOTE_PROC_NETWORK_CREATE_XML:
	fn = (dispatch_fn) remoteDispatchNetworkCreateXml;
	args_filter = (xdrproc_t) xdr_remote_network_create_xml_args;
	args = (char *) &lv_remote_network_create_xml_args;
	memset (&lv_remote_network_create_xml_args, 0, sizeof lv_remote_network_create_xml_args);
	ret_filter = (xdrproc_t) xdr_remote_network_create_xml_ret;
	ret = (char *) &lv_remote_network_create_xml_ret;
	memset (&lv_remote_network_create_xml_ret, 0, sizeof lv_remote_network_create_xml_ret);
	break;
case REMOTE_PROC_NETWORK_DEFINE_XML:
	fn = (dispatch_fn) remoteDispatchNetworkDefineXml;
	args_filter = (xdrproc_t) xdr_remote_network_define_xml_args;
	args = (char *) &lv_remote_network_define_xml_args;
	memset (&lv_remote_network_define_xml_args, 0, sizeof lv_remote_network_define_xml_args);
	ret_filter = (xdrproc_t) xdr_remote_network_define_xml_ret;
	ret = (char *) &lv_remote_network_define_xml_ret;
	memset (&lv_remote_network_define_xml_ret, 0, sizeof lv_remote_network_define_xml_ret);
	break;
case REMOTE_PROC_NETWORK_DESTROY:
	fn = (dispatch_fn) remoteDispatchNetworkDestroy;
	args_filter = (xdrproc_t) xdr_remote_network_destroy_args;
	args = (char *) &lv_remote_network_destroy_args;
	memset (&lv_remote_network_destroy_args, 0, sizeof lv_remote_network_destroy_args);
	break;
case REMOTE_PROC_NETWORK_DUMP_XML:
	fn = (dispatch_fn) remoteDispatchNetworkDumpXml;
	args_filter = (xdrproc_t) xdr_remote_network_dump_xml_args;
	args = (char *) &lv_remote_network_dump_xml_args;
	memset (&lv_remote_network_dump_xml_args, 0, sizeof lv_remote_network_dump_xml_args);
	ret_filter = (xdrproc_t) xdr_remote_network_dump_xml_ret;
	ret = (char *) &lv_remote_network_dump_xml_ret;
	memset (&lv_remote_network_dump_xml_ret, 0, sizeof lv_remote_network_dump_xml_ret);
	break;
case REMOTE_PROC_NETWORK_GET_AUTOSTART:
	fn = (dispatch_fn) remoteDispatchNetworkGetAutostart;
	args_filter = (xdrproc_t) xdr_remote_network_get_autostart_args;
	args = (char *) &lv_remote_network_get_autostart_args;
	memset (&lv_remote_network_get_autostart_args, 0, sizeof lv_remote_network_get_autostart_args);
	ret_filter = (xdrproc_t) xdr_remote_network_get_autostart_ret;
	ret = (char *) &lv_remote_network_get_autostart_ret;
	memset (&lv_remote_network_get_autostart_ret, 0, sizeof lv_remote_network_get_autostart_ret);
	break;
case REMOTE_PROC_NETWORK_GET_BRIDGE_NAME:
	fn = (dispatch_fn) remoteDispatchNetworkGetBridgeName;
	args_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_args;
	args = (char *) &lv_remote_network_get_bridge_name_args;
	memset (&lv_remote_network_get_bridge_name_args, 0, sizeof lv_remote_network_get_bridge_name_args);
	ret_filter = (xdrproc_t) xdr_remote_network_get_bridge_name_ret;
	ret = (char *) &lv_remote_network_get_bridge_name_ret;
	memset (&lv_remote_network_get_bridge_name_ret, 0, sizeof lv_remote_network_get_bridge_name_ret);
	break;
case REMOTE_PROC_NETWORK_LOOKUP_BY_NAME:
	fn = (dispatch_fn) remoteDispatchNetworkLookupByName;
	args_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_args;
	args = (char *) &lv_remote_network_lookup_by_name_args;
	memset (&lv_remote_network_lookup_by_name_args, 0, sizeof lv_remote_network_lookup_by_name_args);
	ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_name_ret;
	ret = (char *) &lv_remote_network_lookup_by_name_ret;
	memset (&lv_remote_network_lookup_by_name_ret, 0, sizeof lv_remote_network_lookup_by_name_ret);
	break;
case REMOTE_PROC_NETWORK_LOOKUP_BY_UUID:
	fn = (dispatch_fn) remoteDispatchNetworkLookupByUuid;
	args_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_args;
	args = (char *) &lv_remote_network_lookup_by_uuid_args;
	memset (&lv_remote_network_lookup_by_uuid_args, 0, sizeof lv_remote_network_lookup_by_uuid_args);
	ret_filter = (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret;
	ret = (char *) &lv_remote_network_lookup_by_uuid_ret;
	memset (&lv_remote_network_lookup_by_uuid_ret, 0, sizeof lv_remote_network_lookup_by_uuid_ret);
	break;
case REMOTE_PROC_NETWORK_SET_AUTOSTART:
	fn = (dispatch_fn) remoteDispatchNetworkSetAutostart;
	args_filter = (xdrproc_t) xdr_remote_network_set_autostart_args;
	args = (char *) &lv_remote_network_set_autostart_args;
	memset (&lv_remote_network_set_autostart_args, 0, sizeof lv_remote_network_set_autostart_args);
	break;
case REMOTE_PROC_NETWORK_UNDEFINE:
	fn = (dispatch_fn) remoteDispatchNetworkUndefine;
	args_filter = (xdrproc_t) xdr_remote_network_undefine_args;
	args = (char *) &lv_remote_network_undefine_args;
	memset (&lv_remote_network_undefine_args, 0, sizeof lv_remote_network_undefine_args);
	break;
case REMOTE_PROC_NODE_GET_INFO:
	fn = (dispatch_fn) remoteDispatchNodeGetInfo;
	ret_filter = (xdrproc_t) xdr_remote_node_get_info_ret;
	ret = (char *) &lv_remote_node_get_info_ret;
	memset (&lv_remote_node_get_info_ret, 0, sizeof lv_remote_node_get_info_ret);
	break;
case REMOTE_PROC_NUM_OF_DEFINED_DOMAINS:
	fn = (dispatch_fn) remoteDispatchNumOfDefinedDomains;
	ret_filter = (xdrproc_t) xdr_remote_num_of_defined_domains_ret;
	ret = (char *) &lv_remote_num_of_defined_domains_ret;
	memset (&lv_remote_num_of_defined_domains_ret, 0, sizeof lv_remote_num_of_defined_domains_ret);
	break;
case REMOTE_PROC_NUM_OF_DEFINED_NETWORKS:
	fn = (dispatch_fn) remoteDispatchNumOfDefinedNetworks;
	ret_filter = (xdrproc_t) xdr_remote_num_of_defined_networks_ret;
	ret = (char *) &lv_remote_num_of_defined_networks_ret;
	memset (&lv_remote_num_of_defined_networks_ret, 0, sizeof lv_remote_num_of_defined_networks_ret);
	break;
case REMOTE_PROC_NUM_OF_DOMAINS:
	fn = (dispatch_fn) remoteDispatchNumOfDomains;
	ret_filter = (xdrproc_t) xdr_remote_num_of_domains_ret;
	ret = (char *) &lv_remote_num_of_domains_ret;
	memset (&lv_remote_num_of_domains_ret, 0, sizeof lv_remote_num_of_domains_ret);
	break;
case REMOTE_PROC_NUM_OF_NETWORKS:
	fn = (dispatch_fn) remoteDispatchNumOfNetworks;
	ret_filter = (xdrproc_t) xdr_remote_num_of_networks_ret;
	ret = (char *) &lv_remote_num_of_networks_ret;
	memset (&lv_remote_num_of_networks_ret, 0, sizeof lv_remote_num_of_networks_ret);
	break;
case REMOTE_PROC_OPEN:
	fn = (dispatch_fn) remoteDispatchOpen;
	args_filter = (xdrproc_t) xdr_remote_open_args;
	args = (char *) &lv_remote_open_args;
	memset (&lv_remote_open_args, 0, sizeof lv_remote_open_args);
	break;
/* Automatically generated by remote_generate_stubs.pl.
 * Do not edit this file.  Any changes you make will be lost.
 */

static int remoteDispatchClose (struct qemud_client *client, remote_message_header *req, void *args, void *ret);
static int remoteDispatchDomainAttachDevice (struct qemud_client *client, remote_message_header *req, remote_domain_attach_device_args *args, void *ret);
static int remoteDispatchDomainCoreDump (struct qemud_client *client, remote_message_header *req, remote_domain_core_dump_args *args, void *ret);
static int remoteDispatchDomainCreate (struct qemud_client *client, remote_message_header *req, remote_domain_create_args *args, void *ret);
static int remoteDispatchDomainCreateLinux (struct qemud_client *client, remote_message_header *req, remote_domain_create_linux_args *args, remote_domain_create_linux_ret *ret);
static int remoteDispatchDomainDefineXml (struct qemud_client *client, remote_message_header *req, remote_domain_define_xml_args *args, remote_domain_define_xml_ret *ret);
static int remoteDispatchDomainDestroy (struct qemud_client *client, remote_message_header *req, remote_domain_destroy_args *args, void *ret);
static int remoteDispatchDomainDetachDevice (struct qemud_client *client, remote_message_header *req, remote_domain_detach_device_args *args, void *ret);
static int remoteDispatchDomainDumpXml (struct qemud_client *client, remote_message_header *req, remote_domain_dump_xml_args *args, remote_domain_dump_xml_ret *ret);
static int remoteDispatchDomainGetAutostart (struct qemud_client *client, remote_message_header *req, remote_domain_get_autostart_args *args, remote_domain_get_autostart_ret *ret);
static int remoteDispatchDomainGetInfo (struct qemud_client *client, remote_message_header *req, remote_domain_get_info_args *args, remote_domain_get_info_ret *ret);
static int remoteDispatchDomainGetMaxMemory (struct qemud_client *client, remote_message_header *req, remote_domain_get_max_memory_args *args, remote_domain_get_max_memory_ret *ret);
static int remoteDispatchDomainGetMaxVcpus (struct qemud_client *client, remote_message_header *req, remote_domain_get_max_vcpus_args *args, remote_domain_get_max_vcpus_ret *ret);
static int remoteDispatchDomainGetOsType (struct qemud_client *client, remote_message_header *req, remote_domain_get_os_type_args *args, remote_domain_get_os_type_ret *ret);
static int remoteDispatchDomainGetVcpus (struct qemud_client *client, remote_message_header *req, remote_domain_get_vcpus_args *args, remote_domain_get_vcpus_ret *ret);
static int remoteDispatchDomainLookupById (struct qemud_client *client, remote_message_header *req, remote_domain_lookup_by_id_args *args, remote_domain_lookup_by_id_ret *ret);
static int remoteDispatchDomainLookupByName (struct qemud_client *client, remote_message_header *req, remote_domain_lookup_by_name_args *args, remote_domain_lookup_by_name_ret *ret);
static int remoteDispatchDomainLookupByUuid (struct qemud_client *client, remote_message_header *req, remote_domain_lookup_by_uuid_args *args, remote_domain_lookup_by_uuid_ret *ret);
static int remoteDispatchDomainPinVcpu (struct qemud_client *client, remote_message_header *req, remote_domain_pin_vcpu_args *args, void *ret);
static int remoteDispatchDomainReboot (struct qemud_client *client, remote_message_header *req, remote_domain_reboot_args *args, void *ret);
static int remoteDispatchDomainRestore (struct qemud_client *client, remote_message_header *req, remote_domain_restore_args *args, void *ret);
static int remoteDispatchDomainResume (struct qemud_client *client, remote_message_header *req, remote_domain_resume_args *args, void *ret);
static int remoteDispatchDomainSave (struct qemud_client *client, remote_message_header *req, remote_domain_save_args *args, void *ret);
static int remoteDispatchDomainSetAutostart (struct qemud_client *client, remote_message_header *req, remote_domain_set_autostart_args *args, void *ret);
static int remoteDispatchDomainSetMaxMemory (struct qemud_client *client, remote_message_header *req, remote_domain_set_max_memory_args *args, void *ret);
static int remoteDispatchDomainSetMemory (struct qemud_client *client, remote_message_header *req, remote_domain_set_memory_args *args, void *ret);
static int remoteDispatchDomainSetVcpus (struct qemud_client *client, remote_message_header *req, remote_domain_set_vcpus_args *args, void *ret);
static int remoteDispatchDomainShutdown (struct qemud_client *client, remote_message_header *req, remote_domain_shutdown_args *args, void *ret);
static int remoteDispatchDomainSuspend (struct qemud_client *client, remote_message_header *req, remote_domain_suspend_args *args, void *ret);
static int remoteDispatchDomainUndefine (struct qemud_client *client, remote_message_header *req, remote_domain_undefine_args *args, void *ret);
static int remoteDispatchGetCapabilities (struct qemud_client *client, remote_message_header *req, void *args, remote_get_capabilities_ret *ret);
static int remoteDispatchGetMaxVcpus (struct qemud_client *client, remote_message_header *req, remote_get_max_vcpus_args *args, remote_get_max_vcpus_ret *ret);
static int remoteDispatchGetType (struct qemud_client *client, remote_message_header *req, void *args, remote_get_type_ret *ret);
static int remoteDispatchGetVersion (struct qemud_client *client, remote_message_header *req, void *args, remote_get_version_ret *ret);
static int remoteDispatchListDefinedDomains (struct qemud_client *client, remote_message_header *req, remote_list_defined_domains_args *args, remote_list_defined_domains_ret *ret);
static int remoteDispatchListDefinedNetworks (struct qemud_client *client, remote_message_header *req, remote_list_defined_networks_args *args, remote_list_defined_networks_ret *ret);
static int remoteDispatchListDomains (struct qemud_client *client, remote_message_header *req, remote_list_domains_args *args, remote_list_domains_ret *ret);
static int remoteDispatchListNetworks (struct qemud_client *client, remote_message_header *req, remote_list_networks_args *args, remote_list_networks_ret *ret);
static int remoteDispatchNetworkCreate (struct qemud_client *client, remote_message_header *req, remote_network_create_args *args, void *ret);
static int remoteDispatchNetworkCreateXml (struct qemud_client *client, remote_message_header *req, remote_network_create_xml_args *args, remote_network_create_xml_ret *ret);
static int remoteDispatchNetworkDefineXml (struct qemud_client *client, remote_message_header *req, remote_network_define_xml_args *args, remote_network_define_xml_ret *ret);
static int remoteDispatchNetworkDestroy (struct qemud_client *client, remote_message_header *req, remote_network_destroy_args *args, void *ret);
static int remoteDispatchNetworkDumpXml (struct qemud_client *client, remote_message_header *req, remote_network_dump_xml_args *args, remote_network_dump_xml_ret *ret);
static int remoteDispatchNetworkGetAutostart (struct qemud_client *client, remote_message_header *req, remote_network_get_autostart_args *args, remote_network_get_autostart_ret *ret);
static int remoteDispatchNetworkGetBridgeName (struct qemud_client *client, remote_message_header *req, remote_network_get_bridge_name_args *args, remote_network_get_bridge_name_ret *ret);
static int remoteDispatchNetworkLookupByName (struct qemud_client *client, remote_message_header *req, remote_network_lookup_by_name_args *args, remote_network_lookup_by_name_ret *ret);
static int remoteDispatchNetworkLookupByUuid (struct qemud_client *client, remote_message_header *req, remote_network_lookup_by_uuid_args *args, remote_network_lookup_by_uuid_ret *ret);
static int remoteDispatchNetworkSetAutostart (struct qemud_client *client, remote_message_header *req, remote_network_set_autostart_args *args, void *ret);
static int remoteDispatchNetworkUndefine (struct qemud_client *client, remote_message_header *req, remote_network_undefine_args *args, void *ret);
static int remoteDispatchNodeGetInfo (struct qemud_client *client, remote_message_header *req, void *args, remote_node_get_info_ret *ret);
static int remoteDispatchNumOfDefinedDomains (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_defined_domains_ret *ret);
static int remoteDispatchNumOfDefinedNetworks (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_defined_networks_ret *ret);
static int remoteDispatchNumOfDomains (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_domains_ret *ret);
static int remoteDispatchNumOfNetworks (struct qemud_client *client, remote_message_header *req, void *args, remote_num_of_networks_ret *ret);
static int remoteDispatchOpen (struct qemud_client *client, remote_message_header *req, remote_open_args *args, void *ret);

Attachment: smime.p7s
Description: S/MIME Cryptographic Signature


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]