fixed scenario loading
[strongswan.git] / src / dumm / dumm.c
index 3246284..560ab8d 100644 (file)
 #define _GNU_SOURCE
 
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <dirent.h>
+#include <errno.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlwriter.h>
 
 #include <debug.h>
 
 #include "dumm.h"
 
+#define PERME (S_IRWXU | S_IRWXG)
+#define GUEST_DIR "guests"
+#define TEMPLATE_DIR "templates"
+#define TEMPLATE_DIR_DIR "diff"
+
 /**
  * instances of dumm, used to deliver signals
  */
@@ -36,6 +45,12 @@ struct private_dumm_t {
        dumm_t public;
        /** working dir */
        char *dir;
+       /** directory of guests */
+       char *guest_dir;
+       /** directory of templates */
+       char *template_dir;
+       /** directory of loaded template */
+       char *template;
        /** list of managed guests */
        linked_list_t *guests;
        /** list of managed bridges */
@@ -52,7 +67,7 @@ static guest_t* create_guest(private_dumm_t *this, char *name, char *kernel,
 {
        guest_t *guest;
        
-       guest = guest_create(this->dir, name, kernel, master, mem);
+       guest = guest_create(this->guest_dir, name, kernel, master, mem);
        if (guest)
        {
                this->guests->insert_last(this->guests, guest);
@@ -92,6 +107,85 @@ static iterator_t* create_bridge_iterator(private_dumm_t *this)
 }
 
 /**
+ * disable the currently enabled template 
+ */
+static void clear_template(private_dumm_t *this)
+{
+       iterator_t *iterator, *ifaces;
+       guest_t *guest;
+       iface_t *iface;
+
+       free(this->template);
+       this->template = NULL;
+
+       iterator = this->guests->create_iterator(this->guests, TRUE);
+       while (iterator->iterate(iterator, (void**)&guest))
+       {
+               guest->load_template(guest, NULL);
+               ifaces = guest->create_iface_iterator(guest);
+               while (ifaces->iterate(ifaces, (void**)&iface))
+               {
+                       ifaces->remove(ifaces);
+                       iface->destroy(iface);
+               }
+               ifaces->destroy(ifaces);
+       }
+       iterator->destroy(iterator);
+}
+
+/**
+ * Implementation of dumm_t.load_template.
+ */
+static bool load_template(private_dumm_t *this, char *name)
+{
+       iterator_t *iterator;
+       guest_t *guest;
+       char dir[PATH_MAX];
+       size_t len;
+       
+       clear_template(this);
+       
+       if (name == NULL)
+       {
+               return TRUE;
+       }
+
+       free(this->template);
+       asprintf(&this->template, "%s/%s", this->template_dir, name);
+       len = snprintf(dir, sizeof(dir), "%s/%s", this->template, TEMPLATE_DIR_DIR);
+       if (len < 0 || len >= sizeof(dir))
+       {
+               return FALSE;
+       }
+       
+       if (access(this->template, F_OK) != 0)
+       {       /* does not exist, create template */
+               if (mkdir(this->template, PERME) != 0)
+               {
+                       DBG1("creating template directory '%s' failed: %m", this->template);
+                       return FALSE;
+               }
+               if (mkdir(dir, PERME) != 0)
+               {
+                       DBG1("creating template overlay directory '%s' failed: %m", dir);
+                       return FALSE;
+               }
+       }
+       iterator = this->guests->create_iterator(this->guests, TRUE);
+       while (iterator->iterate(iterator, (void**)&guest))
+       {
+               if (!guest->load_template(guest, dir))
+               {
+                       iterator->destroy(iterator);
+                       clear_template(this);
+                       return FALSE;
+               }
+       }
+       iterator->destroy(iterator);
+       return TRUE;
+}
+
+/**
  * signal handler 
  */
 void signal_handler(int sig, siginfo_t *info, void *ucontext)
@@ -205,6 +299,9 @@ static void destroy(private_dumm_t *this)
        
        this->destroying = TRUE;
        this->guests->destroy_offset(this->guests, offsetof(guest_t, destroy));
+       free(this->guest_dir);
+       free(this->template_dir);
+       free(this->template);
        free(this->dir);
        remove_instance(this);
        free(this);
@@ -219,7 +316,7 @@ static void load_guests(private_dumm_t *this)
        struct dirent *ent;
        guest_t *guest;
        
-       dir = opendir(this->dir);
+       dir = opendir(this->guest_dir);
        if (dir == NULL)
        {
                return;
@@ -231,9 +328,10 @@ static void load_guests(private_dumm_t *this)
                {
                        continue;
                }
-               guest = guest_load(this->dir, ent->d_name);
+               guest = guest_load(this->guest_dir, ent->d_name);
                if (guest)
                {
+                       DBG1("loaded guest '%s'", ent->d_name);
                        this->guests->insert_last(this->guests, guest);
                }
                else
@@ -256,6 +354,7 @@ dumm_t *dumm_create(char *dir)
        this->public.create_guest_iterator = (iterator_t*(*)(dumm_t*))create_guest_iterator;
        this->public.create_bridge = (bridge_t*(*)(dumm_t*, char *name))create_bridge;
        this->public.create_bridge_iterator = (iterator_t*(*)(dumm_t*))create_bridge_iterator;
+       this->public.load_template = (bool(*)(dumm_t*, char *name))load_template;
        this->public.destroy = (void(*)(dumm_t*))destroy;
        
        this->destroying = FALSE;
@@ -267,11 +366,27 @@ dumm_t *dumm_create(char *dir)
        {
                asprintf(&this->dir, "%s/%s", cwd, dir);
        }
+       this->template = NULL;
+       asprintf(&this->guest_dir, "%s/%s", this->dir, GUEST_DIR);
+       asprintf(&this->template_dir, "%s/%s", this->dir, TEMPLATE_DIR);
        this->guests = linked_list_create();
        this->bridges = linked_list_create();
        
        add_instance(this);
        
+       if (mkdir(this->guest_dir, PERME) < 0 && errno != EEXIST)
+       {
+               DBG1("creating guest directory '%s' failed: %m", this->guest_dir);
+               destroy(this);
+               return NULL;
+       }
+       if (mkdir(this->template_dir, PERME) < 0 && errno != EEXIST)
+       {
+               DBG1("creating template directory '%s' failed: %m", this->template_dir);
+               destroy(this);
+               return NULL;
+       }
+       
        load_guests(this);
        return &this->public;
 }