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 = "";
  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, "childcfg"))
  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                                                         e3 = xml->children(xml);
  97                                                         while (e3->enumerate(e3, &xml, &name, &value))
  98                                                         {
  99                                                                 if (streq(name, "network"))
 100                                                                 {
 101                                                                         r->setf(r, "peercfgs.%s.childcfgs.%s.%s.%d=%s",
 102                                                                                         config, child, name, ++num, value);
 103                                                                 }
 104                                                         }
 105                                                         e3->destroy(e3);
 106                                                 }
 107                                         }
 108                                         e2->destroy(e2);
 109                                 }
 110                         }
 111                         e1->destroy(e1);
 112                 }
 113                 else
 114                 {
 115                         r->setf(r, "peercfgs.%s.%s=%s", config, name, value);
 116                 }
 117         }
 118 }
 119
 120 static void list(private_config_controller_t *this, request_t *r)
 121 {
 122         gateway_t *gateway;
 123         xml_t *xml;
 124         enumerator_t *e1, *e2;
 125         char *name, *value;
 126
 127         gateway = this->manager->select_gateway(this->manager, 0);
 128         e1 = gateway->query_configlist(gateway);
 129         if (e1 == NULL)
 130         {
 131                 r->set(r, "title", "Error");
 132                 r->set(r, "error", "querying the gateway failed");
 133                 r->render(r, "templates/error.cs");
 134         }
 135         else
 136         {
 137                 r->set(r, "title", "Configuration overview");
 138
 139                 while (e1->enumerate(e1, &xml, &name, &value))
 140                 {
 141                         if (streq(name, "peerconfig"))
 142                         {
 143                                 e2 = xml->children(xml);
 144                                 process_peerconfig(this, e2, r);
 145                                 e2->destroy(e2);
 146                         }
 147                 }
 148                 e1->destroy(e1);
 149
 150                 r->render(r, "templates/config/list.cs");
 151         }
 152 }
 153
 154 /**
 155  * Implementation of controller_t.get_name
 156  */
 157 static char* get_name(private_config_controller_t *this)
 158 {
 159         return "config";
 160 }
 161
 162 /**
 163  * Implementation of controller_t.handle
 164  */
 165 static void handle(private_config_controller_t *this,
 166                                    request_t *request, char *action)
 167 {
 168         if (!this->manager->logged_in(this->manager))
 169         {
 170                 return request->redirect(request, "auth/login");
 171         }
 172         if (this->manager->select_gateway(this->manager, 0) == NULL)
 173         {
 174                 return request->redirect(request, "gateway/list");
 175         }
 176         if (action)
 177         {
 178                 if (streq(action, "list"))
 179                 {
 180                         return list(this, request);
 181                 }
 182         }
 183         return request->redirect(request, "config/list");
 184 }
 185
 186 /**
 187  * Implementation of controller_t.destroy
 188  */
 189 static void destroy(private_config_controller_t *this)
 190 {
 191         free(this);
 192 }
 193
 194 /*
 195  * see header file
 196  */
 197 controller_t *config_controller_create(context_t *context, void *param)
 198 {
 199         private_config_controller_t *this = malloc_thing(private_config_controller_t);
 200
 201         this->public.controller.get_name = (char*(*)(controller_t*))get_name;
 202         this->public.controller.handle = (void(*)(controller_t*,request_t*,char*,char*,char*,char*,char*))handle;
 203         this->public.controller.destroy = (void(*)(controller_t*))destroy;
 204
 205         this->manager = (manager_t*)context;
 206
 207         return &this->public.controller;
 208 }
 209