diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/configure.in libvirt-qemu/configure.in
--- libvirt/configure.in	2007-01-22 15:50:57.000000000 -0500
+++ libvirt-qemu/configure.in	2007-01-22 12:00:43.000000000 -0500
@@ -266,6 +266,7 @@ AC_OUTPUT(Makefile src/Makefile include/
           po/Makefile.in \
 	  include/libvirt/Makefile include/libvirt/libvirt.h \
 	  python/Makefile python/tests/Makefile \
+          qemud/Makefile \
           tests/Makefile proxy/Makefile \
           tests/xml2sexprdata/Makefile \
           tests/sexpr2xmldata/Makefile \
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/Makefile.am libvirt-qemu/Makefile.am
--- libvirt/Makefile.am	2006-09-21 11:24:37.000000000 -0400
+++ libvirt-qemu/Makefile.am	2006-12-13 21:17:37.000000000 -0500
@@ -1,6 +1,7 @@
 ## Process this file with automake to produce Makefile.in
 
-SUBDIRS = src include docs @PYTHON_SUBDIR@ tests proxy po
+SUBDIRS = src qemud proxy include docs @PYTHON_SUBDIR@ tests po
 
 ACLOCAL_AMFLAGS = -I m4
 
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/config.c libvirt-qemu/qemud/config.c
--- libvirt/qemud/config.c	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/config.c	2007-01-22 15:36:17.000000000 -0500
@@ -0,0 +1,1423 @@
+/*
+ * config.c: VM configuration management
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+#include <dirent.h>
+#include <string.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/uri.h>
+
+#include <libvirt/virterror.h>
+
+#include "protocol.h"
+#include "internal.h"
+#include "config.h"
+#include "driver.h"
+
+static int qemudParseUUID(const char *uuid,
+                          unsigned char *rawuuid) {
+    const char *cur;
+    int i;
+
+    /*
+     * do a liberal scan allowing '-' and ' ' anywhere between character
+     * pairs as long as there is 32 of them in the end.
+     */
+    cur = uuid;
+    for (i = 0;i < 16;) {
+        rawuuid[i] = 0;
+        if (*cur == 0)
+            goto error;
+        if ((*cur == '-') || (*cur == ' ')) {
+            cur++;
+            continue;
+        }
+        if ((*cur >= '0') && (*cur <= '9'))
+            rawuuid[i] = *cur - '0';
+        else if ((*cur >= 'a') && (*cur <= 'f'))
+            rawuuid[i] = *cur - 'a' + 10;
+        else if ((*cur >= 'A') && (*cur <= 'F'))
+            rawuuid[i] = *cur - 'A' + 10;
+        else
+            goto error;
+        rawuuid[i] *= 16;
+        cur++;
+        if (*cur == 0)
+            goto error;
+        if ((*cur >= '0') && (*cur <= '9'))
+            rawuuid[i] += *cur - '0';
+        else if ((*cur >= 'a') && (*cur <= 'f'))
+            rawuuid[i] += *cur - 'a' + 10;
+        else if ((*cur >= 'A') && (*cur <= 'F'))
+            rawuuid[i] += *cur - 'A' + 10;
+        else
+            goto error;
+        i++;
+        cur++;
+    }
+
+    return 0;
+
+ error:
+    return -1;
+}
+
+
+/* Build up a fully qualfiied path for a config file to be
+ * associated with a persistent guest or network */
+static int
+qemudMakeConfigPath(const char *configDir,
+                    const char *name,
+                    const char *ext,
+                    char *buf,
+                    unsigned int buflen) {
+    if ((strlen(configDir) + 1 + strlen(name) + (ext ? strlen(ext) : 0) + 1) > buflen)
+        return -1;
+
+    strcpy(buf, configDir);
+    strcat(buf, "/");
+    strcat(buf, name);
+    if (ext)
+        strcat(buf, ext);
+    return 0;
+}
+
+static int
+qemudEnsureConfigDir(struct qemud_server *server,
+                     const char *configDir) {
+    struct stat sb;
+
+    /* XXX: needs to be recursive */
+
+    if (stat(configDir, &sb) < 0) {
+        if (errno == ENOENT) {
+            if (mkdir(configDir, 0700) < 0) {
+                qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                                 "cannot create config directory %s: %s",
+                                 configDir, strerror(errno));
+                return -1;
+            }
+        } else {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                             "cannot stat config directory %s",
+                             configDir, strerror(errno));
+            return -1;
+        }
+    } else if (!S_ISDIR(sb.st_mode)) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                         "config directory %s is not a directory", configDir);
+        return -1;
+    }
+
+    return 0;
+}
+
+struct qemu_arch_info {
+    const char *arch;
+    const char **machines;
+    const char *binary;
+};
+
+/* The list of possible machine types for various architectures,
+   as supported by QEMU - taken from 'qemu -M ?' for each arch */
+static const char *arch_info_x86_machines[] = {
+    "pc", "isapc"
+};
+static const char *arch_info_mips_machines[] = {
+    "mips"
+};
+static const char *arch_info_sparc_machines[] = {
+    "sun4m"
+};
+static const char *arch_info_ppc_machines[] = {
+    "g3bw", "mac99", "prep"
+};
+
+/* The archicture tables for supported QEMU archs */
+static struct qemu_arch_info archs[] = { 
+    {  "i686", arch_info_x86_machines, "qemu" },
+    {  "x86_64", arch_info_x86_machines, "qemu-system-x86_64" },
+    {  "mips", arch_info_mips_machines, "qemu-system-mips" },
+    {  "mipsel", arch_info_mips_machines, "qemu-system-mipsel" },
+    {  "sparc", arch_info_sparc_machines, "qemu-system-sparc" },
+    {  "ppc", arch_info_ppc_machines, "qemu-system-ppc" },
+};
+
+/* Return the default architecture if none is explicitly requested*/
+static const char *qemudDefaultArch(void) {
+    return archs[0].arch;
+}
+
+/* Return the default machine type for a given architecture */
+static const char *qemudDefaultMachineForArch(const char *arch) {
+    int i;
+
+    for (i = 0 ; i < (int)(sizeof(archs) / sizeof(struct qemu_arch_info)) ; i++) {
+        if (!strcmp(archs[i].arch, arch)) {
+            return archs[i].machines[0];
+        }
+    }
+
+    return NULL;
+}
+
+/* Return the default binary name for a particular architecture */
+static const char *qemudDefaultBinaryForArch(const char *arch) {
+    int i;
+
+    for (i = 0 ; i < (int)(sizeof(archs) / sizeof(struct qemu_arch_info)) ; i++) {
+        if (!strcmp(archs[i].arch, arch)) {
+            return archs[i].binary;
+        }
+    }
+
+    return NULL;
+}
+
+/* Find the fully qualified path to the binary for an architecture */
+static char *qemudLocateBinaryForArch(struct qemud_server *server,
+                                      int virtType, const char *arch) {
+    const char *name;
+    char *path;
+
+    if (virtType == QEMUD_VIRT_KVM)
+        name = "qemu-kvm";
+    else
+        name = qemudDefaultBinaryForArch(arch);
+
+    if (!name) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot determin binary for architecture %s", arch);
+        return NULL;
+    }
+
+    /* XXX lame. should actually use $PATH ... */
+    path = malloc(strlen(name) + strlen("/usr/bin/") + 1);
+    if (!path) {
+        qemudReportError(server, VIR_ERR_NO_MEMORY, "path");
+        return NULL;
+    }
+    strcpy(path, "/usr/bin/");
+    strcat(path, name);
+    return path;
+}
+
+/* Parse the XML definition for a disk */
+static struct qemud_vm_disk_def *qemudParseDiskXML(struct qemud_server *server,
+                                                   xmlNodePtr node) {
+    struct qemud_vm_disk_def *disk = calloc(1, sizeof(struct qemud_vm_disk_def));
+    xmlNodePtr cur;
+    xmlChar *device = NULL;
+    xmlChar *source = NULL;
+    xmlChar *target = NULL;
+    xmlChar *type = NULL;
+    int typ = 0;
+
+    if (!disk) {
+        qemudReportError(server, VIR_ERR_NO_MEMORY, "disk");
+        return NULL;
+    }
+
+    type = xmlGetProp(node, BAD_CAST "type");
+    if (type != NULL) {
+        if (xmlStrEqual(type, BAD_CAST "file"))
+            typ = QEMUD_DISK_FILE;
+        else if (xmlStrEqual(type, BAD_CAST "block"))
+            typ = QEMUD_DISK_BLOCK;
+        else {
+            typ = QEMUD_DISK_FILE;
+        }
+        xmlFree(type);
+        type = NULL;
+    }
+
+    device = xmlGetProp(node, BAD_CAST "device");
+  
+    cur = node->children;
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if ((source == NULL) &&
+                (xmlStrEqual(cur->name, BAD_CAST "source"))) {
+	
+                if (typ == QEMUD_DISK_FILE)
+                    source = xmlGetProp(cur, BAD_CAST "file");
+                else
+                    source = xmlGetProp(cur, BAD_CAST "dev");
+            } else if ((target == NULL) &&
+                       (xmlStrEqual(cur->name, BAD_CAST "target"))) {
+                target = xmlGetProp(cur, BAD_CAST "dev");
+            } else if (xmlStrEqual(cur->name, BAD_CAST "readonly")) {
+                disk->readonly = 1;
+            }
+        }
+        cur = cur->next;
+    }
+
+    if (source == NULL) {
+        qemudReportError(server, VIR_ERR_NO_SOURCE, target ? "%s" : NULL, target);
+        goto error;
+    }
+    if (target == NULL) {
+        qemudReportError(server, VIR_ERR_NO_TARGET, source ? "%s" : NULL, source);
+        goto error;
+    }
+
+    if (device &&
+        !strcmp((const char *)device, "floppy") &&
+        strcmp((const char *)target, "fda") &&
+        strcmp((const char *)target, "fdb")) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "Invalid floppy device name: %s", target);
+        goto error;
+    }
+  
+    if (device &&
+        !strcmp((const char *)device, "cdrom") &&
+        strcmp((const char *)target, "hdc")) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "Invalid cdrom device name: %s", target);
+        goto error;
+    }
+
+    if (device &&
+        !strcmp((const char *)device, "cdrom"))
+        disk->readonly = 1;
+
+    if ((!device || !strcmp((const char *)device, "disk")) &&
+        strcmp((const char *)target, "hda") &&
+        strcmp((const char *)target, "hdb") &&
+        strcmp((const char *)target, "hdc") &&
+        strcmp((const char *)target, "hdd")) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "Invalid harddisk device name: %s", target);
+        goto error;
+    }
+
+    strncpy(disk->src, (const char *)source, NAME_MAX-1);
+    disk->src[NAME_MAX-1] = '\0';
+
+    strncpy(disk->dst, (const char *)target, NAME_MAX-1);
+    disk->dst[NAME_MAX-1] = '\0';
+    disk->type = typ;
+
+    if (!device)
+        disk->device = QEMUD_DISK_DISK;
+    else if (!strcmp((const char *)device, "disk"))
+        disk->device = QEMUD_DISK_DISK;
+    else if (!strcmp((const char *)device, "cdrom"))
+        disk->device = QEMUD_DISK_CDROM;
+    else if (!strcmp((const char *)device, "floppy"))
+        disk->device = QEMUD_DISK_FLOPPY;
+    else {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "Invalid device type: %s", device);
+        goto error;
+    }
+
+    xmlFree(device);
+    xmlFree(target);
+    xmlFree(source);
+
+    return disk;
+
+ error:
+    if (type)
+        xmlFree(type);
+    if (target)
+        xmlFree(target);
+    if (source)
+        xmlFree(source);
+    if (device)
+        xmlFree(device);
+    free(disk);
+    return NULL;
+}
+
+
+/* Parse the XML definition for a network interface */
+static struct qemud_vm_net_def *qemudParseInterfaceXML(struct qemud_server *server,
+                                                       xmlNodePtr node) {
+    struct qemud_vm_net_def *net = calloc(1, sizeof(struct qemud_vm_net_def));
+    xmlNodePtr cur;
+    xmlChar *macaddr = NULL;
+    xmlChar *type = NULL;
+
+    if (!net) {
+        qemudReportError(server, VIR_ERR_NO_MEMORY, "net");
+        return NULL;
+    }
+
+    net->type = QEMUD_NET_USER;
+
+    type = xmlGetProp(node, BAD_CAST "type");
+    if (type != NULL) {
+        if (xmlStrEqual(type, BAD_CAST "user"))
+            net->type = QEMUD_NET_USER;
+        else if (xmlStrEqual(type, BAD_CAST "tap"))
+            net->type = QEMUD_NET_TAP;
+        else if (xmlStrEqual(type, BAD_CAST "server"))
+            net->type = QEMUD_NET_SERVER;
+        else if (xmlStrEqual(type, BAD_CAST "client"))
+            net->type = QEMUD_NET_CLIENT;
+        else if (xmlStrEqual(type, BAD_CAST "mcast"))
+            net->type = QEMUD_NET_MCAST;
+        /*
+        else if (xmlStrEqual(type, BAD_CAST "vde"))
+          typ = QEMUD_NET_VDE;
+        */
+        else
+            net->type = QEMUD_NET_USER;
+        xmlFree(type);
+        type = NULL;
+    }
+
+    cur = node->children;
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if ((macaddr == NULL) &&
+                (xmlStrEqual(cur->name, BAD_CAST "mac"))) {
+                macaddr = xmlGetProp(cur, BAD_CAST "address");
+            }
+        }
+        cur = cur->next;
+    }
+
+    net->vlan = 0;
+
+    if (macaddr) {
+        sscanf((const char *)macaddr, "%02x:%02x:%02x:%02x:%02x:%02x",
+               (unsigned int*)&net->mac[0],
+               (unsigned int*)&net->mac[1],
+               (unsigned int*)&net->mac[2],
+               (unsigned int*)&net->mac[3],
+               (unsigned int*)&net->mac[4],
+               (unsigned int*)&net->mac[5]);
+    }
+
+    xmlFree(macaddr);
+
+    return net;
+
+    /*
+ error:
+    if (macaddr)
+        xmlFree(macaddr);
+    free(net);
+    return NULL;
+    */
+}
+
+
+/*
+ * Parses a libvirt XML definition of a guest, and populates the
+ * the qemud_vm struct with matching data about the guests config
+ */
+static int qemudParseXML(struct qemud_server *server,
+                         xmlDocPtr xml,
+                         struct qemud_vm *vm) {
+    xmlNodePtr root = NULL;
+    xmlChar *prop = NULL;
+    xmlXPathContextPtr ctxt = NULL;
+    xmlXPathObjectPtr obj = NULL;
+    char *conv = NULL;
+    int i;
+
+    /* Prepare parser / xpath context */
+    root = xmlDocGetRootElement(xml);
+    if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "domain"))) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "incorrect root element");
+        goto error;
+    }
+
+    ctxt = xmlXPathNewContext(xml);
+    if (ctxt == NULL) {
+        qemudReportError(server, VIR_ERR_NO_MEMORY, "xmlXPathContext");
+        goto error;
+    }
+
+
+    /* Find out what type of QEMU virtualization to use */
+    if (!(prop = xmlGetProp(root, BAD_CAST "type"))) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "missing domain type attribute");
+        goto error;
+    }
+
+    if (!strcmp((char *)prop, "qemu"))
+        vm->def.virtType = QEMUD_VIRT_QEMU;
+    else if (!strcmp((char *)prop, "kqemu"))
+        vm->def.virtType = QEMUD_VIRT_KQEMU;
+    else if (!strcmp((char *)prop, "kvm"))
+        vm->def.virtType = QEMUD_VIRT_KVM;
+    else {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "invalid domain type attribute");
+        goto error;
+    }
+    free(prop);
+    prop = NULL;
+
+
+    /* Extract domain name */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/name[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        qemudReportError(server, VIR_ERR_NO_NAME, NULL);
+        goto error;
+    }
+    if (strlen((const char *)obj->stringval) >= (QEMUD_MAX_NAME_LEN-1)) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "domain name length too long");
+        goto error;
+    }
+    strcpy(vm->def.name, (const char *)obj->stringval);
+    xmlXPathFreeObject(obj);
+
+
+    /* Extract domain uuid */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/uuid[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        /* XXX auto-generate a UUID */
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "missing uuid element");
+        goto error;
+    }
+    if (qemudParseUUID((const char *)obj->stringval, vm->def.uuid) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "malformed uuid element");
+        goto error;
+    }
+    xmlXPathFreeObject(obj);
+
+
+    /* Extract domain memory */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/memory[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "missing memory element");
+        goto error;
+    } else {
+        conv = NULL;
+        vm->def.maxmem = strtoll((const char*)obj->stringval, &conv, 10);
+        if (conv == (const char*)obj->stringval) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "malformed memory information");
+            goto error;
+        }
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    /* Extract domain memory */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/currentMemory[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        vm->def.memory = vm->def.maxmem;
+    } else {
+        conv = NULL;
+        vm->def.memory = strtoll((const char*)obj->stringval, &conv, 10);
+        if (vm->def.memory > vm->def.maxmem)
+            vm->def.memory = vm->def.maxmem;
+        if (conv == (const char*)obj->stringval) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "malformed memory information");
+            goto error;
+        }
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+    /* Extract domain vcpu info */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/vcpu[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        vm->def.vcpus = 1;
+    } else {
+        conv = NULL;
+        vm->def.vcpus = strtoll((const char*)obj->stringval, &conv, 10);
+        if (conv == (const char*)obj->stringval) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "malformed vcpu information");
+            goto error;
+        }
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    /* Extract OS type info */
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        qemudReportError(server, VIR_ERR_OS_TYPE, NULL);
+        goto error;
+    }
+    if (strcmp((const char *)obj->stringval, "hvm")) {
+        qemudReportError(server, VIR_ERR_OS_TYPE, "%s", obj->stringval);
+        goto error;
+    }
+    strcpy(vm->def.os.type, (const char *)obj->stringval);
+    xmlXPathFreeObject(obj);
+
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1]/@arch)", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        const char *defaultArch = qemudDefaultArch();
+        if (strlen(defaultArch) >= (QEMUD_OS_TYPE_MAX_LEN-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "architecture type too long");
+            goto error;
+        }
+        strcpy(vm->def.os.arch, defaultArch);
+    } else {
+        if (strlen((const char *)obj->stringval) >= (QEMUD_OS_TYPE_MAX_LEN-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "architecture type too long");
+            goto error;
+        }
+        strcpy(vm->def.os.arch, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/type[1]/@machine)", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        const char *defaultMachine = qemudDefaultMachineForArch(vm->def.os.arch);
+        if (strlen(defaultMachine) >= (QEMUD_OS_MACHINE_MAX_LEN-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "machine type too long");
+            goto error;
+        }
+        strcpy(vm->def.os.machine, defaultMachine);
+    } else {
+        if (strlen((const char *)obj->stringval) >= (QEMUD_OS_MACHINE_MAX_LEN-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "architecture type too long");
+            goto error;
+        }
+        strcpy(vm->def.os.machine, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/kernel[1])", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_STRING) &&
+        (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
+        if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "kernel path too long");
+            goto error;
+        }
+        strcpy(vm->def.os.kernel, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/initrd[1])", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_STRING) &&
+        (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
+        if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "initrd path too long");
+            goto error;
+        }
+        strcpy(vm->def.os.initrd, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/os/cmdline[1])", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_STRING) &&
+        (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
+        if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "cmdline arguments too long");
+            goto error;
+        }
+        strcpy(vm->def.os.cmdline, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+
+    /* analysis of the disk devices */
+    obj = xmlXPathEval(BAD_CAST "/domain/os/boot", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_NODESET) &&
+        (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) {
+        for (i = 0; i < obj->nodesetval->nodeNr && i < QEMUD_MAX_BOOT_DEVS ; i++) {
+            prop = xmlGetProp(obj->nodesetval->nodeTab[i], BAD_CAST "dev");
+            if (!strcmp((char *)prop, "hd")) {
+                vm->def.os.bootDevs[vm->def.os.nBootDevs++] = QEMUD_BOOT_DISK;
+            } else if (!strcmp((char *)prop, "fd")) {
+                vm->def.os.bootDevs[vm->def.os.nBootDevs++] = QEMUD_BOOT_FLOPPY;
+            } else if (!strcmp((char *)prop, "cdrom")) {
+                vm->def.os.bootDevs[vm->def.os.nBootDevs++] = QEMUD_BOOT_CDROM;
+            } else if (!strcmp((char *)prop, "net")) {
+                vm->def.os.bootDevs[vm->def.os.nBootDevs++] = QEMUD_BOOT_NET;
+            } else {
+                goto error;
+            }
+        }
+    }
+    xmlXPathFreeObject(obj);
+    if (vm->def.os.nBootDevs == 0) {
+        vm->def.os.nBootDevs = 1;
+        vm->def.os.bootDevs[0] = QEMUD_BOOT_DISK;
+    }
+
+
+    obj = xmlXPathEval(BAD_CAST "string(/domain/devices/emulator[1])", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_STRING) ||
+        (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
+        char *tmp = qemudLocateBinaryForArch(server, vm->def.virtType, vm->def.os.arch);
+        if (!tmp) {
+            goto error;
+        }
+        strcpy(vm->def.os.binary, tmp);
+        free(tmp);
+    } else {
+        if (strlen((const char *)obj->stringval) >= (PATH_MAX-1)) {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "%s", "emulator path too long");
+            goto error;
+        }
+        strcpy(vm->def.os.binary, (const char *)obj->stringval);
+    }
+    if (obj)
+        xmlXPathFreeObject(obj);
+
+    obj = xmlXPathEval(BAD_CAST "/domain/devices/graphics", ctxt);
+    if ((obj == NULL) || (obj->type != XPATH_NODESET) ||
+        (obj->nodesetval == NULL) || (obj->nodesetval->nodeNr == 0)) {
+        vm->def.graphicsType = QEMUD_GRAPHICS_NONE;
+    } else {
+        prop = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "type");
+        if (!strcmp((char *)prop, "vnc")) {
+            vm->def.graphicsType = QEMUD_GRAPHICS_VNC;
+            prop = xmlGetProp(obj->nodesetval->nodeTab[0], BAD_CAST "port");
+            if (prop) {
+                conv = NULL;
+                vm->def.vncPort = strtoll((const char*)prop, &conv, 10);
+            } else {
+                vm->def.vncPort = -1;
+            }
+        } else if (!strcmp((char *)prop, "sdl")) {
+            vm->def.graphicsType = QEMUD_GRAPHICS_SDL;
+        } else {
+            qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "Unsupported graphics type %s", prop);
+            goto error;
+        }
+    }
+
+    /* analysis of the disk devices */
+    obj = xmlXPathEval(BAD_CAST "/domain/devices/disk", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_NODESET) &&
+        (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) {
+        for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+            struct qemud_vm_disk_def *disk;
+            if (!(disk = qemudParseDiskXML(server, obj->nodesetval->nodeTab[i]))) {
+                goto error;
+            }
+            vm->def.ndisks++;
+            disk->next = vm->def.disks;
+            vm->def.disks = disk;
+        }
+    }
+    xmlXPathFreeObject(obj);
+
+
+    /* analysis of the network devices */
+    obj = xmlXPathEval(BAD_CAST "/domain/devices/interface", ctxt);
+    if ((obj != NULL) && (obj->type == XPATH_NODESET) &&
+        (obj->nodesetval != NULL) && (obj->nodesetval->nodeNr >= 0)) {
+        for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+            struct qemud_vm_net_def *net;
+            if (!(net = qemudParseInterfaceXML(server, obj->nodesetval->nodeTab[i]))) {
+                goto error;
+            }
+            vm->def.nnets++;
+            net->next = vm->def.nets;
+            vm->def.nets = net;
+        }
+    }
+    xmlXPathFreeObject(obj);
+    xmlXPathFreeContext(ctxt);
+
+    return 0;
+
+ error:
+    if (prop)
+        free(prop);
+    if (obj)
+        xmlXPathFreeObject(obj);
+    if (ctxt)
+        xmlXPathFreeContext(ctxt);
+    return -1;
+}
+
+
+/*
+ * Constructs a argv suitable for launching qemu with config defined
+ * for a given virtual machine.
+ */
+int qemudBuildCommandLine(struct qemud_server *server,
+                          struct qemud_vm *vm,
+                          char ***argv) {
+    int len, n = -1, i;
+    char memory[50];
+    char vcpus[50];
+    char boot[QEMUD_MAX_BOOT_DEVS+1];
+    struct qemud_vm_disk_def *disk = vm->def.disks;
+    struct qemud_vm_net_def *net = vm->def.nets;
+
+    len = 1 + /* qemu */
+        2 + /* machine type */
+        (vm->def.virtType == QEMUD_VIRT_QEMU ? 1 : 0) + /* Disable kqemu */
+        2 * vm->def.ndisks + /* disks*/
+        (vm->def.nnets > 0 ? (4 * vm->def.nnets) : 2) + /* networks */
+        2 + /* memory*/
+        2 + /* cpus */
+        2 + /* boot device */
+        (vm->def.os.kernel[0] ? 2 : 0) + /* kernel */
+        (vm->def.os.initrd[0] ? 2 : 0) + /* initrd */
+        (vm->def.os.cmdline[0] ? 2 : 0) + /* cmdline */
+        (vm->def.graphicsType == QEMUD_GRAPHICS_VNC ? 2 :
+         (vm->def.graphicsType == QEMUD_GRAPHICS_SDL ? 0 : 1)); /* graphics */
+
+    sprintf(memory, "%d", vm->def.memory/1024);
+    sprintf(vcpus, "%d", vm->def.vcpus);
+
+    if (!(*argv = malloc(sizeof(char *) * (len+1))))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup(vm->def.os.binary)))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup("-M")))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup(vm->def.os.machine)))
+        goto no_memory;
+    if (vm->def.virtType == QEMUD_VIRT_QEMU) {
+        if (!((*argv)[++n] = strdup("-no-kqemu")))
+        goto no_memory;
+    }
+    if (!((*argv)[++n] = strdup("-m")))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup(memory)))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup("-smp")))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup(vcpus)))
+        goto no_memory;
+
+    for (i = 0 ; i < vm->def.os.nBootDevs ; i++) {
+        switch (vm->def.os.bootDevs[i]) {
+        case QEMUD_BOOT_CDROM:
+            boot[i] = 'd';
+            break;
+        case QEMUD_BOOT_FLOPPY:
+            boot[i] = 'a';
+            break;
+        case QEMUD_BOOT_DISK:
+            boot[i] = 'c';
+            break;
+        case QEMUD_BOOT_NET:
+            boot[i] = 'n';
+            break;
+        default:
+            boot[i] = 'c';
+            break;
+        }
+    }
+    boot[vm->def.os.nBootDevs] = '\0';
+    if (!((*argv)[++n] = strdup("-boot")))
+        goto no_memory;
+    if (!((*argv)[++n] = strdup(boot)))
+        goto no_memory;
+
+    if (vm->def.os.kernel[0]) {
+        if (!((*argv)[++n] = strdup("-kernel")))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup(vm->def.os.kernel)))
+            goto no_memory;
+    }
+    if (vm->def.os.initrd[0]) {
+        if (!((*argv)[++n] = strdup("-initrd")))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup(vm->def.os.initrd)))
+            goto no_memory;
+    }
+    if (vm->def.os.cmdline[0]) {
+        if (!((*argv)[++n] = strdup("-append")))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup(vm->def.os.cmdline)))
+            goto no_memory;
+    }
+
+    while (disk) {
+        char dev[NAME_MAX];
+        char file[PATH_MAX];
+        if (!strcmp(disk->dst, "hdc") &&
+            disk->device == QEMUD_DISK_CDROM)
+            snprintf(dev, NAME_MAX, "-%s", "cdrom");
+        else
+            snprintf(dev, NAME_MAX, "-%s", disk->dst);
+        snprintf(file, PATH_MAX, "%s", disk->src);
+
+        if (!((*argv)[++n] = strdup(dev)))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup(file)))
+            goto no_memory;
+
+        disk = disk->next;
+    }
+
+    if (!net) {
+        if (!((*argv)[++n] = strdup("-net")))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup("none")))
+            goto no_memory;
+    } else {
+        while (net) {
+            char nic[3+1+7+1+17+1];
+            sprintf(nic, "nic,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
+                    net->mac[0], net->mac[1],
+                    net->mac[2], net->mac[3],
+                    net->mac[4], net->mac[5]);
+
+            if (!((*argv)[++n] = strdup("-net")))
+                goto no_memory;
+            if (!((*argv)[++n] = strdup(nic)))
+                goto no_memory;
+            if (!((*argv)[++n] = strdup("-net")))
+                goto no_memory;
+            /* XXX don't hardcode user */
+            if (!((*argv)[++n] = strdup("user")))
+                goto no_memory;
+
+            net = net->next;
+        }
+    }
+
+    if (vm->def.graphicsType == QEMUD_GRAPHICS_VNC) {
+        char port[10];
+        snprintf(port, 10, "%d", vm->def.vncActivePort - 5900);
+        if (!((*argv)[++n] = strdup("-vnc")))
+            goto no_memory;
+        if (!((*argv)[++n] = strdup(port)))
+            goto no_memory;
+    } else if (vm->def.graphicsType == QEMUD_GRAPHICS_NONE) {
+        if (!((*argv)[++n] = strdup("-nographic")))
+            goto no_memory;
+    } else {
+        /* SDL is the default. no args needed */
+    }
+
+    (*argv)[++n] = NULL;
+
+    return 0;
+
+ no_memory:
+    if (argv) {
+        for (i = 0 ; i < n ; i++)
+            free(argv[i]);
+        free(argv);
+    }
+    qemudReportError(server, VIR_ERR_NO_MEMORY, "argv");
+    return -1;
+}
+
+/* Free all memory associated with a struct qemud_vm object */
+void qemudFreeVM(struct qemud_vm *vm) {
+    struct qemud_vm_disk_def *disk = vm->def.disks;
+    struct qemud_vm_net_def *net = vm->def.nets;
+
+    while (disk) {
+        struct qemud_vm_disk_def *prev = disk;
+        disk = disk->next;
+        free(prev);
+    }
+    while (net) {
+        struct qemud_vm_net_def *prev = net;
+        net = net->next;
+        free(prev);
+    }
+
+    free(vm);
+}
+
+
+/* Save a guest's config data into a persistent file */
+static int qemudSaveConfig(struct qemud_server *server,
+                           struct qemud_vm *vm) {
+    char *xml;
+    int fd = -1, ret = -1;
+    int towrite;
+
+    if (!(xml = qemudGenerateXML(server, vm))) {
+        return -1;
+    }
+
+    if (qemudEnsureConfigDir(server, server->configDir) < 0) {
+        goto cleanup;
+    }
+
+    if ((fd = open(vm->configFile,
+                   O_WRONLY | O_CREAT | O_TRUNC,
+                   S_IRUSR | S_IWUSR )) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                         "cannot create config file %s",
+                         vm->configFile);
+        goto cleanup;
+    }
+
+    towrite = strlen(xml);
+    if (write(fd, xml, towrite) != towrite) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                         "cannot write config file %s",
+                         vm->configFile);
+        goto cleanup;
+    }
+
+    if (close(fd) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                         "cannot save config file %s",
+                         vm->configFile);
+        goto cleanup;
+    }
+
+    ret = 0;
+
+ cleanup:
+    if (fd != -1)
+        close(fd);
+
+    free(xml);
+
+    return ret;
+}
+
+
+/* Create a qemud_vm instance, populating it based on the data
+ * in a libvirt XML document describing the guest */
+struct qemud_vm *qemudLoadConfigXML(struct qemud_server *server,
+                                    const char *file,
+                                    const char *doc,
+                                    int save) {
+    struct qemud_vm *vm = NULL;
+    xmlDocPtr xml;
+
+    if (!(xml = xmlReadDoc(BAD_CAST doc, file ? file : "domain.xml", NULL,
+                           XML_PARSE_NOENT | XML_PARSE_NONET |
+                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
+        qemudReportError(server, VIR_ERR_XML_ERROR, NULL);
+        return NULL;
+    }
+
+    if (!(vm = calloc(1, sizeof(struct qemud_vm)))) {
+        qemudReportError(server, VIR_ERR_NO_MEMORY, "vm");
+        return NULL;
+    }
+
+    vm->stdout = -1;
+    vm->stderr = -1;
+    vm->monitor = -1;
+    vm->pid = -1;
+    vm->def.id = -1;
+
+    if (qemudParseXML(server, xml, vm) < 0) {
+        xmlFreeDoc(xml);
+        qemudFreeVM(vm);
+        return NULL;
+    }
+    xmlFreeDoc(xml);
+
+    if (qemudFindVMByUUID(server, vm->def.uuid)) {
+        qemudReportError(server, VIR_ERR_DOM_EXIST, vm->def.name);
+        qemudFreeVM(vm);
+        return NULL;
+    }
+
+    if (qemudFindVMByName(server, vm->def.name)) {
+        qemudReportError(server, VIR_ERR_DOM_EXIST, vm->def.name);
+        qemudFreeVM(vm);
+        return NULL;
+    }
+
+    if (file) {
+        strncpy(vm->configFile, file, PATH_MAX);
+        vm->configFile[PATH_MAX-1] = '\0';
+    } else {
+        if (save) {
+            if (qemudMakeConfigPath(server->configDir, vm->def.name, ".xml", vm->configFile, PATH_MAX) < 0) {
+                qemudReportError(server, VIR_ERR_INTERNAL_ERROR,
+                                 "cannot construct config file path");
+                qemudFreeVM(vm);
+                return NULL;
+            }
+
+            if (qemudSaveConfig(server, vm) < 0) {
+                qemudFreeVM(vm);
+                return NULL;
+            }
+        } else {
+            vm->configFile[0] = '\0';
+        }
+    }
+
+    return vm;
+}
+
+
+/* Load a guest from its persistent config file */
+static void qemudLoadConfig(struct qemud_server *server,
+                            const char *file) {
+    FILE *fh;
+    struct stat st;
+    struct qemud_vm *vm;
+    char xml[QEMUD_MAX_XML_LEN];
+    int ret;
+
+    if (!(fh = fopen(file, "r"))) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot open guest config file %s", file);
+        return;
+    }
+
+    if (fstat(fileno(fh), &st) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot stat config file %s", file);
+        goto cleanup;
+    }
+
+    if (st.st_size >= QEMUD_MAX_XML_LEN) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "guest config too large in file %s", file);
+        goto cleanup;
+    }
+
+    if ((ret = fread(xml, st.st_size, 1, fh)) != 1) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot read config file %s", file);
+        goto cleanup;
+    }
+    xml[st.st_size] = '\0';
+
+    if ((vm = qemudLoadConfigXML(server, file, xml, 1))) {
+        vm->next = server->inactivevms;
+        server->inactivevms = vm;
+        server->ninactivevms++;
+    }
+  
+ cleanup:
+    fclose(fh);
+}
+
+
+static
+int qemudScanConfigDir(struct qemud_server *server,
+                       const char *configDir) {
+    DIR *dir;
+    struct dirent *entry;
+
+    if (!(dir = opendir(configDir))) {
+        if (errno == ENOENT)
+            return 0;
+        return -1;
+    }
+
+    while ((entry = readdir(dir))) {
+        char file[PATH_MAX];
+        if (entry->d_name[0] == '.')
+            continue;
+
+        if (qemudMakeConfigPath(configDir, entry->d_name, NULL, file, PATH_MAX) < 0)
+            continue;
+
+        qemudLoadConfig(server, file);
+    }
+
+    closedir(dir);
+ 
+    return 0;
+}
+
+/* Scan for all guest and network config files */
+int qemudScanConfigs(struct qemud_server *server) {
+    return qemudScanConfigDir(server, server->configDir);
+}
+
+/* Simple grow-on-demand string buffer */
+/* XXX re-factor to shared library */
+struct qemudBuffer {
+    char *data;
+    int len;
+    int used;
+};
+
+static
+int qemudBufferAdd(struct qemudBuffer *buf, const char *str) {
+    int need = strlen(str);
+  
+    if ((need+1) > (buf->len-buf->used)) {
+        return -1;
+    }
+  
+    memcpy(buf->data + buf->used, str, need+1);
+    buf->used += need;
+
+    return 0;
+}
+
+
+static
+int qemudBufferPrintf(struct qemudBuffer *buf,
+                      const char *format, ...) {
+    int size, count;
+    va_list locarg, argptr;
+
+    if ((format == NULL) || (buf == NULL)) {
+        return -1;
+    }
+    size = buf->len - buf->used - 1;
+    va_start(argptr, format);
+    va_copy(locarg, argptr);
+
+    if ((count = vsnprintf(&buf->data[buf->used],
+                           size,
+                           format,
+                           locarg)) >= size) {
+        return -1;
+    }
+    va_end(locarg);
+    buf->used += count;
+
+    buf->data[buf->used] = '\0';
+    return 0;
+}
+
+/* Generate an XML document describing the guest's configuration */
+char *qemudGenerateXML(struct qemud_server *server, struct qemud_vm *vm) {
+    struct qemudBuffer buf;
+    unsigned char *uuid;
+    struct qemud_vm_disk_def *disk;
+    struct qemud_vm_net_def *net;
+    const char *type = NULL;
+    int n;
+
+    buf.len = QEMUD_MAX_XML_LEN;
+    buf.used = 0;
+    buf.data = malloc(buf.len);
+
+    switch (vm->def.virtType) {
+    case QEMUD_VIRT_QEMU:
+        type = "qemu";
+        break;
+    case QEMUD_VIRT_KQEMU:
+        type = "kqemu";
+        break;
+    case QEMUD_VIRT_KVM:
+        type = "kvm";
+        break;
+    }
+    if (!type) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "unexpected domain type %d", vm->def.virtType);
+        goto cleanup;
+    }
+
+    if (vm->def.id >= 0) {
+        if (qemudBufferPrintf(&buf, "<domain type='%s' id='%d'>\n", type, vm->def.id) < 0)
+            goto no_memory;
+    } else {
+        if (qemudBufferPrintf(&buf, "<domain type='%s'>\n", type) < 0)
+            goto no_memory;
+    }
+
+    if (qemudBufferPrintf(&buf, "  <name>%s</name>\n", vm->def.name) < 0)
+        goto no_memory;
+
+    uuid = vm->def.uuid;
+    if (qemudBufferPrintf(&buf, "  <uuid>%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x</uuid>\n",
+                          uuid[0], uuid[1], uuid[2], uuid[3],
+                          uuid[4], uuid[5], uuid[6], uuid[7],
+                          uuid[8], uuid[9], uuid[10], uuid[11],
+                          uuid[12], uuid[13], uuid[14], uuid[15]) < 0)
+        goto no_memory;
+    if (qemudBufferPrintf(&buf, "  <memory>%d</memory>\n", vm->def.maxmem) < 0)
+        goto no_memory;
+    if (qemudBufferPrintf(&buf, "  <currentMemory>%d</currentMemory>\n", vm->def.memory) < 0)
+        goto no_memory;
+    if (qemudBufferPrintf(&buf, "  <vcpu>%d</vcpu>\n", vm->def.vcpus) < 0)
+        goto no_memory;
+
+    if (qemudBufferAdd(&buf, "  <os>\n") < 0)
+        goto no_memory;
+
+    if (vm->def.virtType == QEMUD_VIRT_QEMU) {
+        if (qemudBufferPrintf(&buf, "    <type arch='%s' machine='%s'>%s</type>\n",
+                              vm->def.os.arch, vm->def.os.machine, vm->def.os.type) < 0)
+            goto no_memory;
+    } else {
+        if (qemudBufferPrintf(&buf, "    <type>%s</type>\n", vm->def.os.type) < 0)
+            goto no_memory;
+    }
+
+    if (vm->def.os.kernel[0])
+        if (qemudBufferPrintf(&buf, "    <kernel>%s</kernel>\n", vm->def.os.kernel) < 0)
+            goto no_memory;
+    if (vm->def.os.initrd[0])
+        if (qemudBufferPrintf(&buf, "    <initrd>%s</initrd>\n", vm->def.os.initrd) < 0)
+            goto no_memory;
+    if (vm->def.os.cmdline[0])
+        if (qemudBufferPrintf(&buf, "    <cmdline>%s</cmdline>\n", vm->def.os.cmdline) < 0)
+            goto no_memory;
+
+    for (n = 0 ; n < vm->def.os.nBootDevs ; n++) {
+        const char *boottype = "hd";
+        switch (vm->def.os.bootDevs[n]) {
+        case QEMUD_BOOT_FLOPPY:
+            boottype = "fd";
+            break;
+        case QEMUD_BOOT_DISK:
+            boottype = "hd";
+            break;
+        case QEMUD_BOOT_CDROM:
+            boottype = "cdrom";
+            break;
+        case QEMUD_BOOT_NET:
+            boottype = "net";
+            break;
+        }
+        if (qemudBufferPrintf(&buf, "    <boot dev='%s'/>\n", boottype) < 0)
+            goto no_memory;
+    }
+
+    if (qemudBufferAdd(&buf, "  </os>\n") < 0)
+        goto no_memory;
+
+    if (qemudBufferAdd(&buf, "  <devices>\n") < 0)
+        goto no_memory;
+
+    if (qemudBufferPrintf(&buf, "    <emulator>%s</emulator>\n", vm->def.os.binary) < 0)
+        goto no_memory;
+
+    disk = vm->def.disks;
+    while (disk) {
+        const char *types[] = {
+            "block",
+            "file",
+        };
+        const char *typeAttrs[] = {
+            "dev",
+            "file",
+        };
+        const char *devices[] = {
+            "disk",
+            "cdrom",
+            "floppy",
+        };
+        if (qemudBufferPrintf(&buf, "    <disk type='%s' device='%s'>\n",
+                              types[disk->type], devices[disk->device]) < 0)
+            goto no_memory;
+
+        if (qemudBufferPrintf(&buf, "      <source %s='%s'/>\n", typeAttrs[disk->type], disk->src) < 0)
+            goto no_memory;
+
+        if (qemudBufferPrintf(&buf, "      <target dev='%s'/>\n", disk->dst) < 0)
+            goto no_memory;
+
+        if (disk->readonly)
+            if (qemudBufferAdd(&buf, "      <readonly/>\n") < 0)
+                goto no_memory;
+
+        if (qemudBufferPrintf(&buf, "    </disk>\n") < 0)
+            goto no_memory;
+
+        disk = disk->next;
+    }
+
+    net = vm->def.nets;
+    disk = vm->def.disks;
+    while (disk) {
+        const char *types[] = {
+            "user",
+            "tap",
+            "server",
+            "client",
+            "mcast",
+            "vde",
+        };
+        if (qemudBufferPrintf(&buf, "    <interface type='%s'>\n",
+                              types[net->type]) < 0)
+            goto no_memory;
+
+        if (qemudBufferPrintf(&buf, "      <mac address='%02x:%02x:%02x:%02x:%02x:%02x'/>\n",
+                              net->mac[0], net->mac[1], net->mac[2],
+                              net->mac[3], net->mac[4], net->mac[5]) < 0)
+            goto no_memory;
+
+        if (qemudBufferPrintf(&buf, "    </interface>\n") < 0)
+            goto no_memory;
+
+        disk = disk->next;
+    }
+
+    if (vm->def.graphicsType == QEMUD_GRAPHICS_VNC) {
+        if (vm->def.vncPort) {
+            qemudBufferPrintf(&buf, "    <graphics type='vnc' port='%d'/>\n",
+                              vm->def.id == -1 ? vm->def.vncPort : vm->def.vncActivePort);
+        } else {
+            qemudBufferPrintf(&buf, "    <graphics type='vnc'/>\n");
+        }
+    }
+
+    if (qemudBufferAdd(&buf, "  </devices>\n") < 0)
+        goto no_memory;
+
+
+    if (qemudBufferAdd(&buf, "</domain>\n") < 0)
+        goto no_memory;
+
+    return buf.data;
+
+ no_memory:
+    qemudReportError(server, VIR_ERR_NO_MEMORY, "xml");
+ cleanup:
+    free(buf.data);
+    return NULL;
+}
+
+
+int qemudDeleteConfigXML(struct qemud_server *server, struct qemud_vm *vm) {
+    if (!vm->configFile[0]) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "no config file for guest %s", vm->def.name);
+        return -1;
+    }
+
+    if (unlink(vm->configFile) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot remove config for guest %s", vm->def.name);
+        return -1;
+    }
+
+    vm->configFile[0] = '\0';
+
+    return 0;
+}
+
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/config.h libvirt-qemu/qemud/config.h
--- libvirt/qemud/config.h	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/config.h	2007-01-22 15:35:45.000000000 -0500
@@ -0,0 +1,55 @@
+/*
+ * config.h: VM configuration management
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+#ifndef __QEMUD_CONFIG_H
+#define __QEMUD_CONFIG_H
+
+#include "internal.h"
+
+int qemudBuildCommandLine(struct qemud_server *server,
+                          struct qemud_vm *vm,
+                          char ***argv);
+
+void qemudFreeVM(struct qemud_vm *vm);
+struct qemud_vm *qemudLoadConfigXML(struct qemud_server *server,
+                                    const char *file,
+                                    const char *doc,
+                                    int persist);
+int qemudScanConfigs(struct qemud_server *server);
+char *qemudGenerateXML(struct qemud_server *server,
+                       struct qemud_vm *vm);
+
+int qemudDeleteConfigXML(struct qemud_server *server,
+                         struct qemud_vm *vm);
+
+
+#endif
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/dispatch.c libvirt-qemu/qemud/dispatch.c
--- libvirt/qemud/dispatch.c	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/dispatch.c	2007-01-22 15:03:15.000000000 -0500
@@ -0,0 +1,614 @@
+/*
+ * dispatch.c: (De-)marshall wire messages to driver functions.
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <libvirt/virterror.h>
+
+#include "internal.h"
+#include "driver.h"
+#include "dispatch.h"
+
+
+static int qemudDispatchFailure(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                struct qemud_client *client ATTRIBUTE_UNUSED,
+                                struct qemud_packet *out) {
+    out->header.type = qemud_wire_32(QEMUD_PKT_FAILURE);
+    out->header.dataSize = qemud_wire_32(sizeof(out->data.failureReply));
+    out->data.failureReply.code = qemud_wire_32(server->errorCode);
+    strcpy(out->data.failureReply.message, server->errorMessage);
+    return 0;
+}
+
+static int qemudDispatchProtocolHello(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                      struct qemud_client *client ATTRIBUTE_UNUSED,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    int mode, minor, major;
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.protocolHelloRequest))
+        return -1;
+
+    minor = qemud_wire_32(in->data.protocolHelloRequest.version) && 0xff;
+    major = (qemud_wire_32(in->data.protocolHelloRequest.version) >> 16) && 0xff;
+    printf("Hello %d %d\n", minor, major);
+    /* If major is not compatible, reject client altogether */
+    if (major != QEMUD_PROTOCOL_VERSION_MAJOR)
+        return -1;
+
+    /* Force new clients back down to our supported minor */
+    if (minor > QEMUD_PROTOCOL_VERSION_MINOR)
+        minor = QEMUD_PROTOCOL_VERSION_MINOR;
+
+    mode = qemud_wire_32(in->data.setProtocolModeRequest.mode);
+    printf("Client supports modes %d\n", mode);
+    if (client->secure) {
+        if (!(mode & QEMUD_MODE_TLS)) {
+            printf("Deny client request for non-TLS, on secure connection\n");
+            return -1;
+        }
+        client->mode = QEMUD_MODE_TLS;
+        printf("TLS mode\n");
+    } else {
+        if (!(mode & QEMUD_MODE_CLEAR)) {
+            printf("Deny client request for TLS, on insecure connection\n");
+            return -1;
+        }
+        client->mode = QEMUD_MODE_CLEAR;
+        printf("Clear mode\n");
+    }
+
+    out->header.type = qemud_wire_32(QEMUD_PKT_PROTOCOL_HELLO);
+    out->header.dataSize = qemud_wire_32(sizeof(out->data.protocolHelloReply));
+    out->data.protocolHelloReply.version = qemud_wire_32((QEMUD_PROTOCOL_VERSION_MAJOR << 16) +
+                                                         minor);
+    out->data.protocolHelloReply.mode = qemud_wire_32(client->mode);
+
+    return 0;
+}
+
+static int qemudDispatchGetVersion(struct qemud_server *server, struct qemud_client *client,
+                                   struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != 0)
+        return -1;
+
+    int version = qemudGetVersion(server);
+    if (version < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_GET_VERSION;
+        out->header.dataSize = sizeof(out->data.getVersionReply);
+        out->data.getVersionReply.version = version;
+    }
+    return 0;
+}
+
+static int qemudDispatchListDomains(struct qemud_server *server, struct qemud_client *client,
+                                    struct qemud_packet *in, struct qemud_packet *out) {
+    int i, ndomains, domains[QEMUD_MAX_NUM_DOMAINS];
+    if (in->header.dataSize != 0)
+        return -1;
+
+    ndomains = qemudListDomains(server,
+                                domains,
+                                QEMUD_MAX_NUM_DOMAINS);
+    if (ndomains < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_LIST_DOMAINS);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.listDomainsReply));
+        for (i = 0 ; i < ndomains ; i++) {
+            out->data.listDomainsReply.domains[i] = qemud_wire_32(domains[i]);
+        }
+        out->data.listDomainsReply.numDomains = qemud_wire_32(ndomains);
+    }
+    return 0;
+}
+
+static int qemudDispatchNumDomains(struct qemud_server *server, struct qemud_client *client,
+                                   struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != 0)
+        return -1;
+
+    int ndomains = qemudNumDomains(server);
+    if (ndomains < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_NUM_DOMAINS);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.numDomainsReply));
+        out->data.numDomainsReply.numDomains = qemud_wire_32(ndomains);
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainCreate(struct qemud_server *server, struct qemud_client *client,
+                                     struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainCreateRequest))
+        return -1;
+
+    in->data.domainCreateRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
+
+    struct qemud_vm *vm = qemudDomainCreate(server, in->data.domainCreateRequest.xml);
+    if (!vm) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_CREATE);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainCreateReply));
+        out->data.domainCreateReply.id = qemud_wire_32(vm->def.id);
+        memcpy(out->data.domainCreateReply.uuid, vm->def.uuid, QEMUD_UUID_RAW_LEN);
+        strncpy(out->data.domainCreateReply.name, vm->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.domainCreateReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainLookupByID(struct qemud_server *server, struct qemud_client *client,
+                                         struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainLookupByIDRequest))
+        return -1;
+
+    struct qemud_vm *vm = qemudFindVMByID(server, qemud_wire_32(in->data.domainLookupByIDRequest.id));
+    if (!vm) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_LOOKUP_BY_ID);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainLookupByIDReply));
+        memcpy(out->data.domainLookupByIDReply.uuid, vm->def.uuid, QEMUD_UUID_RAW_LEN);
+        strncpy(out->data.domainLookupByIDReply.name, vm->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.domainLookupByIDReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainLookupByUUID(struct qemud_server *server, struct qemud_client *client,
+                                           struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainLookupByUUIDRequest))
+        return -1;
+
+    struct qemud_vm *vm = qemudFindVMByUUID(server, in->data.domainLookupByUUIDRequest.uuid);
+    if (!vm) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_LOOKUP_BY_UUID);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainLookupByUUIDReply));
+        out->data.domainLookupByUUIDReply.id = qemud_wire_32(vm->def.id);
+        strncpy(out->data.domainLookupByUUIDReply.name, vm->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.domainLookupByUUIDReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainLookupByName(struct qemud_server *server, struct qemud_client *client,
+                                           struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainLookupByNameRequest))
+        return -1;
+
+    /* Paranoia NULL termination */
+    in->data.domainLookupByNameRequest.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    struct qemud_vm *vm = qemudFindVMByName(server, in->data.domainLookupByNameRequest.name);
+    if (!vm) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_LOOKUP_BY_NAME);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainLookupByNameReply));
+        out->data.domainLookupByNameReply.id = qemud_wire_32(vm->def.id);
+        memcpy(out->data.domainLookupByNameReply.uuid, vm->def.uuid, QEMUD_UUID_RAW_LEN);
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainSuspend(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainSuspendRequest))
+        return -1;
+
+    int ret = qemudDomainSuspend(server, qemud_wire_32(in->data.domainSuspendRequest.id));
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_SUSPEND);
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainResume(struct qemud_server *server, struct qemud_client *client,
+                                     struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainResumeRequest))
+        return -1;
+
+    int ret = qemudDomainResume(server, qemud_wire_32(in->data.domainResumeRequest.id));
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_RESUME);
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainDestroy(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainDestroyRequest))
+        return -1;
+
+    int ret = qemudDomainDestroy(server, qemud_wire_32(in->data.domainDestroyRequest.id));
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_DESTROY);
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainGetInfo(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    int runstate;
+    unsigned long long cpuTime;
+    unsigned long memory;
+    unsigned long maxmem;
+    unsigned int nrVirtCpu;
+
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainGetInfoRequest))
+        return -1;
+
+    int ret = qemudDomainGetInfo(server, in->data.domainGetInfoRequest.uuid,
+                                 &runstate,
+                                 &cpuTime,
+                                 &maxmem,
+                                 &memory,
+                                 &nrVirtCpu);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_GET_INFO);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainGetInfoReply));
+        out->data.domainGetInfoReply.runstate = qemud_wire_32(runstate);
+        out->data.domainGetInfoReply.cpuTime = qemud_wire_64(cpuTime);
+        out->data.domainGetInfoReply.maxmem = qemud_wire_32(maxmem);
+        out->data.domainGetInfoReply.memory = qemud_wire_32(memory);
+        out->data.domainGetInfoReply.nrVirtCpu = qemud_wire_32(nrVirtCpu);
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainSave(struct qemud_server *server, struct qemud_client *client,
+                                   struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainSaveRequest))
+        return -1;
+
+    /* Paranoia NULL termination */
+    in->data.domainSaveRequest.file[PATH_MAX-1] ='\0';
+
+    int ret = qemudDomainSave(server,
+                              qemud_wire_32(in->data.domainSaveRequest.id),
+                              in->data.domainSaveRequest.file);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_SAVE);
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainRestore(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainRestoreRequest))
+        return -1;
+
+    /* Paranoia null termination */
+    in->data.domainRestoreRequest.file[PATH_MAX-1] ='\0';
+
+    int id = qemudDomainRestore(server, in->data.domainRestoreRequest.file);
+    if (id < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_RESTORE);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainRestoreReply));
+        out->data.domainRestoreReply.id = qemud_wire_32(id);
+    }
+    return 0;
+}
+
+static int qemudDispatchDumpXML(struct qemud_server *server, struct qemud_client *client,
+                                struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainDumpXMLRequest))
+        return -1;
+
+    int ret = qemudDomainDumpXML(server,
+                                 in->data.domainDumpXMLRequest.uuid,
+                                 out->data.domainDumpXMLReply.xml, QEMUD_MAX_XML_LEN);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DUMP_XML);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainDumpXMLReply));
+    }
+    return 0;
+}
+
+static int qemudDispatchListDefinedDomains(struct qemud_server *server, struct qemud_client *client,
+                                           struct qemud_packet *in, struct qemud_packet *out) {
+    char **names;
+    int i;
+    if (in->header.dataSize != 0)
+        return -1;
+
+    if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_DOMAINS)))
+        return -1;
+
+    for (i = 0 ; i < QEMUD_MAX_NUM_DOMAINS ; i++) {
+        names[i] = out->data.listDefinedDomainsReply.domains[i];
+    }
+
+    int ndomains = qemudListDefinedDomains(server,
+                                           names,
+                                           QEMUD_MAX_NUM_DOMAINS);
+    free(names);
+    if (ndomains < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_LIST_DEFINED_DOMAINS);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.listDefinedDomainsReply));
+        out->data.listDefinedDomainsReply.numDomains = qemud_wire_32(ndomains);
+    }
+    return 0;
+}
+
+static int qemudDispatchNumDefinedDomains(struct qemud_server *server, struct qemud_client *client,
+                                          struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != 0)
+        return -1;
+
+    int ndomains = qemudNumDefinedDomains(server);
+    if (ndomains < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_NUM_DEFINED_DOMAINS);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.numDefinedDomainsReply));
+        out->data.numDefinedDomainsReply.numDomains = qemud_wire_32(ndomains);
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainStart(struct qemud_server *server, struct qemud_client *client,
+                                    struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainStartRequest))
+        return -1;
+
+    struct qemud_vm *vm = qemudFindVMByUUID(server, in->data.domainStartRequest.uuid);
+    if (!vm || qemudDomainStart(server, vm) < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_START);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainStartReply));
+        out->data.domainStartReply.id = qemud_wire_32(vm->def.id);
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainDefine(struct qemud_server *server, struct qemud_client *client,
+                                     struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainDefineRequest))
+        return -1;
+
+    in->data.domainDefineRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
+
+    struct qemud_vm *vm = qemudDomainDefine(server, in->data.domainDefineRequest.xml);
+    if (!vm) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_DEFINE);
+        out->header.dataSize = qemud_wire_32(sizeof(out->data.domainDefineReply));
+        memcpy(out->data.domainDefineReply.uuid, vm->def.uuid, QEMUD_UUID_RAW_LEN);
+        strncpy(out->data.domainDefineReply.name, vm->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.domainDefineReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchDomainUndefine(struct qemud_server *server, struct qemud_client *client,
+                                       struct qemud_packet *in, struct qemud_packet *out) {
+    if (qemud_wire_32(in->header.dataSize) != sizeof(in->data.domainUndefineRequest))
+        return -1;
+
+    int ret = qemudDomainUndefine(server, in->data.domainUndefineRequest.uuid);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = qemud_wire_32(QEMUD_PKT_DOMAIN_UNDEFINE);
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+
+typedef int (*clientFunc)(struct qemud_server *server, struct qemud_client *client,
+                          struct qemud_packet *in, struct qemud_packet *out);
+
+
+/* One per message type recorded in qemud_packet_type enum */
+
+/* In initial state, only allow the hello message */
+clientFunc funcsInit[QEMUD_PKT_MAX] = {
+    NULL, /* FAILURE code */
+    qemudDispatchProtocolHello,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+};
+
+clientFunc funcsTransmitRW[QEMUD_PKT_MAX] = {
+    NULL, /* FAILURE code */
+    NULL,
+    qemudDispatchGetVersion,
+    qemudDispatchListDomains,
+    qemudDispatchNumDomains,
+    qemudDispatchDomainCreate,
+    qemudDispatchDomainLookupByID,
+    qemudDispatchDomainLookupByUUID,
+    qemudDispatchDomainLookupByName,
+    qemudDispatchDomainSuspend,
+    qemudDispatchDomainResume,
+    qemudDispatchDomainDestroy,
+    qemudDispatchDomainGetInfo,
+    qemudDispatchDomainSave,
+    qemudDispatchDomainRestore,
+    qemudDispatchDumpXML,
+    qemudDispatchListDefinedDomains,
+    qemudDispatchNumDefinedDomains,
+    qemudDispatchDomainStart,
+    qemudDispatchDomainDefine,
+    qemudDispatchDomainUndefine
+};
+
+clientFunc funcsTransmitRO[QEMUD_PKT_MAX] = {
+    NULL, /* FAILURE code */
+    NULL,
+    NULL,
+    qemudDispatchListDomains,
+    qemudDispatchNumDomains,
+    NULL,
+    qemudDispatchDomainLookupByID,
+    qemudDispatchDomainLookupByUUID,
+    qemudDispatchDomainLookupByName,
+    NULL,
+    NULL,
+    NULL,
+    qemudDispatchDomainGetInfo,
+    NULL,
+    NULL,
+    qemudDispatchDumpXML,
+    qemudDispatchListDefinedDomains,
+    qemudDispatchNumDefinedDomains,
+    NULL,
+    NULL,
+    NULL,
+};
+
+/*
+ * Returns -1 if message processing failed - eg, illegal header sizes,
+ * a memory error dealing with stuff, or any other bad stuff which
+ * should trigger immediate client disconnect
+ *
+ * Return 0 if message processing succeeded. NB, this does not mean
+ * the operation itself succeeded - success/failure of the operation
+ * is recorded by the return message type - either it matches the
+ * incoming type, or is QEMUD_PKT_FAILURE
+ */
+int qemudDispatch(struct qemud_server *server, struct qemud_client *client,
+                  struct qemud_packet *in, struct qemud_packet *out) {
+    clientFunc *funcs;
+    unsigned int type = qemud_wire_32(in->header.type);
+    printf("> Dispatching request %d readonly ? %d\n", type, client->readonly);
+
+    server->errorCode = 0;
+    server->errorMessage[0] = '\0';
+
+    memset(out, 0, sizeof(struct qemud_packet));
+
+    if (type >= QEMUD_PKT_MAX) {
+        printf("Illegal request type\n");
+        return -1;
+    }
+
+    if (type == QEMUD_PKT_FAILURE) {
+        printf("Illegal request type\n");
+        return -1;
+    }
+
+    if (client->state == QEMUD_CLIENT_INIT) {
+        funcs = funcsInit;
+    } else if (client->state == QEMUD_CLIENT_TRANSMIT) {
+        if (client->readonly)
+            funcs = funcsTransmitRO;
+        else
+            funcs = funcsTransmitRW;
+    } else {
+        return -1;
+    }
+
+    if (!funcs[type]) {
+        printf("Illegal operation requested\n");
+        qemudReportError(server, VIR_ERR_OPERATION_DENIED, NULL);
+        qemudDispatchFailure(server, client, out);
+    } else {
+        if ((funcs[type])(server, client, in, out) < 0) {
+            printf("Dispatch failed\n");
+            return -1;
+        }
+    }
+
+    printf("< Returning reply %d (%d bytes)\n",
+           qemud_wire_32(out->header.type),
+           qemud_wire_32(out->header.dataSize));
+
+    return 0;
+}
+
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/dispatch.h libvirt-qemu/qemud/dispatch.h
--- libvirt/qemud/dispatch.h	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/dispatch.h	2007-01-04 08:37:59.000000000 -0500
@@ -0,0 +1,43 @@
+/*
+ * dispatch.h: (De-)marshall wire messages to driver functions.
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+
+#ifndef QEMUD_DISPATCH_H
+#define QEMUD_DISPATCH_H
+
+#include "internal.h"
+
+
+int qemudDispatch(struct qemud_server *server, struct qemud_client *client,
+                  struct qemud_packet *in, struct qemud_packet *out);
+
+#endif
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/driver.c libvirt-qemu/qemud/driver.c
--- libvirt/qemud/driver.c	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/driver.c	2007-01-10 11:25:51.000000000 -0500
@@ -0,0 +1,361 @@
+/*
+ * driver.c: core driver methods for managing qemu guests
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+#include <sys/types.h>
+#include <dirent.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include <libvirt/virterror.h>
+
+#include "internal.h"
+#include "driver.h"
+#include "config.h"
+
+void qemudReportError(struct qemud_server *server,
+                      int code, const char *fmt, ...) {
+    va_list args;
+    server->errorCode = code;
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(server->errorMessage, QEMUD_MAX_ERROR_LEN-1, fmt, args);
+        va_end(args);
+    } else {
+        server->errorMessage[0] = '\0';
+    }
+}
+
+struct qemud_vm *qemudFindVMByID(const struct qemud_server *server, int id) {
+    struct qemud_vm *vm = server->activevms;
+
+    while (vm) {
+        if (vm->def.id == id)
+            return vm;
+        vm = vm->next;
+    }
+
+    return NULL;
+}
+
+struct qemud_vm *qemudFindVMByUUID(const struct qemud_server *server,
+                                   const unsigned char *uuid) {
+    struct qemud_vm *vm = server->activevms;
+
+    while (vm) {
+        if (!memcmp(vm->def.uuid, uuid, QEMUD_UUID_RAW_LEN))
+            return vm;
+        vm = vm->next;
+    }
+
+    vm = server->inactivevms;
+    while (vm) {
+        if (!memcmp(vm->def.uuid, uuid, QEMUD_UUID_RAW_LEN))
+            return vm;
+        vm = vm->next;
+    }
+
+    return NULL;
+}
+
+struct qemud_vm *qemudFindVMByName(const struct qemud_server *server,
+                                   const char *name) {
+    struct qemud_vm *vm = server->activevms;
+
+    while (vm) {
+        if (!strcmp(vm->def.name, name))
+            return vm;
+        vm = vm->next;
+    }
+
+    vm = server->inactivevms;
+    while (vm) {
+        if (!strcmp(vm->def.name, name))
+            return vm;
+        vm = vm->next;
+    }
+
+    return NULL;
+}
+
+int qemudGetVersion(struct qemud_server *server) {
+    return server->qemuVersion;
+}
+
+int qemudListDomains(struct qemud_server *server, int *ids, int nids) {
+    struct qemud_vm *vm = server->activevms;
+    int got = 0;
+    while (vm && got < nids) {
+        ids[got] = vm->def.id;
+        vm = vm->next;
+        got++;
+    }
+    return got;
+}
+int qemudNumDomains(struct qemud_server *server) {
+    return server->nactivevms;
+}
+struct qemud_vm *qemudDomainCreate(struct qemud_server *server, const char *xml) {
+    struct qemud_vm *vm;
+
+    if (!(vm = qemudLoadConfigXML(server, NULL, xml, 0))) {
+        return NULL;
+    }
+
+    if (qemudStartVMDaemon(server, vm) < 0) {
+        qemudFreeVM(vm);
+        return NULL;
+    }
+
+    vm->next = server->activevms;
+    server->activevms = vm;
+    server->nactivevms++;
+    server->nvmfds += 2;
+
+    return vm;
+}
+
+
+int qemudDomainSuspend(struct qemud_server *server, int id) {
+    struct qemud_vm *vm = qemudFindVMByID(server, id);
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+        return -1;
+    }
+    if (vm->pid == -1) {
+        qemudReportError(server, VIR_ERR_OPERATION_FAILED, "domain is not running");
+        return -1;
+    }
+    qemudReportError(server, VIR_ERR_OPERATION_FAILED, "suspend is not supported");
+    return -1;
+}
+
+
+int qemudDomainResume(struct qemud_server *server, int id) {
+    struct qemud_vm *vm = qemudFindVMByID(server, id);
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+        return -1;
+    }
+    if (vm->pid == -1) {
+        qemudReportError(server, VIR_ERR_OPERATION_FAILED, "domain is not running");
+        return -1;
+    }
+    qemudReportError(server, VIR_ERR_OPERATION_FAILED, "resume is not supported");
+    return -1;
+}
+
+
+int qemudDomainDestroy(struct qemud_server *server, int id) {
+    struct qemud_vm *vm = qemudFindVMByID(server, id);
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+        return -1;
+    }
+    if (vm->pid == -1) {
+        qemudReportError(server, VIR_ERR_OPERATION_FAILED, "domain is not running");
+        return -1;
+    }
+
+    if (qemudShutdownVMDaemon(server, vm) < 0)
+        return -1;
+    return 0;
+}
+
+
+int qemudDomainGetInfo(struct qemud_server *server, const unsigned char *uuid,
+                       int *runstate,
+                       unsigned long long *cputime,
+                       unsigned long *maxmem,
+                       unsigned long *memory,
+                       unsigned int *nrVirtCpu) {
+    struct qemud_vm *vm = qemudFindVMByUUID(server, uuid);
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+        return -1;
+    }
+
+    if (vm->pid == -1) {
+        *runstate = QEMUD_STATE_STOPPED;
+    } else {
+        /* XXX in future need to add PAUSED */
+        *runstate = QEMUD_STATE_RUNNING;
+    }
+
+    *cputime = 0;
+    *maxmem = vm->def.maxmem;
+    *memory = vm->def.memory;
+    *nrVirtCpu = vm->def.vcpus;
+    return 0;
+}
+
+
+int qemudDomainSave(struct qemud_server *server, int id,
+                    const char *path ATTRIBUTE_UNUSED) {
+    struct qemud_vm *vm = qemudFindVMByID(server, id);
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching id %d", id);
+        return -1;
+    }
+    if (vm->pid == -1) {
+        qemudReportError(server, VIR_ERR_OPERATION_FAILED, "domain is not running");
+        return -1;
+    }
+    qemudReportError(server, VIR_ERR_OPERATION_FAILED, "save is not supported");
+    return -1;
+}
+
+
+int qemudDomainRestore(struct qemud_server *server,
+                       const char *path ATTRIBUTE_UNUSED) {
+    qemudReportError(server, VIR_ERR_OPERATION_FAILED, "restore is not supported");
+    return -1;
+}
+
+
+int qemudDomainDumpXML(struct qemud_server *server, const unsigned char *uuid, char *xml, int xmllen) {
+    struct qemud_vm *vm = qemudFindVMByUUID(server, uuid);
+    char *vmxml;
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+        return -1;
+    }
+
+    vmxml = qemudGenerateXML(server, vm);
+    if (!vmxml)
+        return -1;
+
+    strncpy(xml, vmxml, xmllen);
+    xml[xmllen-1] = '\0';
+
+    return 0;
+}
+
+
+int qemudListDefinedDomains(struct qemud_server *server, char *const*names, int nnames) {
+    struct qemud_vm *vm = server->inactivevms;
+    int got = 0;
+    while (vm && got < nnames) {
+        strncpy(names[got], vm->def.name, QEMUD_MAX_NAME_LEN-1);
+        names[got][QEMUD_MAX_NAME_LEN-1] = '\0';
+        vm = vm->next;
+        got++;
+    }
+    return got;
+}
+
+
+int qemudNumDefinedDomains(struct qemud_server *server) {
+    return server->ninactivevms;
+}
+
+
+int qemudDomainStart(struct qemud_server *server, struct qemud_vm *vm) {
+    struct qemud_vm *prev = NULL, *curr = server->inactivevms;
+    if (qemudStartVMDaemon(server, vm) < 0) {
+        return 1;
+    }
+
+    while (curr) {
+        if (curr == vm) {
+            if (prev)
+                prev->next = curr->next;
+            else
+                server->inactivevms = curr->next;
+            server->ninactivevms--;
+            break;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+
+    vm->next = server->activevms;
+    server->activevms = vm;
+    server->nactivevms++;
+    server->nvmfds += 2;
+
+    return 0;
+}
+
+
+struct qemud_vm *qemudDomainDefine(struct qemud_server *server, const char *xml) {
+    struct qemud_vm *vm;
+
+    if (!(vm = qemudLoadConfigXML(server, NULL, xml, 1))) {
+        return NULL;
+    }
+
+    vm->next = server->inactivevms;
+    server->inactivevms = vm;
+    server->ninactivevms++;
+
+    return vm;
+}
+
+int qemudDomainUndefine(struct qemud_server *server, const unsigned char *uuid) {
+    struct qemud_vm *vm = qemudFindVMByUUID(server, uuid);
+    struct qemud_vm *prev = NULL, *curr = server->inactivevms;
+
+    if (!vm) {
+        qemudReportError(server, VIR_ERR_INVALID_DOMAIN, "no domain with matching uuid");
+        return -1;
+    }
+
+    if (vm->pid != -1) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot delete active domain");
+        return -1;
+    }
+
+    if (qemudDeleteConfigXML(server, vm) < 0)
+        return -1;
+
+    while (curr) {
+        if (curr == vm) {
+            if (prev) {
+                prev->next = curr->next;
+            } else {
+                server->inactivevms = curr->next;
+            }
+            server->ninactivevms--;
+            break;
+        }
+
+        prev = curr;
+        curr = curr->next;
+    }
+
+    qemudFreeVM(vm);
+
+    return 0;
+}
+
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/driver.h libvirt-qemu/qemud/driver.h
--- libvirt/qemud/driver.h	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/driver.h	2007-01-10 11:26:53.000000000 -0500
@@ -0,0 +1,90 @@
+/*
+ * driver.h: core driver methods for managing qemu guests
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+
+#ifndef QEMUD_DRIVER_H
+#define QEMUD_DRIVER_H
+
+#include "internal.h"
+
+void qemudReportError(struct qemud_server *server,
+                      int code, const char *fmt, ...);
+
+struct qemud_vm *qemudFindVMByID(const struct qemud_server *server,
+                                 int id);
+struct qemud_vm *qemudFindVMByUUID(const struct qemud_server *server,
+                                   const unsigned char *uuid);
+struct qemud_vm *qemudFindVMByName(const struct qemud_server *server,
+                                   const char *name);
+
+int qemudGetVersion(struct qemud_server *server);
+int qemudListDomains(struct qemud_server *server,
+                     int *ids,
+                     int nids);
+int qemudNumDomains(struct qemud_server *server);
+struct qemud_vm *qemudDomainCreate(struct qemud_server *server,
+                                   const char *xml);
+int qemudDomainSuspend(struct qemud_server *server,
+                       int id);
+int qemudDomainResume(struct qemud_server *server,
+                      int id);
+int qemudDomainDestroy(struct qemud_server *server,
+                       int id);
+int qemudDomainGetInfo(struct qemud_server *server,
+                       const unsigned char *uuid,
+                       int *runstate,
+                       unsigned long long *cputime,
+                       unsigned long *maxmem,
+                       unsigned long *memory,
+                       unsigned int *nrVirtCpu);
+int qemudDomainSave(struct qemud_server *server,
+                    int id,
+                    const char *path);
+int qemudDomainRestore(struct qemud_server *server,
+                       const char *path);
+int qemudDomainDumpXML(struct qemud_server *server,
+                       const unsigned char *uuid,
+                       char *xml,
+                       int xmllen);
+int qemudListDefinedDomains(struct qemud_server *server,
+                            char *const*names,
+                            int nnames);
+int qemudNumDefinedDomains(struct qemud_server *server);
+int qemudDomainStart(struct qemud_server *server,
+                     struct qemud_vm *vm);
+struct qemud_vm *qemudDomainDefine(struct qemud_server *server,
+                                   const char *xml);
+int qemudDomainUndefine(struct qemud_server *server,
+                        const unsigned char *uuid);
+
+#endif
+
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/internal.h libvirt-qemu/qemud/internal.h
--- libvirt/qemud/internal.h	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/internal.h	2007-01-10 13:53:03.000000000 -0500
@@ -0,0 +1,259 @@
+/*
+ * internal.h: daemon data structure definitions
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+
+#ifndef QEMUD_INTERNAL_H__
+#define QEMUD_INTERNAL_H__
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <gnutls/gnutls.h>
+
+#include "protocol.h"
+
+#ifdef __GNUC__
+#ifdef HAVE_ANSIDECL_H
+#include <ansidecl.h>
+#endif
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED __attribute__((unused))
+#endif
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+
+
+#define UUID_LEN 16
+
+/* Different types of QEMU acceleration possible */
+enum qemud_vm_virt_type {
+    QEMUD_VIRT_QEMU,
+    QEMUD_VIRT_KQEMU,
+    QEMUD_VIRT_KVM,
+};
+
+
+/* Two types of disk backends */
+enum qemud_vm_disk_type {
+    QEMUD_DISK_BLOCK,
+    QEMUD_DISK_FILE
+};
+
+/* Three types of disk frontend */
+enum qemud_vm_disk_device {
+    QEMUD_DISK_DISK,
+    QEMUD_DISK_CDROM,
+    QEMUD_DISK_FLOPPY,
+};
+
+/* Stores the virtual disk configuration */
+struct qemud_vm_disk_def {
+    int type;
+    int device;
+    char src[PATH_MAX];
+    char dst[NAME_MAX];
+    int readonly;
+
+    struct qemud_vm_disk_def *next;
+};
+
+#define QEMUD_MAC_ADDRESS_LEN 6
+#define QEMUD_OS_TYPE_MAX_LEN 10
+#define QEMUD_OS_ARCH_MAX_LEN 10
+#define QEMUD_OS_MACHINE_MAX_LEN 10
+
+/* 5 different types of networking config */
+enum qemud_vm_net_type {
+    QEMUD_NET_USER,
+    QEMUD_NET_TAP,
+    QEMUD_NET_SERVER,
+    QEMUD_NET_CLIENT,
+    QEMUD_NET_MCAST,
+    /*  QEMUD_NET_VDE*/
+};
+
+/* Stores the virtual network interface configuration */
+struct qemud_vm_net_def {
+    int type;
+    int vlan;
+    unsigned char mac[QEMUD_MAC_ADDRESS_LEN];
+    union {
+        struct {
+            char ifname[NAME_MAX];
+            char script[PATH_MAX];
+        } tap;
+        struct {
+            struct sockaddr_in listen;
+            int port;
+        } server;
+        struct {
+            struct sockaddr_in connect;
+            int port;
+        } client;
+        struct {
+            struct sockaddr_in group;
+            int port;
+        } mcast;
+        struct {
+            char vlan[PATH_MAX];
+        } vde;
+    } dst;
+
+    struct qemud_vm_net_def *next;
+};
+
+#define QEMUD_MAX_BOOT_DEVS 4
+
+/* 3 possible boot devices */
+enum qemud_vm_boot_order {
+    QEMUD_BOOT_FLOPPY,
+    QEMUD_BOOT_CDROM,
+    QEMUD_BOOT_DISK,
+    QEMUD_BOOT_NET,
+};
+/* 3 possible graphics console modes */
+enum qemud_vm_grapics_type {
+    QEMUD_GRAPHICS_NONE,
+    QEMUD_GRAPHICS_SDL,
+    QEMUD_GRAPHICS_VNC,
+};
+
+/* Operating system configuration data & machine / arch */
+struct qemud_vm_os_def {
+    char type[QEMUD_OS_TYPE_MAX_LEN];
+    char arch[QEMUD_OS_ARCH_MAX_LEN];
+    char machine[QEMUD_OS_MACHINE_MAX_LEN];
+    int nBootDevs;
+    int bootDevs[QEMUD_MAX_BOOT_DEVS];
+    char kernel[PATH_MAX];
+    char initrd[PATH_MAX];
+    char cmdline[PATH_MAX];
+    char binary[PATH_MAX];
+};
+
+/* Guest VM main configuration */
+struct qemud_vm_def {
+    int id;
+    int virtType;
+    unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    char name[QEMUD_MAX_NAME_LEN];
+
+    int memory;
+    int maxmem;
+    int vcpus;
+
+    struct qemud_vm_os_def os;
+
+    int graphicsType;
+    int vncPort;
+    int vncActivePort;
+
+    int ndisks;
+    struct qemud_vm_disk_def *disks;
+
+    int nnets;
+    struct qemud_vm_net_def *nets;
+};
+
+/* Guest VM runtime state */
+struct qemud_vm {
+    int stdout;
+    int stderr;
+    int monitor;
+    int pid;
+
+    char configFile[PATH_MAX];
+
+    struct qemud_vm_def def;
+
+    struct qemud_vm *next;
+};
+
+enum qemud_client_state {
+    QEMUD_CLIENT_INIT = 0,
+    QEMUD_CLIENT_POSTINIT,
+    QEMUD_CLIENT_HANDSHAKE,
+    QEMUD_CLIENT_TRANSMIT,
+};
+
+/* Stores the per-client connection state */
+struct qemud_client {
+    int fd;
+    int readonly;
+    int secure; /* Whether it came from secure line */
+    int certAuth;
+    int mode; /* Requested data mode */
+    int state; /* Current state */
+    gnutls_session_t session;
+    struct qemud_packet incoming;
+    unsigned int incomingReceived;
+    struct qemud_packet outgoing;
+    unsigned int outgoingSent;
+    int tx;
+    struct qemud_client *next;
+};
+
+
+struct qemud_socket {
+    int fd;
+    int readonly;
+    int secure;
+    int clientCertAuth;
+    struct qemud_socket *next;
+};
+
+/* Main server state */
+struct qemud_server {
+    int nsockets;
+    struct qemud_socket *sockets;
+    int qemuVersion;
+    int nclients;
+    struct qemud_client *clients;
+    int nvmfds;
+    int nactivevms;
+    struct qemud_vm *activevms;
+    int ninactivevms;
+    struct qemud_vm *inactivevms;
+    int nextvmid;
+    char configDir[PATH_MAX];
+    char errorMessage[QEMUD_MAX_ERROR_LEN];
+    int errorCode;
+};
+
+int qemudStartVMDaemon(struct qemud_server *server,
+                       struct qemud_vm *vm);
+
+int qemudShutdownVMDaemon(struct qemud_server *server,
+                          struct qemud_vm *vm);
+
+
+#endif
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/Makefile.am libvirt-qemu/qemud/Makefile.am
--- libvirt/qemud/Makefile.am	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/Makefile.am	2007-01-22 15:20:36.000000000 -0500
@@ -0,0 +1,17 @@
+## Process this file with automake to produce Makefile.in
+
+INCLUDES = @LIBXML_CFLAGS@
+
+libexec_PROGRAMS = libvirt_qemud
+
+libvirt_qemud_SOURCES = qemud.c internal.h protocol.h \
+                driver.c driver.h \
+                dispatch.c dispatch.h \
+                config.c config.h
+libvirt_qemud_CFLAGS = -D_XOPEN_SOURCE=600 -D_XOPEN_SOURCE_EXTENDED=1 -D_POSIX_C_SOURCE=199506L \
+        -I$(top_srcdir)/include -I$(top_builddir)/include $(LIBXML_CFLAGS) \
+        -Werror -Wall -Wextra $(shell pkg-config --cflags gnutls)
+libvirt_qemud_LDFLAGS = $(LIBXML_LIBS) $(shell pkg-config --libs gnutls)
+libvirt_qemud_DEPENDENCIES =
+libvirt_qemud_LDADD =
+
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/protocol.h libvirt-qemu/qemud/protocol.h
--- libvirt/qemud/protocol.h	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/protocol.h	2007-01-22 14:40:19.000000000 -0500
@@ -0,0 +1,244 @@
+/*
+ * protocol.h: wire protocol message format & data structures
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+
+#ifndef QEMUD_PROTOCOL_H__
+#define QEMUD_PROTOCOL_H__
+
+#include <stdint.h>
+#include <byteswap.h>
+#include <endian.h>
+
+/* List of different packet types which can be sent */
+enum {
+    QEMUD_PKT_FAILURE = 0,
+    QEMUD_PKT_PROTOCOL_HELLO,
+    QEMUD_PKT_GET_VERSION,
+    QEMUD_PKT_LIST_DOMAINS,
+    QEMUD_PKT_NUM_DOMAINS,
+    QEMUD_PKT_DOMAIN_CREATE,
+    QEMUD_PKT_DOMAIN_LOOKUP_BY_ID,
+    QEMUD_PKT_DOMAIN_LOOKUP_BY_UUID,
+    QEMUD_PKT_DOMAIN_LOOKUP_BY_NAME,
+    QEMUD_PKT_DOMAIN_SUSPEND,
+    QEMUD_PKT_DOMAIN_RESUME,
+    QEMUD_PKT_DOMAIN_DESTROY,
+    QEMUD_PKT_DOMAIN_GET_INFO,
+    QEMUD_PKT_DOMAIN_SAVE,
+    QEMUD_PKT_DOMAIN_RESTORE,
+    QEMUD_PKT_DUMP_XML,
+    QEMUD_PKT_LIST_DEFINED_DOMAINS,
+    QEMUD_PKT_NUM_DEFINED_DOMAINS,
+    QEMUD_PKT_DOMAIN_START,
+    QEMUD_PKT_DOMAIN_DEFINE,
+    QEMUD_PKT_DOMAIN_UNDEFINE,
+
+    QEMUD_PKT_MAX,
+} qemud_packet_type;
+
+
+#define QEMUD_DEFAULT_PORT_STR "56565"
+
+#define QEMUD_PROTOCOL_VERSION_MAJOR 1
+#define QEMUD_PROTOCOL_VERSION_MINOR 0
+
+#define QEMUD_UUID_RAW_LEN 16
+#define QEMUD_MAX_NAME_LEN 50
+#define QEMUD_MAX_XML_LEN 4096
+#define QEMUD_MAX_NUM_DOMAINS 100
+#define QEMUD_MAX_ERROR_LEN 1024
+
+/* Possible guest VM states */
+enum {
+    QEMUD_STATE_RUNNING = 1,
+    QEMUD_STATE_PAUSED,
+    QEMUD_STATE_STOPPED,
+} qemud_domain_runstate;
+
+enum {
+    QEMUD_MODE_CLEAR = 1,
+    QEMUD_MODE_TLS = 2,
+} qemud_protocol_mode;
+
+
+/* The regular hton stuff is a) not size specific b) not extended to int64_t :-( */
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define qemud_wire_32(x) (x)
+#define qemud_wire_64(x) (x)
+#else
+#define qemud_wire_32(x) bswap_32(x)
+#define qemud_wire_64(x) bswap_64(x)
+#endif
+
+/* Each packets has at least a fixed size header.
+ *
+ * All data required to be network byte order
+ * to 32-bit boundaries */
+struct qemud_packet_header {
+    uint32_t type;
+    /* Stores the size of the data struct matching
+       the type arg.
+       Must be <= sizeof(union qemudPacketData) */
+    uint32_t dataSize;
+};
+
+/* Most packets also have some message specific data
+ * All data required to be network byte order, padded
+ * to 32-bit boundaries */
+union qemud_packet_data {
+    struct {
+        int32_t code;
+        char message[QEMUD_MAX_ERROR_LEN];
+    } failureReply;
+    struct {
+        int32_t version;
+        int32_t modes;
+    } protocolHelloRequest;
+    struct {
+        int32_t version;
+        int32_t mode;
+    } protocolHelloReply;
+    struct {
+        int32_t version;
+        int32_t mode;
+    } setProtocolModeRequest;
+    struct {
+        int32_t version;
+    } getVersionReply;
+    struct {
+        int32_t numDomains;
+        int32_t domains[QEMUD_MAX_NUM_DOMAINS];
+    } listDomainsReply;
+    struct {
+        int32_t numDomains;
+    } numDomainsReply;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } domainCreateRequest;
+    struct {
+        int32_t id;
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+        char name[QEMUD_MAX_NAME_LEN];
+    } domainCreateReply;
+    struct {
+        int32_t id;
+    } domainLookupByIDRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+        char name[QEMUD_MAX_NAME_LEN];
+    } domainLookupByIDReply;
+    struct {
+        char name[QEMUD_MAX_NAME_LEN];
+    } domainLookupByNameRequest;
+    struct {
+        int32_t id;
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainLookupByNameReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainLookupByUUIDRequest;
+    struct {
+        int32_t id;
+        char name[QEMUD_MAX_NAME_LEN];
+    } domainLookupByUUIDReply;
+    struct {
+        int32_t id;
+    } domainSuspendRequest;
+    struct {
+        int32_t id;
+    } domainResumeRequest;
+    struct {
+    } domainResumeReply;
+    struct {
+        int32_t id;
+    } domainDestroyRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainGetInfoRequest;
+    struct {
+        uint64_t cpuTime;
+        int32_t runstate;
+        uint32_t memory;
+        uint32_t maxmem;
+        uint32_t nrVirtCpu;
+    } domainGetInfoReply;
+    struct {
+        int32_t id;
+        char file[PATH_MAX];
+    } domainSaveRequest;
+    struct {
+        char file[PATH_MAX];
+    } domainRestoreRequest;
+    struct {
+        int32_t id;
+    } domainRestoreReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainDumpXMLRequest;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } domainDumpXMLReply;
+    struct {
+        int32_t numDomains;
+        char domains[QEMUD_MAX_NUM_DOMAINS][QEMUD_MAX_NAME_LEN];
+    } listDefinedDomainsReply;
+    struct {
+        int32_t numDomains;
+    } numDefinedDomainsReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainStartRequest;
+    struct {
+        int32_t id;
+    } domainStartReply;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } domainDefineRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+        char name[QEMUD_MAX_NAME_LEN];
+    } domainDefineReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } domainUndefineRequest;
+};
+
+/* Each packet has header & data */
+struct qemud_packet {
+    struct qemud_packet_header header;
+    union qemud_packet_data data;
+};
+
+
+#endif
+
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff --exclude .deps --exclude CVS --exclude Makefile.in -ruNp libvirt/qemud/qemud.c libvirt-qemu/qemud/qemud.c
--- libvirt/qemud/qemud.c	1969-12-31 19:00:00.000000000 -0500
+++ libvirt-qemu/qemud/qemud.c	2007-01-22 15:35:45.000000000 -0500
@@ -0,0 +1,1288 @@
+/*
+ * qemud.c: daemon start of day, guest process & i/o management
+ *
+ * Copyright (C) 2006, 2007 Red Hat, Inc.
+ * Copyright (C) 2006 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange@redhat.com>
+ */
+
+#include <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 <string.h>
+#include <errno.h>
+#include <getopt.h>
+
+#include <libvirt/virterror.h>
+
+#include <gnutls/x509.h>
+
+#include "internal.h"
+#include "dispatch.h"
+#include "driver.h"
+#include "config.h"
+
+static void reapchild(int sig ATTRIBUTE_UNUSED) {
+    /* We explicitly waitpid the child later */
+}
+static int qemudSetCloseExec(int fd) {
+    int flags;
+    if ((flags = fcntl(fd, F_GETFD)) < 0) {
+        return -1;
+    }
+    flags |= FD_CLOEXEC;
+    if ((fcntl(fd, F_SETFD, flags)) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+
+static int qemudSetNonBlock(int fd) {
+    int flags;
+    if ((flags = fcntl(fd, F_GETFL)) < 0) {
+        return -1;
+    }
+    flags |= O_NONBLOCK;
+    if ((fcntl(fd, F_SETFL, flags)) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static int qemudGoDaemon(void) {
+    int pid = fork();
+    switch (pid) {
+    case 0:
+        {
+            int i, open_max, nextpid;
+            int stdinfd = -1;
+            int stdoutfd = -1;
+            if ((stdinfd = open(_PATH_DEVNULL, O_RDONLY)) < 0)
+                goto cleanup;
+            if ((stdoutfd = open(_PATH_DEVNULL, 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;
+
+            open_max = sysconf (_SC_OPEN_MAX);
+            for (i = 0; i < open_max; i++)
+                if (i != STDIN_FILENO &&
+                    i != STDOUT_FILENO &&
+                    i != STDERR_FILENO)
+                    close(i);
+
+            if (setsid() < 0)
+                goto cleanup;
+
+            nextpid = fork();
+            switch (nextpid) {
+            case 0:
+                return 0;
+            case -1:
+                return -1;
+            default:
+                return nextpid;
+            }
+
+        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;
+            }
+      
+            return pid;
+        }
+    }
+}
+
+static int qemudListenUnix(struct qemud_server *server,
+                           const char *path, int readonly) {
+    struct qemud_socket *sock = calloc(1, sizeof(struct qemud_socket));
+    struct sockaddr_un addr;
+    mode_t oldmask;
+
+    if (!sock)
+        return -1;
+
+    sock->readonly = readonly;
+    sock->next = server->sockets;
+    server->sockets = sock;
+    server->nsockets++;
+
+    if ((sock->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
+        return -1;
+
+    if (qemudSetCloseExec(sock->fd) < 0)
+        return -1;
+    if (qemudSetNonBlock(sock->fd) < 0)
+        return -1;
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    strncpy(addr.sun_path, path, sizeof(addr.sun_path)-1);
+    /* Use '@' to indicate abstract socket namespace */
+    if (path[0] == '@') {
+        addr.sun_path[0] = '\0';
+    } else {
+        unlink(addr.sun_path);
+    }
+
+    if (readonly)
+        oldmask = umask(~(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
+    else
+        oldmask = umask(~(S_IRUSR | S_IWUSR));
+    if (bind(sock->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+        return -1;
+    umask(oldmask);
+
+    if (listen(sock->fd, 30) < 0)
+        return -1;
+
+    return 0;
+}
+
+static int qemudListenAddr(struct qemud_server *server,
+                           const char *addr, int readonly,
+                           int secure, int clientCertAuth) {
+    struct addrinfo *ai;
+    struct addrinfo hints;
+    struct addrinfo *tmp;
+    char *node, *offset;
+    const char *service;
+
+    node = strdup(addr);
+    if (!node)
+        return -1;
+
+    if (!(offset = strstr(node, ","))) {
+        service = QEMUD_DEFAULT_PORT_STR;
+    } else {
+        offset[0] = '\0';
+        service = offset + 1;
+    }
+
+    memset (&hints, '\0', sizeof (hints));
+    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG | AI_NUMERICSERV;
+    hints.ai_socktype = SOCK_STREAM;
+    if (getaddrinfo (node, service, &hints, &ai) < 0) {
+        free(node);
+        return -1;
+    }
+    free(node);
+
+    tmp = ai;
+    while (tmp != NULL) {
+        int opt = 1;
+        struct qemud_socket *sock = calloc(1, sizeof(struct qemud_socket));
+        if (!sock)
+            goto error;
+
+        sock->readonly = readonly;
+        sock->secure = secure;
+        sock->clientCertAuth = clientCertAuth;
+        sock->next = server->sockets;
+        server->sockets = sock;
+        server->nsockets++;
+
+        if ((sock->fd = socket (tmp->ai_family, tmp->ai_socktype,
+                                tmp->ai_protocol)) < 0)
+            goto error;
+
+        if (qemudSetCloseExec(sock->fd) < 0)
+            goto error;
+
+        if (qemudSetNonBlock(sock->fd) < 0)
+            goto error;
+
+        if (setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR,
+                       &opt, sizeof (opt)) < 0)
+            goto error;
+
+        if (bind (sock->fd, tmp->ai_addr, tmp->ai_addrlen) < 0)
+            goto error;
+
+        if (listen (sock->fd, SOMAXCONN) < 0)
+            goto error;
+
+        tmp = tmp->ai_next;
+    }
+
+    freeaddrinfo (ai);
+    return 0;
+
+ error:
+    freeaddrinfo (ai);
+    return -1;
+}
+
+static int qemudListen(struct qemud_server *server,
+                       const char *listenAddr, int tls, int tlsAuth) {
+    int readonly = 0;
+
+    if (!strncmp(listenAddr, "ro:", 3)) {
+        readonly = 1;
+        listenAddr += 3;
+    }
+
+    if (listenAddr[0] == '/' ||
+        (listenAddr[0] == '@' && listenAddr[1] == '/')) {
+        if (qemudListenUnix(server, listenAddr, readonly) < 0)
+            return -1;
+    } else {
+        if (qemudListenAddr(server, listenAddr, readonly, tls, tlsAuth) < 0)
+            return -1;
+    }
+
+    return 0;
+}
+
+#define DH_BITS 1024
+static gnutls_certificate_credentials_t x509_cred;
+static gnutls_dh_params_t dh_params;
+
+static int qemudGenerateTLSDHParams(void) {
+    if (gnutls_dh_params_init (&dh_params) < 0)
+        return -1;
+    if (gnutls_dh_params_generate2 (dh_params, DH_BITS) < 0)
+        return -1;
+    return 0;
+}
+
+static int qemudInitializeTLS(const char *cert,
+                              const char *key,
+                              const char *cacert,
+                              const char *cacrl) {
+    int ret;
+    if (gnutls_global_init() < 0) {
+        printf("Could not init TLS\n");
+        return -1;
+    }
+
+    if (gnutls_certificate_allocate_credentials (&x509_cred) < 0) {
+        return -1;
+    }
+    if ((ret = gnutls_certificate_set_x509_trust_file (x509_cred, cacert,
+                                                       GNUTLS_X509_FMT_PEM)) < 0) {
+        printf("Could not load CA cert %s\n", gnutls_strerror(ret));
+        return -1;
+    }
+    
+    if (cacrl &&
+        (ret = gnutls_certificate_set_x509_crl_file (x509_cred, cacrl,
+                                                     GNUTLS_X509_FMT_PEM)) < 0) {
+        printf("Could not load CA CRL %s\n", gnutls_strerror(ret));
+        return -1;
+    }
+
+    if ((ret = gnutls_certificate_set_x509_key_file (x509_cred, cert, key,
+                                                     GNUTLS_X509_FMT_PEM)) < 0) {
+        printf("Could not load cert & key %s\n", gnutls_strerror(ret));
+        return -1;
+    }
+
+    if (qemudGenerateTLSDHParams() < 0)
+        return -1;
+
+    gnutls_certificate_set_dh_params (x509_cred, dh_params);
+
+    return 0;
+}
+
+
+static struct qemud_server *qemudInitialize(char **listenAddrs,
+                                            int naddrs,
+                                            int tls,
+                                            int tlsAuth) {
+    struct qemud_server *server;
+    int i;
+    char path[PATH_MAX];
+    struct passwd *pw;
+    int uid, ret;
+
+    if (!(server = calloc(1, sizeof(struct qemud_server))))
+        return NULL;
+
+    /* XXX extract actual version */
+    server->qemuVersion = (0*1000000)+(8*1000)+(0);
+    /* We don't have a dom-0, so start from 1 */
+    server->nextvmid = 1;
+
+    if ((uid = geteuid()) < 0) {
+        goto cleanup;
+    }
+    if (!(pw = getpwuid(uid))) {
+        goto cleanup;
+    }
+
+    if ((ret = snprintf(path, PATH_MAX, "%s/.qemud", pw->pw_dir)) > PATH_MAX) {
+        goto cleanup;
+    }
+
+    if ((ret = snprintf(server->configDir, PATH_MAX, "%s/.qemud.d", pw->pw_dir)) > PATH_MAX) {
+        goto cleanup;
+    }
+
+    for (i = 0 ; i < naddrs ; i++) {
+        if (qemudListen(server, listenAddrs[i], tls, tlsAuth) < 0)
+            goto cleanup;
+    }
+
+    if (qemudScanConfigs(server) < 0) {
+        goto cleanup;
+    }
+
+    return server;
+
+ cleanup:
+    if (server) {
+        struct qemud_socket *sock = server->sockets;
+        while (sock) {
+            close(sock->fd);
+            sock = sock->next;
+        }
+
+        free(server);
+    }
+    return NULL;
+}
+
+static int qemudClientTLSInitialize(struct qemud_client *client) {
+    int protocol[]= { GNUTLS_TLS1_1, GNUTLS_SSL3, 0 };
+
+    if (gnutls_init (&client->session, GNUTLS_SERVER) < 0)
+        return -1;
+
+    //gnutls_set_default_priority(client->session);
+    if (gnutls_set_default_export_priority(client->session) < 0)
+        return -1;
+    if (gnutls_protocol_set_priority(client->session, protocol) < 0)
+        return -1;
+
+    if (gnutls_credentials_set(client->session, GNUTLS_CRD_CERTIFICATE, x509_cred) < 0)
+        return -1;
+
+    gnutls_certificate_server_set_request(client->session, GNUTLS_CERT_REQUEST);
+    gnutls_dh_set_prime_bits(client->session, DH_BITS);
+    gnutls_transport_set_ptr(client->session, (gnutls_transport_ptr_t) (long)client->fd);
+
+    return 0;
+}
+
+static int qemudClientTLSValidate(struct qemud_client *client) {
+    int ret;
+    unsigned int status;
+    const gnutls_datum_t *certs;
+    unsigned int nCerts, i;
+    time_t now;
+
+    printf("Validating TLS certificate\n");
+    if ((ret = gnutls_certificate_verify_peers2 (client->session, &status)) < 0) {
+        printf("Verify failed %s\n", gnutls_strerror(ret));
+        return -1;
+    }
+
+    if ((now = time(NULL)) == ((time_t)-1)) {
+        return -1;
+    }
+
+    if (status != 0) {
+        if (status & GNUTLS_CERT_INVALID)
+            printf ("The certificate is not trusted.\n");
+
+        if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
+            printf ("The certificate hasn't got a known issuer.\n");
+
+        if (status & GNUTLS_CERT_REVOKED)
+            printf ("The certificate has been revoked.\n");
+
+        if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
+            printf ("The certificate uses an insecure algorithm\n");
+
+        return -1;
+    } else {
+        printf("Certificate is valid!\n");
+    }
+
+    if (gnutls_certificate_type_get(client->session) != GNUTLS_CRT_X509)
+        return -1;
+
+    if (!(certs = gnutls_certificate_get_peers(client->session, &nCerts)))
+        return -1;
+
+    for (i = 0 ; i < nCerts ; i++) {
+        gnutls_x509_crt_t cert;
+        printf ("Checking chain %d\n", i);
+        if (gnutls_x509_crt_init (&cert) < 0)
+            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) {
+            printf("The certificate has expired\n");
+            gnutls_x509_crt_deinit (cert);
+            return -1;
+        }
+
+        if (gnutls_x509_crt_get_activation_time (cert) > now) {
+            printf("The certificate is not yet activated\n");
+            gnutls_x509_crt_deinit (cert);
+            return -1;
+        }
+
+        if (i == 0) {
+            const char *hostname = "localhost";
+            if (!gnutls_x509_crt_check_hostname (cert, hostname)) {
+                printf ("The certificate's owner does not match hostname '%s'\n",
+                        hostname);
+                gnutls_x509_crt_deinit (cert);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int qemudClientTLSHandshake(struct qemud_client *client) {
+    int ret;
+    if ((ret = gnutls_handshake(client->session)) < 0) {
+        printf("Handshake err\n");
+        if (gnutls_error_is_fatal(ret)) {
+            printf("Fatal TLS error %s\n", gnutls_strerror(ret));
+            return -1;
+        }
+        return 0;
+    }
+
+    if (client->certAuth) {
+        if (qemudClientTLSValidate(client) < 0) {
+            printf("Certificate validation failed\n");
+            return -1;
+        } else {
+            printf("Client certificate is ok, allowing read-write\n");
+        }
+    } else {
+        printf("Not checking for client certificate, marking read-only\n");
+        /* XXX do some other auth, rather than just letting through */
+    }
+
+    printf("Handshake complete\n");
+    client->state = QEMUD_CLIENT_TRANSMIT;
+
+    return 0;
+}
+
+static int qemudDispatchServer(struct qemud_server *server, struct qemud_socket *sock) {
+    int fd;
+    struct sockaddr_storage addr;
+    unsigned int addrlen = sizeof(addr);
+    struct qemud_client *client;
+
+    if ((fd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen)) < 0) {
+        if (errno == EAGAIN)
+            return 0;
+        return -1;
+    }
+
+    if (qemudSetCloseExec(fd) < 0) {
+        close(fd);
+        return -1;
+    }
+
+    if (qemudSetNonBlock(fd) < 0) {
+        close(fd);
+        return -1;
+    }
+
+    client = calloc(1, sizeof(struct qemud_client));
+    client->fd = fd;
+    client->readonly = sock->readonly;
+    client->secure = sock->secure;
+    client->certAuth = sock->clientCertAuth;
+    client->state = QEMUD_CLIENT_INIT;
+
+    client->next = server->clients;
+    server->clients = client;
+    server->nclients++;
+
+    return 0;
+}
+
+static int
+qemudExec(struct qemud_server *server, char **argv,
+          int *retpid, int *outfd, int *errfd) {
+    int pid, null;
+    int pipeout[2] = {-1,-1};
+    int pipeerr[2] = {-1,-1};
+
+    if ((null = open(_PATH_DEVNULL, O_RDONLY)) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot open %s : %s",
+                         _PATH_DEVNULL, strerror(errno));
+        goto cleanup;
+    }
+
+    if ((outfd != NULL && pipe(pipeout) < 0) ||
+        (errfd != NULL && pipe(pipeerr) < 0)) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot create pipe : %s",
+                         strerror(errno));
+        goto cleanup;
+    }
+
+    if ((pid = fork()) < 0) {
+        qemudReportError(server, VIR_ERR_INTERNAL_ERROR, "cannot fork child process : %s",
+                         strerror(errno));
+        goto cleanup;
+    }
+
+    if (pid) { /* parent */
+        close(null);
+        if (outfd) {
+            close(pipeout[1]);
+            qemudSetNonBlock(pipeout[0]);
+            *outfd = pipeout[0];
+        }
+        if (errfd) {
+            close(pipeerr[1]);
+            qemudSetNonBlock(pipeerr[0]);
+            *errfd = pipeerr[0];
+        }
+        *retpid = pid;
+        return 0;
+    }
+
+    /* child */
+
+    if (pipeout[0] > 0 && close(pipeout[0]) < 0)
+        _exit(1);
+    if (pipeerr[0] > 0 && close(pipeerr[0]) < 0)
+        _exit(1);
+
+    if (dup2(null, STDIN_FILENO) < 0)
+        _exit(1);
+    if (dup2(pipeout[1] > 0 ? pipeout[1] : null, STDOUT_FILENO) < 0)
+        _exit(1);
+    if (dup2(pipeerr[1] > 0 ? pipeerr[1] : null, STDERR_FILENO) < 0)
+        _exit(1);
+
+    int i, open_max = sysconf (_SC_OPEN_MAX);
+    for (i = 0; i < open_max; i++)
+        if (i != STDOUT_FILENO &&
+            i != STDERR_FILENO &&
+            i != STDIN_FILENO)
+            close(i);
+
+    execvp(argv[0], argv);
+
+    _exit(1);
+
+    return 0;
+
+ cleanup:
+    if (pipeerr[0] > 0)
+        close(pipeerr[0] > 0);
+    if (pipeerr[1])
+        close(pipeerr[1] > 0);
+    if (pipeout[0])
+        close(pipeout[0] > 0);
+    if (pipeout[1])
+        close(pipeout[1] > 0);
+    if (null > 0)
+        close(null);
+    return -1;
+}
+
+
+int qemudStartVMDaemon(struct qemud_server *server,
+                       struct qemud_vm *vm) {
+    char **argv = NULL;
+    int i, ret = -1;
+
+    if (vm->def.vncPort < 0)
+        vm->def.vncActivePort = 5900 + server->nextvmid;
+    else
+        vm->def.vncActivePort = vm->def.vncPort;
+
+    if (qemudBuildCommandLine(server, vm, &argv) < 0)
+        return -1;
+
+    if (qemudExec(server, argv, &vm->pid, &vm->stdout, &vm->stderr) == 0) {
+        vm->def.id = server->nextvmid++;
+        ret = 0;
+    }
+  
+    for (i = 0 ; argv[i] ; i++)
+        free(argv[i]);
+    free(argv);
+
+    return ret;
+}
+
+
+static void qemudDispatchClientFailure(struct qemud_server *server, struct qemud_client *client) {
+    struct qemud_client *tmp = server->clients;
+    struct qemud_client *prev = NULL;
+    while (tmp) {
+        if (tmp == client) {
+            if (prev == NULL)
+                server->clients = client->next;
+            else
+                prev->next = client->next;
+            server->nclients--;
+            break;
+        }
+        prev = tmp;
+        tmp = tmp->next;
+    }
+    close(client->fd);
+    if (client->secure)
+        gnutls_deinit(client->session);
+    free(client);
+}
+
+
+static int qemudDispatchClientRequest(struct qemud_server *server, struct qemud_client *client) {
+    if (qemudDispatch(server,
+                      client,
+                      &client->incoming,
+                      &client->outgoing) < 0) {
+        return -1;
+    }
+
+    client->outgoingSent = 0;
+    client->tx = 1;
+    client->incomingReceived = 0;
+
+    return 0;
+}
+
+static int qemudClientRead(struct qemud_server *server,
+                           struct qemud_client *client,
+                           char *buf, size_t want) {
+    int ret;
+    int tls = (client->state == QEMUD_CLIENT_TRANSMIT &&
+               client->mode == QEMUD_MODE_TLS) ? 1 : 0;
+
+    if (tls) {
+        if ((ret = gnutls_read(client->session, buf, want)) <= 0) {
+            printf("Secure read error %d\n", ret);
+            if (!ret || gnutls_error_is_fatal(ret))
+                qemudDispatchClientFailure(server, client);
+            return -1;
+        }
+        printf("Secure data read %d\n", ret);
+        return ret;
+    } else {
+        if ((ret = read(client->fd, buf, want)) <= 0) {
+            printf("Plain read error %d\n", ret);
+            if (!ret || errno != EAGAIN)
+                qemudDispatchClientFailure(server, client);
+            return -1;
+        }
+        printf("Plain data read %d\n", ret);
+        return ret;
+    }
+}
+
+static void qemudDispatchClientRead(struct qemud_server *server, struct qemud_client *client) {
+    char *data = (char *)&client->incoming;
+    unsigned int got = client->incomingReceived;
+    int want;
+    int ret;
+
+ restart:
+    if (got >= sizeof(struct qemud_packet_header)) {
+        want = sizeof(struct qemud_packet_header) + qemud_wire_32(client->incoming.header.dataSize) - got;
+    } else {
+        want = sizeof(struct qemud_packet_header) - got;
+    }
+
+    if ((ret = qemudClientRead(server, client, data+got, want)) < 0) {
+        return;
+    }
+    got += ret;
+    client->incomingReceived += ret;
+
+    /* If we've finished header, move onto body */
+    if (client->incomingReceived == sizeof(struct qemud_packet_header)) {
+        printf("Type %d, data %d\n",
+               qemud_wire_32(client->incoming.header.type),
+               qemud_wire_32(client->incoming.header.dataSize));
+        /* Client lied about dataSize */
+        if (qemud_wire_32(client->incoming.header.dataSize) > sizeof(union qemud_packet_data)) {
+            printf("Bogus data size %u\n", qemud_wire_32(client->incoming.header.dataSize));
+            qemudDispatchClientFailure(server, client);
+            return;
+        }
+        if (qemud_wire_32(client->incoming.header.dataSize)) {
+            printf("- Restarting recv to process body (%d bytes)\n", qemud_wire_32(client->incoming.header.dataSize));
+            goto restart;
+        }
+    }
+
+    /* If we've finished body, dispatch the request */
+    if (ret == want) {
+        if (qemudDispatchClientRequest(server, client) < 0)
+            qemudDispatchClientFailure(server, client);
+        printf("Dispatch\n");
+    }
+}
+
+
+static int qemudClientWrite(struct qemud_server *server,
+                           struct qemud_client *client,
+                           char *buf, size_t want) {
+    int ret;
+    int tls = (client->state == QEMUD_CLIENT_TRANSMIT &&
+               client->mode == QEMUD_MODE_TLS) ? 1 : 0;
+    if (tls) {
+        if ((ret = gnutls_write(client->session, buf, want)) < 0) {
+            printf("Secure write error %d\n", ret);
+            if (gnutls_error_is_fatal(ret))
+                qemudDispatchClientFailure(server, client);
+            return -1;
+        }
+        printf("Secure data write %d\n", ret);
+        return ret;
+    } else {
+        if ((ret = write(client->fd, buf, want)) < 0) {
+            printf("Plain write error %d\n", ret);
+            if (errno != EAGAIN)
+                qemudDispatchClientFailure(server, client);
+            return -1;
+        }
+        printf("Plain data write %d\n", ret);
+        return ret;
+    }
+}
+
+
+static void qemudDispatchClientWrite(struct qemud_server *server, struct qemud_client *client) {
+    char *data = (char *)&client->outgoing;
+    int sent = client->outgoingSent;
+    int todo = sizeof(struct qemud_packet_header) + qemud_wire_32(client->outgoing.header.dataSize) - sent;
+    int ret;
+    if ((ret = qemudClientWrite(server, client, data+sent, todo)) < 0) {
+        return;
+    }
+    client->outgoingSent += ret;
+    printf("Done %d %d %d\n", todo, ret, client->state);
+    if (todo == ret) {
+        client->tx = 0;
+        /* If we've finished sending a reply & we're in the init state,
+           then we need to change states, possibly doing a TLS handshake */
+        if (client->state == QEMUD_CLIENT_INIT) {
+            printf("Completed init, switching state\n");
+            if (client->mode == QEMUD_MODE_TLS) {
+                printf("Starting handshake\n");
+                if (qemudClientTLSInitialize(client) < 0)
+                    qemudDispatchClientFailure(server, client);
+                else
+                    client->state = QEMUD_CLIENT_HANDSHAKE;
+            } else {
+                printf("Starting transmit\n");
+                client->state = QEMUD_CLIENT_TRANSMIT;
+            }
+        }
+    }
+}
+
+static int qemudVMData(struct qemud_server *server ATTRIBUTE_UNUSED,
+                       struct qemud_vm *vm, int fd) {
+    char buf[4096];
+    if (vm->pid < 0)
+        return 0;
+
+    for (;;) {
+        int ret = read(fd, buf, 4096);
+        if (ret < 0) {
+            if (errno == EAGAIN)
+                return 0;
+            return -1;
+        }
+        if (ret == 0) {
+            return 0;
+        }
+        write(STDOUT_FILENO, "[", 1);
+        write(STDOUT_FILENO, buf, ret);
+        write(STDOUT_FILENO, "]", 1);
+    }
+}
+
+int qemudShutdownVMDaemon(struct qemud_server *server, struct qemud_vm *vm) {
+    struct qemud_vm *prev = NULL, *curr = server->activevms;
+
+    /* Already cleaned-up */
+    if (vm->pid < 0)
+        return 0;
+
+    kill(vm->pid, SIGTERM);
+
+    /* Move it to inactive vm list */
+    while (curr) {
+        if (curr == vm) {
+            if (prev) {
+                prev->next = curr->next;
+            } else {
+                server->activevms = curr->next;
+            }
+            server->nactivevms--;
+
+            curr->next = server->inactivevms;
+            server->inactivevms = curr;
+            server->ninactivevms++;
+            break;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+
+    qemudVMData(server, vm, curr->stdout);
+    qemudVMData(server, vm, curr->stderr);
+    close(curr->stdout);
+    close(curr->stderr);
+    curr->stdout = -1;
+    curr->stderr = -1;
+    server->nvmfds -= 2;
+
+    if (waitpid(vm->pid, NULL, WNOHANG) != vm->pid) {
+        kill(vm->pid, SIGKILL);
+        if (waitpid(vm->pid, NULL, 0) != vm->pid) {
+            printf("Got unexpected pid, damn\n");
+        }
+    }
+
+    vm->pid = -1;
+    vm->def.id = -1;
+
+    return 0;
+}
+
+static int qemudDispatchVMLog(struct qemud_server *server, struct qemud_vm *vm, int fd) {
+    if (qemudVMData(server, vm, fd) < 0)
+        if (qemudShutdownVMDaemon(server, vm) < 0)
+            return -1;
+    return 0;
+}
+static int qemudDispatchVMMonitor(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                  struct qemud_vm *vm ATTRIBUTE_UNUSED) {
+    return -1;
+}
+static int qemudDispatchVMFailure(struct qemud_server *server, struct qemud_vm *vm,
+                                  int fd ATTRIBUTE_UNUSED) {
+    if (qemudShutdownVMDaemon(server, vm) < 0)
+        return -1;
+    return 0;
+}
+
+
+static int qemudDispatchPoll(struct qemud_server *server, struct pollfd *fds) {
+    struct qemud_socket *sock = server->sockets;
+    struct qemud_client *client = server->clients;
+    struct qemud_vm *vm = server->activevms;
+    struct qemud_vm *tmp;
+    int ret = 0;
+    int fd = 0;
+
+    while (sock) {
+        struct qemud_socket *next = sock->next;
+        if (fds[fd].revents)
+            if (qemudDispatchServer(server, sock) < 0)
+                return -1;
+        fd++;
+        sock = next;
+    }
+
+    while (client) {
+        struct qemud_client *next = client->next;
+        if (fds[fd].revents) {
+            switch (client->state) {
+            case QEMUD_CLIENT_HANDSHAKE:
+                printf("Poll data handshake\n");
+                if (fds[fd].revents & (POLLOUT | POLLIN)) {
+                    if (qemudClientTLSHandshake(client) < 0)
+                        qemudDispatchClientFailure(server, client);
+                } else {
+                    qemudDispatchClientFailure(server, client);
+                }
+                break;
+            case QEMUD_CLIENT_INIT:
+            case QEMUD_CLIENT_TRANSMIT:
+                printf("Poll data normal\n");
+                if (fds[fd].revents == POLLOUT)
+                    qemudDispatchClientWrite(server, client);
+                else if (fds[fd].revents == POLLIN)
+                    qemudDispatchClientRead(server, client);
+                else
+                    qemudDispatchClientFailure(server, client);
+                break;
+            default:
+                qemudDispatchClientFailure(server, client);
+                break;
+            }
+        }
+        fd++;
+        client = next;
+    }
+    while (vm) {
+        struct qemud_vm *next = vm->next;
+        int failed = 0,
+            stdoutfd = vm->stdout,
+            stderrfd = vm->stderr,
+            monitorfd = vm->monitor;
+        if (stdoutfd != -1) {
+            if (fds[fd].revents) {
+                if (fds[fd].revents == POLLIN) {
+                    if (qemudDispatchVMLog(server, vm, fds[fd].fd) < 0)
+                        failed = 1;
+                } else {
+                    if (qemudDispatchVMFailure(server, vm, fds[fd].fd) < 0)
+                        failed = 1;
+                }
+            }
+            fd++;
+        }
+        if (stderrfd != -1) {
+            if (!failed) {
+                if (fds[fd].revents) {
+                    if (fds[fd].revents == POLLIN) {
+                        if (qemudDispatchVMLog(server, vm, fds[fd].fd) < 0)
+                            failed = 1;
+                    } else {
+                        if (qemudDispatchVMFailure(server, vm, fds[fd].fd) < 0)
+                            failed = 1;
+                    }
+                }
+            }
+            fd++;
+        }
+        if (monitorfd != -1) {
+            if (!failed) {
+                if (fds[fd].revents) {
+                    if (fds[fd].revents == POLLIN) {
+                        if (qemudDispatchVMMonitor(server, vm) < 0)
+                            failed = 1;
+                    } else {
+                        if (qemudDispatchVMFailure(server, vm, fds[fd].fd) < 0)
+                            failed = 1;
+                    }
+                }
+            }
+            fd++;
+        }
+        vm = next;
+        if (failed)
+            ret = -1;
+    }
+
+    /* Cleanup any VMs which shutdown & dont have an associated
+       config file */
+    vm = server->inactivevms;
+    tmp = NULL;
+    while (vm) {
+        if (!vm->configFile[0]) {
+            struct qemud_vm *next = vm->next;
+            if (tmp) {
+                tmp->next = next;
+            } else {
+                server->inactivevms = next;
+            }
+            qemudFreeVM(vm);
+            vm = next;
+        } else {
+            tmp = vm;
+            vm = vm->next;
+        }
+    }
+
+    return ret;
+}
+
+static void qemudPreparePoll(struct qemud_server *server, struct pollfd *fds) {
+    struct qemud_socket *sock;
+    struct qemud_client *client;
+    struct qemud_vm *vm;
+    int  fd = 0;
+
+    for (sock = server->sockets ; sock ; sock = sock->next) {
+        fds[fd].fd = sock->fd;
+        fds[fd].events = POLLIN;
+        fd++;
+    }
+
+    for (client = server->clients ; client ; client = client->next) {
+        fds[fd].fd = client->fd;
+        /* Refuse to read more from client if tx is pending to
+           rate limit */
+        if (client->tx)
+            fds[fd].events = POLLOUT | POLLERR | POLLHUP;
+        else
+            fds[fd].events = POLLIN | POLLERR | POLLHUP;
+        fd++;
+    }
+    for (vm = server->activevms ; vm ; vm = vm->next) {
+        if (vm->stdout != -1) {
+            fds[fd].fd = vm->stdout;
+            fds[fd].events = POLLIN | POLLERR | POLLHUP;
+            fd++;
+        }
+        if (vm->stderr != -1) {
+            fds[fd].fd = vm->stderr;
+            fds[fd].events = POLLIN | POLLERR | POLLHUP;
+            fd++;
+        }
+        if (vm->monitor != -1) {
+            fds[fd].fd = vm->monitor;
+            fds[fd].events = POLLIN | POLLERR | POLLHUP;
+            fd++;
+        }
+    }
+}
+
+
+
+static int qemudOneLoop(struct qemud_server *server, int timeout) {
+    int nfds = server->nsockets + server->nclients + server->nvmfds;
+    struct pollfd fds[nfds];
+    int thistimeout = -1;
+    int ret;
+
+    /* If we have no clients or vms, then timeout after
+       30 seconds, letting daemon exit */
+    if (timeout > 0 &&
+        !server->nclients &&
+        !server->nactivevms)
+        thistimeout = timeout;
+
+    qemudPreparePoll(server, fds);
+
+ retry:
+
+    if ((ret = poll(fds, nfds, thistimeout * 1000)) < 0) {
+        if (errno == EINTR) {
+            goto retry;
+        }
+        return -1;
+    }
+
+    /* Must have timed out */
+    if (ret == 0)
+        return -1;
+
+    if (qemudDispatchPoll(server, fds) < 0)
+        return -1;
+
+    return 0;
+}
+
+static int qemudRunLoop(struct qemud_server *server, int timeout) {
+    int ret;
+
+    while ((ret = qemudOneLoop(server, timeout)) == 0)
+        ;
+
+    return ret == -1 ? -1 : 0;
+}
+
+static void qemudCleanup(struct qemud_server *server) {
+    struct qemud_socket *sock = server->sockets;
+    while (sock) {
+        close(sock->fd);
+        sock = sock->next;
+    }
+    free(server);
+}
+
+#define MAX_LISTEN 5
+int main(int argc, char **argv) {
+    int daemon = 0;
+    int verbose = 0;
+    int timeout = -1;
+    char *listenAddrs[MAX_LISTEN];
+    int naddrs = 0;
+    int tls = 0;
+    int tlsAuth = 0;
+    char *tlsCert = NULL;
+    char *tlsKey = NULL;
+    char *tlsCACert = NULL;
+    char *tlsCACRL = NULL;
+
+    struct option opts[] = {
+        { "verbose", no_argument, &verbose, 1},
+        { "daemon", no_argument, &daemon, 1},
+        { "timeout", required_argument, 0, 't'},
+        { "listen", required_argument, 0, 'l' },
+        { "tls", no_argument, &tls, 1},
+        { "tls-auth", no_argument, &tlsAuth, 1},
+        { "tls-cert", required_argument, 0, 'c' },
+        { "tls-key", required_argument, 0, 'k' },
+        { "tls-ca-cert", required_argument, 0, 'a' },
+        { "tls-ca-crl", required_argument, 0, 'r' },
+        {0, 0, 0, 0}
+    };
+
+    while (1) {
+        int optidx = 0;
+        int c;
+        char *tmp;
+
+        c = getopt_long(argc, argv, "vdt:u:U:l:L:", opts, &optidx);
+
+        if (c == -1) {
+            break;
+        }
+
+        switch (c) {
+        case 0:
+            /* Got one of the flags */
+            break;
+        case 't':
+            timeout = strtol(optarg, &tmp, 10);
+            if (!tmp)
+                timeout = -1;
+            if (timeout <= 0)
+                timeout = -1;
+            break;
+        case 'l':
+            if (naddrs >= MAX_LISTEN)
+                abort();
+            if (!(listenAddrs[naddrs] = strdup(optarg)))
+                abort();
+            naddrs++;
+            break;
+        case '?':
+            return 2;
+            break;
+
+        case 'c':
+            tlsCert = optarg;
+            break;
+        case 'k':
+            tlsKey = optarg;
+            break;
+        case 'a':
+            tlsCACert = optarg;
+            break;
+        case 'r':
+            tlsCACRL = optarg;
+            break;
+
+        default:
+            abort();
+        }
+    }
+
+
+    if (tls) {
+        if (!tlsCert) {
+            fprintf(stderr, "TLS enabled, but no certificate specified\n");
+            return 1;
+        }
+        if (!tlsKey) {
+            fprintf(stderr, "TLS enabled, but no private key specified\n");
+            return 1;
+        }
+        if (!tlsCACert) {
+            fprintf(stderr, "TLS enabled, but no CA certificate specified\n");
+            return 1;
+        }
+    }
+
+    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
+        return 3;
+    if (signal(SIGCHLD, reapchild) == SIG_ERR)
+        return 3;
+
+    if (daemon) {
+        int pid = qemudGoDaemon();
+        if (pid < 0)
+            return 1;
+        if (pid > 0)
+            return 0;
+    }
+
+    if (tls) {
+        if (qemudInitializeTLS(tlsCert, tlsKey, tlsCACert, tlsCACRL) < 0) {
+            return 1;
+        }
+    }
+
+    struct qemud_server *server = qemudInitialize(listenAddrs,
+                                                  naddrs,
+                                                  tls, tlsAuth);
+
+    if (!server)
+        return 2;
+
+    qemudRunLoop(server, timeout);
+
+    qemudCleanup(server);
+
+    return 0;
+}
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
