src/manager/controller/config_controller.c

   1 /**
   2  * @file config_controller.c
   3  *
   4  * @brief Implementation of config_controller_t.
   5  *
   6  */
   7
   8 /*
   9  * Copyright (C) 2007 Martin Willi
  10  * Hochschule fuer Technik Rapperswil
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by the
  14  * Free Software Foundation; either version 2 of the License, or (at your
  15  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  19  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  * for more details.
  21  */
  22
  23 #include "config_controller.h"
  24 #include "../manager.h"
  25 #include "../gateway.h"
  26
  27 #include <xml.h>
  28
  29 #include <library.h>
  30
  31
  32 typedef struct private_config_controller_t private_config_controller_t;
  33
  34 /**
  35  * private data of the task manager
  36  */
  37 struct private_config_controller_t {
  38
  39         /**
  40          * public functions
  41          */
  42         config_controller_t public;
  43
  44         /**
  45          * manager instance
  46          */
  47         manager_t *manager;
  48 };
  49
  50 /**
  51  * read XML of a peerconfig element and fill template
  52  */
  53 static void process_peerconfig(private_config_controller_t *this,
  54                                                            enumerator_t *e, request_t *r)
  55 {
  56         xml_t *xml;
  57         enumerator_t *e1, *e2, *e3;
  58         char *name, *value, *config = "", *child = "", *section = "";
  59
  60         while (e->enumerate(e, &xml, &name, &value))
  61         {
  62                 if (streq(name, "name"))
  63                 {
  64                         config = value;
  65                 }
  66                 else if (streq(name, "ikeconfig"))
  67                 {
  68                         e1 = xml->children(xml);
  69                         while (e1->enumerate(e1, &xml, &name, &value))
  70                         {
  71                                 if (streq(name, "local") || streq(name, "remote"))
  72                                 {
  73                                         r->setf(r, "peercfgs.%s.ikecfg.%s=%s", config, name, value);
  74                                 }
  75                         }
  76                         e1->destroy(e1);
  77                 }
  78                 else if (streq(name, "childconfiglist"))
  79                 {
  80                         e1 = xml->children(xml);
  81                         while (e1->enumerate(e1, &xml, &name, &value))
  82                         {
  83                                 if (streq(name, "childconfig"))
  84                                 {
  85                                         int num = 0;
  86
  87                                         e2 = xml->children(xml);
  88                                         while (e2->enumerate(e2, &xml, &name, &value))
  89                                         {
  90                                                 if (streq(name, "name"))
  91                                                 {
  92                                                         child = value;
  93                                                 }
  94                                                 else if (streq(name, "local") || streq(name, "remote"))
  95                                                 {
  96                                                         section = name;
  97                                                         e3 = xml->children(xml);
  98                                                         while (e3->enumerate(e3, &xml, &name, &value))
  99                                                         {
 100                                                                 if (streq(name, "network"))
 101                                                                 {
 102                                                                         r->setf(r, "peercfgs.%s.childcfgs.%s.%s.networks.%d=%s",
 103                                                                                         config, child, section, ++num, value);
 104                                                                 }
 105                                                         }
 106                                                         e3->destroy(e3);
 107                                                 }
 108                                         }
 109                                         e2->destroy(e2);
 110                                 }
 111                         }
 112                         e1->destroy(e1);
 113                 }
 114                 else
 115                 {
 116                         r->setf(r, "peercfgs.%s.%s=%s", config, name, value);
 117                 }
 118         }
 119 }
 120
 121 static void list(private_config_controller_t *this, request_t *r)
 122 {
 123         gateway_t *gateway;
 124         xml_t *xml;
 125         enumerator_t *e1, *e2;
 126         char *name, *value;
 127
 128         gateway = this->manager->select_gateway(this->manager, 0);
 129         e1 = gateway->query_configlist(gateway);
 130         if (e1 == NULL)
 131         {
 132                 r->set(r, "title", "Error");
 133                 r->set(r, "error", "querying the gateway failed");
 134                 r->render(r, "templates/error.cs");
 135         }
 136         else
 137         {
 138                 r->set(r, "title", "Configuration overview");
 139
 140                 while (e1->enumerate(e1, &xml, &name, &value))
 141                 {
 142                         if (streq(name, "peerconfig"))
 143                         {
 144                                 e2 = xml->children(xml);
 145                                 process_peerconfig(this, e2, r);
 146                                 e2->destroy(e2);
 147                         }
 148                 }
 149                 e1->destroy(e1);
 150
 151                 r->render(r, "templates/config/list.cs");
 152         }
 153 }
 154
 155 /**
 156  * Implementation of controller_t.get_name
 157  */
 158 static char* get_name(private_config_controller_t *this)
 159 {
 160         return "config";
 161 }
 162
 163 /**
 164  * Implementation of controller_t.handle
 165  */
 166 static void handle(private_config_controller_t *this,
 167                                    request_t *request, char *action)
 168 {
 169         if (!this->manager->logged_in(this->manager))
 170         {
 171                 return request->redirect(request, "auth/login");
 172         }
 173         if (this->manager->select_gateway(this->manager, 0) == NULL)
 174         {
 175                 return request->redirect(request, "gateway/list");
 176         }
 177         if (action)
 178         {
 179                 if (streq(action, "list"))
 180                 {
 181                         return list(this, request);
 182                 }
 183         }
 184         return request->redirect(request, "config/list");
 185 }
 186
 187 /**
 188  * Implementation of controller_t.destroy
 189  */
 190 static void destroy(private_config_controller_t *this)
 191 {
 192         free(this);
 193 }
 194
 195 /*
 196  * see header file
 197  */
 198 controller_t *config_controller_create(context_t *context, void *param)
 199 {
 200         private_config_controller_t *this = malloc_thing(private_config_controller_t);
 201
 202         this->public.controller.get_name = (char*(*)(controller_t*))get_name;
 203         this->public.controller.handle = (void(*)(controller_t*,request_t*,char*,char*,char*,char*,char*))handle;
 204         this->public.controller.destroy = (void(*)(controller_t*))destroy;
 205
 206         this->manager = (manager_t*)context;
 207
 208         return &this->public.controller;
 209 }
 210