---
 src/lxc_conf.c |  942 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/lxc_conf.h |  142 ++++++++
 2 files changed, 1084 insertions(+)

Index: b/src/lxc_conf.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ b/src/lxc_conf.h	2008-03-14 11:22:13.000000000 -0700
@@ -0,0 +1,142 @@
+/*
+ * Copyright IBM Corp. 2008
+ *
+ * lxc_conf.h: header file for linux container config functions
+ *
+ * Authors:
+ *  David L. Leskovec <dlesko at linux.vnet.ibm.com>
+ *
+ * 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
+ */
+
+#ifndef LXC_CONF_H
+#define LXC_CONF_H
+
+#include <config.h>
+
+#ifdef WITH_LXC
+
+#include "internal.h"
+
+/* Defines */
+#define LXC_MAX_TTY_NAME 32
+#define LXC_MAX_XML_LENGTH 4096
+#define LXC_MAX_ERROR_LEN 1024
+#define LXC_DOMAIN_TYPE "linuxcontainer"
+
+typedef struct __lxc_mount lxc_mount_t;
+struct __lxc_mount {
+    char source[PATH_MAX]; /* user's directory */
+    char target[PATH_MAX];
+
+    lxc_mount_t *next;
+};
+
+typedef struct __lxc_vm_def lxc_vm_def_t;
+struct __lxc_vm_def {
+    unsigned char uuid[VIR_UUID_BUFLEN];
+    char* name;
+    int id;
+
+    /* init command string */
+    char init[PATH_MAX];
+
+    int maxMemory;
+
+    /* mounts - list of mount structs */
+    int nmounts;
+    lxc_mount_t *mounts;
+
+    /* tty device */
+    char tty[LXC_MAX_TTY_NAME];
+};
+
+typedef struct __lxc_vm lxc_vm_t;
+struct __lxc_vm {
+    int pid;
+    int state;
+
+    char configFile[PATH_MAX];
+    char configFileBase[PATH_MAX];
+
+    int parentTty;
+
+    lxc_vm_def_t *def;
+
+    lxc_vm_t *next;
+};
+
+typedef struct __lxc_driver lxc_driver_t;
+struct __lxc_driver {
+    lxc_vm_t *vms;
+    int nactivevms;
+    int ninactivevms;
+    char* configDir;
+};
+
+/* Types and structs */
+
+/* Inline Functions */
+static inline int lxcIsActiveVM(lxc_vm_t *vm)
+{
+    return vm->def->id != -1;
+}
+
+/* Function declarations */
+lxc_vm_def_t * lxcParseVMDef(virConnectPtr conn,
+                             const char* xmlString,
+                             const char* fileName);
+int lxcSaveVMDef(virConnectPtr conn,
+                 lxc_driver_t *driver,
+                 lxc_vm_t *vm,
+                 lxc_vm_def_t *def);
+int lxcLoadDriverConfig(virConnectPtr conn);
+int lxcSaveConfig(virConnectPtr conn,
+                  lxc_driver_t *driver,
+                  lxc_vm_t *vm,
+                  lxc_vm_def_t *def);
+int lxcLoadContainerInfo(virConnectPtr conn);
+int lxcLoadContainerConfigFile(lxc_driver_t *driver,
+                               const char *file);
+lxc_vm_t * lxcAssignVMDef(virConnectPtr conn,
+                          lxc_driver_t *driver,
+                          lxc_vm_def_t *def);
+char *lxcGenerateXML(virConnectPtr conn,
+                     lxc_driver_t *driver,
+                     lxc_vm_t *vm,
+                     lxc_vm_def_t *def);
+lxc_vm_t *lxcFindVMByID(const lxc_driver_t *driver, int id);
+lxc_vm_t *lxcFindVMByUUID(const lxc_driver_t *driver,
+                          const unsigned char *uuid);
+lxc_vm_t *lxcFindVMByName(const lxc_driver_t *driver,
+                          const char *name);
+void lxcRemoveInactiveVM(lxc_driver_t *driver,
+                         lxc_vm_t *vm);
+void lxcFreeVMs(lxc_vm_t *vms);
+void lxcFreeVM(lxc_vm_t *vm);
+void lxcFreeVMDef(lxc_vm_def_t *vmdef);
+int lxcDeleteConfig(virConnectPtr conn,
+                    lxc_driver_t *driver,
+                    const char *configFile,
+                    const char *name);
+
+void lxcError(virConnectPtr conn,
+              virDomainPtr dom,
+              int code, const char *fmt, ...)
+    ATTRIBUTE_FORMAT(printf,4,5);
+
+#endif /* WITH_LXC */
+#endif /* LXC_CONF_H */
+
Index: b/src/lxc_conf.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ b/src/lxc_conf.c	2008-03-14 11:22:13.000000000 -0700
@@ -0,0 +1,942 @@
+/*
+ * Copyright IBM Corp. 2008
+ *
+ * lxc_conf.c: config functions for managing linux containers
+ *
+ * Authors:
+ *  David L. Leskovec <dlesko at linux.vnet.ibm.com>
+ *
+ * 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
+ *
+ */
+
+/* includes */
+#include <config.h>
+
+#ifdef WITH_LXC
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/uri.h>
+#include <libxml/xpath.h>
+
+#include "buf.h"
+#include "util.h"
+#include "uuid.h"
+
+#include "lxc_conf.h"
+
+/* debug macros */
+#define DEBUG(fmt,...) VIR_DEBUG(__FILE__, fmt, __VA_ARGS__)
+#define DEBUG0(msg) VIR_DEBUG(__FILE__, "%s", msg)
+
+/* Functions */
+void lxcError(virConnectPtr conn, virDomainPtr dom, int code,
+              const char *fmt, ...)
+{
+    va_list args;
+    char errorMessage[LXC_MAX_ERROR_LEN];
+    const char *codeErrorMessage;
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(errorMessage, LXC_MAX_ERROR_LEN-1, fmt, args);
+        va_end(args);
+    } else {
+        errorMessage[0] = '\0';
+    }
+
+    codeErrorMessage = __virErrorMsg(code, fmt);
+    __virRaiseError(conn, dom, NULL, VIR_FROM_LXC, code, VIR_ERR_ERROR,
+                    codeErrorMessage, errorMessage, NULL, 0, 0,
+                    codeErrorMessage, errorMessage);
+}
+
+static inline int lxcIsEmptyXPathStringObj(xmlXPathObjectPtr xpathObj)
+{
+    if ((xpathObj == NULL) ||
+        (xpathObj->type != XPATH_STRING) ||
+        (xpathObj->stringval == NULL) ||
+        (xpathObj->stringval[0] == 0)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+static int lxcParseMountXML(virConnectPtr conn, xmlNodePtr nodePtr,
+                            lxc_mount_t *lxcMount)
+{
+    xmlChar *fsType = NULL;
+    xmlNodePtr curNode;
+    xmlChar *mountSource = NULL;
+    xmlChar *mountTarget = NULL;
+    int strLen;
+    int rc = -1;
+
+    if (NULL == (fsType = xmlGetProp(nodePtr, BAD_CAST "type"))) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("missing filesystem type"));
+        goto error;
+    }
+
+    if (xmlStrEqual(fsType, BAD_CAST "mount") == 0) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("invalid filesystem type"));
+        goto error;
+    }
+
+    for (curNode = nodePtr->children;
+         NULL != curNode;
+         curNode = curNode->next) {
+        if (curNode->type != XML_ELEMENT_NODE) {
+            continue;
+        }
+
+        if ((mountSource == NULL) &&
+            (xmlStrEqual(curNode->name, BAD_CAST "source"))) {
+            mountSource = xmlGetProp(curNode, BAD_CAST "dir");
+        } else if ((mountTarget == NULL) &&
+                  (xmlStrEqual(curNode->name, BAD_CAST "target"))) {
+            mountTarget = xmlGetProp(curNode, BAD_CAST "dir");
+        }
+    }
+
+    if (mountSource == NULL) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("missing mount source"));
+        goto error;
+    }
+
+    strLen = xmlStrlen(mountSource);
+    if ((strLen > (PATH_MAX-1)) || (0 == strLen)) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("empty or invalid mount source"));
+        goto error;
+    }
+
+    strncpy(lxcMount->source, (char *)mountSource, strLen);
+    lxcMount->source[strLen] = '\0';
+
+    if (mountTarget == NULL) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("missing mount target"));
+        goto error;
+    }
+
+    strLen = xmlStrlen(mountTarget);
+    if ((strLen > (PATH_MAX-1)) || (0 == strLen)) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("empty or invalid mount target"));
+        goto error;
+    }
+
+    strncpy(lxcMount->target, (char *)mountTarget, strLen);
+    lxcMount->target[strLen] = '\0';
+
+    rc = 0;
+
+error:
+    xmlFree(mountSource);
+    xmlFree(mountTarget);
+
+    return rc;
+}
+
+static int lxcParseDomainName(virConnectPtr conn, char **name,
+                              xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+
+    xpathObj = xmlXPathEval(BAD_CAST "string(/domain/name[1])", contextPtr);
+    if (lxcIsEmptyXPathStringObj(xpathObj)) {
+        lxcError(conn, NULL, VIR_ERR_NO_NAME, NULL);
+        goto parse_complete;
+    }
+
+    *name = strdup((const char *)xpathObj->stringval);
+    if (NULL == *name) {
+        lxcError(conn, NULL, VIR_ERR_NO_MEMORY, NULL);
+        goto parse_complete;
+    }
+
+
+    rc = 0;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+    return rc;
+}
+
+static int lxcParseDomainUUID(virConnectPtr conn, unsigned char *uuid,
+                              xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+
+    xpathObj = xmlXPathEval(BAD_CAST "string(/domain/uuid[1])", contextPtr);
+    if (lxcIsEmptyXPathStringObj(xpathObj)) {
+        if ((rc = virUUIDGenerate(uuid))) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("failed to generate uuid: %s"), strerror(rc));
+            goto parse_complete;
+        }
+    } else {
+        if (virUUIDParse((const char *)xpathObj->stringval, uuid) < 0) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("invalid uuid element"));
+            goto parse_complete;
+        }
+    }
+
+    rc = 0;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+    return rc;
+}
+
+static int lxcParseDomainMounts(virConnectPtr conn,
+                                lxc_mount_t **mounts,
+                                xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+    int i;
+    lxc_mount_t *mountObj;
+    lxc_mount_t *prevObj = NULL;
+    int nmounts = 0;
+
+    xpathObj = xmlXPathEval(BAD_CAST "/domain/devices/filesystem",
+                            contextPtr);
+    if ((xpathObj != NULL) &&
+        (xpathObj->type == XPATH_NODESET) &&
+        (xpathObj->nodesetval != NULL) &&
+        (xpathObj->nodesetval->nodeNr >= 0)) {
+        for (i = 0; i < xpathObj->nodesetval->nodeNr; ++i) {
+            mountObj = calloc(1, sizeof(lxc_mount_t));
+            if (NULL == mountObj) {
+                lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "mount");
+                goto parse_complete;
+            }
+
+            rc = lxcParseMountXML(conn, xpathObj->nodesetval->nodeTab[i],
+                                  mountObj);
+            if (0 > rc) {
+                free(mountObj);
+                goto parse_complete;
+            }
+
+            /* set the linked list pointers */
+            nmounts++;
+            mountObj->next = NULL;
+            if (0 == i) {
+                *mounts = mountObj;
+            } else {
+                prevObj->next = mountObj;
+            }
+            prevObj = mountObj;
+        }
+    }
+
+    rc = nmounts;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+
+    return rc;
+}
+
+static int lxcParseDomainInit(virConnectPtr conn, char* init, xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+
+    xpathObj = xmlXPathEval(BAD_CAST "string(/domain/os/init[1])",
+                           contextPtr);
+    if (lxcIsEmptyXPathStringObj(xpathObj)) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("invalid or missing init element"));
+        goto parse_complete;
+    }
+
+    if (strlen((const char*)xpathObj->stringval) >= PATH_MAX - 1) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("init string too long"));
+        goto parse_complete;
+    }
+
+    strcpy(init, (const char *)xpathObj->stringval);
+
+    rc = 0;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+
+    return rc;
+}
+
+
+static int lxcParseDomainTty(virConnectPtr conn, char *tty, xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+
+    xpathObj = xmlXPathEval(BAD_CAST "string(/domain/devices/console[1]/@tty)",
+                            contextPtr);
+    if (lxcIsEmptyXPathStringObj(xpathObj)) {
+        /* make sure the tty string is empty */
+        tty[0] = 0x00;
+    } else {
+        /* check the source string length */
+        if (strlen((const char*)xpathObj->stringval) >= LXC_MAX_TTY_NAME - 1) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("tty name is too long"));
+            goto parse_complete;
+        }
+        strcpy(tty, (const char *)xpathObj->stringval);
+    }
+
+    rc = 0;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+
+    return rc;
+}
+
+static int lxcParseDomainMemory(virConnectPtr conn, int* memory, xmlXPathContextPtr contextPtr)
+{
+    int rc = -1;
+    xmlXPathObjectPtr xpathObj = NULL;
+    char *endChar = NULL;
+
+    xpathObj = xmlXPathEval(BAD_CAST "string(/domain/memory[1])", contextPtr);
+    if (lxcIsEmptyXPathStringObj(xpathObj)) {
+        /* not an error, default to an invalid value so it's not used */
+        *memory = -1;
+    } else {
+        *memory = strtoll((const char*)xpathObj->stringval,
+                                          &endChar, 10);
+        if ((endChar == (const char*)xpathObj->stringval) ||
+           (*endChar != '\0')) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("invalid memory value"));
+            goto parse_complete;
+        }
+    }
+
+    rc = 0;
+
+parse_complete:
+    xmlXPathFreeObject(xpathObj);
+
+    return rc;
+}
+
+static lxc_vm_def_t * lxcParseXML(virConnectPtr conn, xmlDocPtr docPtr)
+{
+    xmlNodePtr rootNodePtr = NULL;
+    xmlXPathContextPtr contextPtr = NULL;
+    xmlChar *xmlProp = NULL;
+    lxc_vm_def_t *containerDef;
+
+    if (!(containerDef = calloc(1, sizeof(*containerDef)))) {
+        lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "containerDef");
+        return NULL;
+    }
+
+    /* Prepare parser / xpath context */
+    rootNodePtr = xmlDocGetRootElement(docPtr);
+    if ((rootNodePtr == NULL) ||
+       (!xmlStrEqual(rootNodePtr->name, BAD_CAST "domain"))) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("invalid root element"));
+        goto error;
+    }
+
+    contextPtr = xmlXPathNewContext(docPtr);
+    if (contextPtr == NULL) {
+        lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "context");
+        goto error;
+    }
+
+    /* Verify the domain type is linuxcontainer */
+    if (!(xmlProp = xmlGetProp(rootNodePtr, BAD_CAST "type"))) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("missing domain type"));
+        goto error;
+    }
+
+    if (!(xmlStrEqual(xmlProp, BAD_CAST LXC_DOMAIN_TYPE))) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("invalid domain type"));
+        goto error;
+    }
+    free(xmlProp);
+    xmlProp = NULL;
+
+    if ((xmlProp = xmlGetProp(rootNodePtr, BAD_CAST "id"))) {
+        if (0 > virStrToLong_i((char*)xmlProp, NULL, 10, &(containerDef->id))) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     "invalid domain id");
+            goto error;
+        }
+    } else {
+        containerDef->id = -1;
+    }
+    free(xmlProp);
+    xmlProp = NULL;
+
+    if (lxcParseDomainName(conn, &(containerDef->name), contextPtr) < 0) {
+        goto error;
+    }
+
+    if (lxcParseDomainInit(conn, containerDef->init, contextPtr) < 0) {
+        goto error;
+    }
+
+    if (lxcParseDomainUUID(conn, containerDef->uuid, contextPtr) < 0) {
+        goto error;
+    }
+
+    containerDef->nmounts = lxcParseDomainMounts(conn, &(containerDef->mounts),
+                                                 contextPtr);
+    if (0 > containerDef->nmounts) {
+        goto error;
+    }
+
+    if (lxcParseDomainTty(conn, containerDef->tty, contextPtr) < 0) {
+        goto error;
+    }
+
+    if (lxcParseDomainMemory(conn, &(containerDef->maxMemory), contextPtr) < 0) {
+        goto error;
+    }
+
+    xmlXPathFreeContext(contextPtr);
+
+    return containerDef;
+
+ error:
+    free(xmlProp);
+    xmlXPathFreeContext(contextPtr);
+    lxcFreeVMDef(containerDef);
+
+    return NULL;
+}
+
+
+lxc_vm_def_t * lxcParseVMDef(virConnectPtr conn,
+                             const char* xmlString,
+                             const char* fileName)
+{
+    xmlDocPtr xml;
+    lxc_vm_def_t *containerDef;
+
+    xml = xmlReadDoc(BAD_CAST xmlString,
+                     fileName ? fileName : "domain.xml",
+                     NULL, XML_PARSE_NOENT |
+                     XML_PARSE_NONET | XML_PARSE_NOERROR |
+                     XML_PARSE_NOWARNING);
+    if (!xml) {
+        lxcError(conn, NULL, VIR_ERR_XML_ERROR, NULL);
+        return NULL;
+    }
+
+    containerDef = lxcParseXML(conn, xml);
+
+    xmlFreeDoc(xml);
+
+    return containerDef;
+}
+
+lxc_vm_t * lxcAssignVMDef(virConnectPtr conn,
+                          lxc_driver_t *driver,
+                          lxc_vm_def_t *def)
+{
+    lxc_vm_t *vm = NULL;
+
+    if ((vm = lxcFindVMByName(driver, def->name))) {
+        if (!lxcIsActiveVM(vm)) {
+            lxcFreeVMDef(vm->def);
+            vm->def = def;
+        } else {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("Can't redefine active VM with name %s"), def->name);
+            return NULL;
+        }
+
+        return vm;
+    }
+
+    if (!(vm = calloc(1, sizeof(lxc_vm_t)))) {
+        lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "vm");
+        return NULL;
+    }
+
+    vm->pid = -1;
+    vm->def = def;
+    vm->next = driver->vms;
+
+    driver->vms = vm;
+
+    if (lxcIsActiveVM(vm)) {
+        vm->state = VIR_DOMAIN_RUNNING;
+        driver->nactivevms++;
+    } else {
+        vm->state = VIR_DOMAIN_SHUTOFF;
+        driver->ninactivevms++;
+    }
+
+    return vm;
+}
+
+void lxcRemoveInactiveVM(lxc_driver_t *driver,
+                         lxc_vm_t *vm)
+{
+    lxc_vm_t *prevVm = NULL;
+    lxc_vm_t *curVm;
+
+    for (curVm = driver->vms;
+         (curVm != vm) && (NULL != curVm);
+         curVm = curVm->next) {
+        prevVm = curVm;
+    }
+
+    if (curVm) {
+        if (prevVm) {
+            prevVm->next = curVm->next;
+        } else {
+            driver->vms = curVm->next;
+        }
+
+        driver->ninactivevms--;
+    }
+
+    lxcFreeVM(vm);
+}
+
+/* Save a container's config data into a persistent file */
+int lxcSaveConfig(virConnectPtr conn,
+                  lxc_driver_t *driver,
+                  lxc_vm_t *vm,
+                  lxc_vm_def_t *def)
+{
+    int rc = -1;
+    char *xmlDef;
+    int fd = -1;
+    int amtToWrite;
+
+    if (!(xmlDef = lxcGenerateXML(conn, driver, vm, def))) {
+        return -1;
+    }
+
+    if ((fd = open(vm->configFile,
+                  O_WRONLY | O_CREAT | O_TRUNC,
+                  S_IRUSR | S_IWUSR )) < 0) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("cannot create config file %s: %s"),
+                  vm->configFile, strerror(errno));
+        goto cleanup;
+    }
+
+    amtToWrite = strlen(xmlDef);
+    if (safewrite(fd, xmlDef, amtToWrite) < 0) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("cannot write config file %s: %s"),
+                 vm->configFile, strerror(errno));
+        goto cleanup;
+    }
+
+    if (close(fd) < 0) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("cannot save config file %s: %s"),
+                 vm->configFile, strerror(errno));
+        goto cleanup;
+    }
+
+    rc = 0;
+
+ cleanup:
+    if (fd != -1) {
+        close(fd);
+    }
+
+    free(xmlDef);
+
+    return rc;
+}
+
+int lxcSaveVMDef(virConnectPtr conn,
+                 lxc_driver_t *driver,
+                 lxc_vm_t *vm,
+                 lxc_vm_def_t *def)
+{
+    int rc = -1;
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+    if (vm->configFile[0] == '\0') {
+        if ((rc = virFileMakePath(driver->configDir))) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("cannot create config directory %s: %s"),
+                     driver->configDir, strerror(rc));
+            goto save_complete;
+        }
+
+        virUUIDFormat(def->uuid, uuidstr);
+        if (virFileBuildPath(driver->configDir, uuidstr, ".xml",
+                            vm->configFile, PATH_MAX) < 0) {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("cannot construct config file path"));
+            goto save_complete;
+        }
+
+        strncpy(vm->configFileBase, uuidstr, PATH_MAX);
+        strncat(vm->configFileBase, ".xml", PATH_MAX - strlen(uuidstr));
+
+    }
+
+    rc = lxcSaveConfig(conn, driver, vm, def);
+
+save_complete:
+    return rc;
+}
+
+
+
+static lxc_vm_t * lxcLoadConfig(lxc_driver_t *driver,
+                                const char *file,
+                                const char *fullFilePath,
+                                const char *xmlData)
+{
+    lxc_vm_def_t *containerDef;
+    lxc_vm_t * vm;
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+    containerDef = lxcParseVMDef(NULL, xmlData, file);
+    if (NULL == containerDef) {
+        DEBUG0("Error parsing container config");
+        return NULL;
+    }
+
+    virUUIDFormat(containerDef->uuid, uuidstr);
+    if (!virFileMatchesNameSuffix(file, uuidstr, ".xml")) {
+        DEBUG0("Container uuid does not match config file name");
+        lxcFreeVMDef(containerDef);
+        return NULL;
+    }
+
+    vm = lxcAssignVMDef(NULL, driver, containerDef);
+    if (NULL == vm) {
+        DEBUG0("Failed to load container config");
+        lxcFreeVMDef(containerDef);
+        return NULL;
+    }
+
+    strncpy(vm->configFile, fullFilePath, PATH_MAX);
+    vm->configFile[PATH_MAX-1] = '\0';
+
+    strncpy(vm->configFileBase, file, PATH_MAX);
+    vm->configFile[PATH_MAX-1] = '\0';
+
+    return vm;
+}
+
+int lxcLoadDriverConfig(virConnectPtr conn)
+{
+    lxc_driver_t *driverPtr = (lxc_driver_t*)conn->privateData;
+
+    /* Set the container configuration directory */
+    driverPtr->configDir = strdup(SYSCONF_DIR "/libvirt/lxc");
+    if (NULL == driverPtr->configDir) {
+        lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "configDir");
+        return -1;
+    }
+
+    return 0;
+}
+
+int lxcLoadContainerConfigFile(lxc_driver_t *driver,
+                               const char *file)
+{
+    int rc = -1;
+    char tempPath[PATH_MAX];
+    char* xmlData;
+
+    rc = virFileBuildPath(driver->configDir, file, NULL, tempPath,
+                          PATH_MAX);
+    if (0 > rc) {
+        DEBUG0("config file name too long");
+        goto load_complete;
+    }
+
+    if ((rc = virFileReadAll(tempPath, LXC_MAX_XML_LENGTH, &xmlData)) < 0) {
+        goto load_complete;
+    }
+
+    lxcLoadConfig(driver, file, tempPath, xmlData);
+
+    free(xmlData);
+
+load_complete:
+    return rc;
+}
+
+int lxcLoadContainerInfo(virConnectPtr conn)
+{
+    int rc = -1;
+    lxc_driver_t *driverPtr = (lxc_driver_t*)conn->privateData;
+    DIR *dir;
+    struct dirent *dirEntry;
+
+    if (!(dir = opendir(driverPtr->configDir))) {
+        if (ENOENT == errno) {
+            /* no config dir => no containers */
+            rc = 0;
+        } else {
+            lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                     _("failed to open config directory: %s"), strerror(errno));
+        }
+
+        goto load_complete;
+    }
+
+    while ((dirEntry = readdir(dir))) {
+        if (dirEntry->d_name[0] == '.') {
+            continue;
+        }
+
+        if (!virFileHasSuffix(dirEntry->d_name, ".xml")) {
+            continue;
+        }
+
+        lxcLoadContainerConfigFile(driverPtr, dirEntry->d_name);
+    }
+
+    closedir(dir);
+
+    rc = 0;
+
+load_complete:
+    return rc;
+}
+
+/* Generate an XML document describing the vm's configuration */
+char *lxcGenerateXML(virConnectPtr conn,
+                     lxc_driver_t *driver ATTRIBUTE_UNUSED,
+                     lxc_vm_t *vm,
+                     lxc_vm_def_t *def)
+{
+    virBufferPtr buf = 0;
+    unsigned char *uuid;
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+    lxc_mount_t *mount;
+
+    buf = virBufferNew(LXC_MAX_XML_LENGTH);
+    if (!buf) {
+        goto no_memory;
+    }
+
+    if (lxcIsActiveVM(vm)) {
+        if (virBufferVSprintf(buf, "<domain type='linuxcontainer' id='%d'>\n",
+                             vm->def->id) < 0) {
+            goto no_memory;
+        }
+    } else {
+        if (virBufferAddLit(buf, "<domain type='linuxcontainer'>\n") < 0) {
+            goto no_memory;
+        }
+    }
+
+    if (virBufferVSprintf(buf, "    <name>%s</name>\n", def->name) < 0) {
+        goto no_memory;
+    }
+
+    uuid = def->uuid;
+    virUUIDFormat(uuid, uuidstr);
+    if (virBufferVSprintf(buf, "    <uuid>%s</uuid>\n", uuidstr) < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferAddLit(buf, "    <os>\n") < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferVSprintf(buf, "        <init>%s</init>\n", def->init) < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferAddLit(buf, "    </os>\n") < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferVSprintf(buf, "    <memory>%d</memory>\n", def->maxMemory) < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferAddLit(buf, "    <devices>\n") < 0) {
+        goto no_memory;
+    }
+
+    /* loop adding mounts */
+    for (mount = def->mounts; mount; mount = mount->next) {
+        if (virBufferAddLit(buf, "        <filesystem type='mount'>\n") < 0) {
+            goto no_memory;
+        }
+
+        if (virBufferVSprintf(buf, "            <source dir='%s'/>\n",
+                              mount->source) < 0) {
+            goto no_memory;
+        }
+
+        if (virBufferVSprintf(buf, "            <target dir='%s'/>\n",
+                              mount->target) < 0) {
+            goto no_memory;
+        }
+
+        if (virBufferAddLit(buf, "        </filesystem>\n") < 0) {
+            goto no_memory;
+        }
+
+    }
+
+    if (virBufferVSprintf(buf, "        <console tty='%s'/>\n", def->tty) < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferAddLit(buf, "    </devices>\n") < 0) {
+        goto no_memory;
+    }
+
+    if (virBufferAddLit(buf, "</domain>\n") < 0) {
+        goto no_memory;
+    }
+
+    return virBufferContentAndFree(buf);
+
+no_memory:
+    lxcError(conn, NULL, VIR_ERR_NO_MEMORY, "generateXml");
+    virBufferFree(buf);
+
+    return NULL;
+}
+
+void lxcFreeVMDef(lxc_vm_def_t *vmdef)
+{
+    lxc_mount_t *curMount = vmdef->mounts;
+    lxc_mount_t *nextMount;
+
+    while (curMount) {
+        nextMount = curMount->next;
+        free(curMount);
+        curMount = nextMount;
+    }
+
+    free(vmdef->name);
+    vmdef->name = NULL;
+
+}
+
+void lxcFreeVMs(lxc_vm_t *vms)
+{
+    lxc_vm_t *curVm = vms;
+    lxc_vm_t *nextVm;
+
+    while (curVm) {
+        lxcFreeVM(curVm);
+        nextVm = curVm->next;
+        free(curVm);
+        curVm = nextVm;
+    }
+}
+
+void lxcFreeVM(lxc_vm_t *vm)
+{
+    lxcFreeVMDef(vm->def);
+    free(vm->def);
+}
+
+lxc_vm_t *lxcFindVMByID(const lxc_driver_t *driver, int id)
+{
+    lxc_vm_t *vm;
+
+    for (vm = driver->vms; vm; vm = vm->next) {
+        if (lxcIsActiveVM(vm) && (vm->def->id == id)) {
+            return vm;
+        }
+
+    }
+
+    return NULL;
+}
+
+lxc_vm_t *lxcFindVMByUUID(const lxc_driver_t *driver,
+                          const unsigned char *uuid)
+{
+    lxc_vm_t *vm;
+
+    for (vm = driver->vms; vm; vm = vm->next) {
+        if (!memcmp(vm->def->uuid, uuid, VIR_UUID_BUFLEN)) {
+            return vm;
+        }
+    }
+
+    return NULL;
+}
+
+lxc_vm_t *lxcFindVMByName(const lxc_driver_t *driver,
+                          const char *name)
+{
+    lxc_vm_t *vm;
+
+    for (vm = driver->vms; vm; vm = vm->next) {
+        if (STREQ(vm->def->name, name)) {
+            return vm;
+        }
+    }
+
+    return NULL;
+}
+
+int lxcDeleteConfig(virConnectPtr conn,
+                    lxc_driver_t *driver ATTRIBUTE_UNUSED,
+                    const char *configFile,
+                    const char *name)
+{
+    if (!configFile[0]) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("no config file for %s"), name);
+        return -1;
+    }
+
+    if (unlink(configFile) < 0) {
+        lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
+                 _("cannot remove config for %s"), name);
+        return -1;
+    }
+
+    return 0;
+}
+
+#endif /* WITH_LXC */
+

