first simple prototype of a UCI configuration plugin for OpenWRT
authorMartin Willi <martin@strongswan.org>
Tue, 17 Jun 2008 14:17:51 +0000 (14:17 -0000)
committerMartin Willi <martin@strongswan.org>
Tue, 17 Jun 2008 14:17:51 +0000 (14:17 -0000)
configure.in
src/charon/Makefile.am
src/charon/plugins/uci/Makefile.am [new file with mode: 0644]
src/charon/plugins/uci/uci_config.c [new file with mode: 0644]
src/charon/plugins/uci/uci_config.h [new file with mode: 0644]
src/charon/plugins/uci/uci_creds.c [new file with mode: 0644]
src/charon/plugins/uci/uci_creds.h [new file with mode: 0644]
src/charon/plugins/uci/uci_parser.c [new file with mode: 0644]
src/charon/plugins/uci/uci_parser.h [new file with mode: 0644]
src/charon/plugins/uci/uci_plugin.c [new file with mode: 0644]
src/charon/plugins/uci/uci_plugin.h [new file with mode: 0644]

index 064d0c4..30f0312 100644 (file)
@@ -555,6 +555,14 @@ AC_ARG_ENABLE(
        fi],
 )
 
+AC_ARG_ENABLE(
+       [uci],
+       AS_HELP_STRING([--enable-uci],[enable OpenWRT UCI configuration plugin (default is NO).]),
+       [if test x$enableval = xyes; then
+               uci=true
+       fi]
+)
+
 dnl =========================
 dnl  check required programs
 dnl =========================
@@ -683,6 +691,11 @@ if test x$openssl = xtrue; then
        AC_CHECK_HEADER([openssl/evp.h],,[AC_MSG_ERROR([OpenSSL header openssl/evp.h not found!])])
 fi
 
+if test x$uci = xtrue; then
+       AC_HAVE_LIBRARY([uci],[LIBS="$LIBS"],[AC_MSG_ERROR([UCI library libuci not found])])
+       AC_CHECK_HEADER([uci.h],,[AC_MSG_ERROR([UCI header uci.h not found!])])
+fi
+
 dnl ======================================
 dnl  collect all plugins for libstrongswan
 dnl ======================================
@@ -776,6 +789,7 @@ dnl ==============
 AM_CONDITIONAL(USE_STROKE, test x$stroke = xtrue)
 AM_CONDITIONAL(USE_MEDSRV, test x$medsrv = xtrue)
 AM_CONDITIONAL(USE_MEDCLI, test x$medcli = xtrue)
+AM_CONDITIONAL(USE_UCI, test x$uci = xtrue)
 AM_CONDITIONAL(USE_SMP, test x$smp = xtrue)
 AM_CONDITIONAL(USE_SQL, test x$sql = xtrue)
 AM_CONDITIONAL(USE_UNIT_TESTS, test x$unittest = xtrue)
@@ -853,6 +867,7 @@ AC_OUTPUT(
        src/charon/plugins/sql/Makefile
        src/charon/plugins/medsrv/Makefile
        src/charon/plugins/medcli/Makefile
+       src/charon/plugins/uci/Makefile
        src/charon/plugins/stroke/Makefile
        src/charon/plugins/unit_tester/Makefile
        src/stroke/Makefile
index 7ddd117..8301c43 100644 (file)
@@ -185,5 +185,10 @@ if USE_MEDCLI
   PLUGINS += medcli
 endif
 
+if USE_UCI
+       SUBDIRS += plugins/uci
+       PLUGINS += uci
+endif
+
 AM_CFLAGS += -DPLUGINS=\""${PLUGINS}\""
 
diff --git a/src/charon/plugins/uci/Makefile.am b/src/charon/plugins/uci/Makefile.am
new file mode 100644 (file)
index 0000000..47a55ae
--- /dev/null
@@ -0,0 +1,13 @@
+
+INCLUDES = -I$(top_srcdir)/src/libstrongswan -I$(top_srcdir)/src/charon
+
+AM_CFLAGS = -rdynamic
+
+plugin_LTLIBRARIES = libstrongswan-uci.la
+libstrongswan_uci_la_SOURCES = \
+  uci_plugin.h uci_plugin.c uci_parser.h uci_parser.c \
+  uci_config.h uci_config.c uci_creds.h uci_creds.c
+libstrongswan_uci_la_LDFLAGS = -module
+libstrongswan_uci_la_LIBADD = -luci
+
+
diff --git a/src/charon/plugins/uci/uci_config.c b/src/charon/plugins/uci/uci_config.c
new file mode 100644 (file)
index 0000000..8f35ccc
--- /dev/null
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Copyright (C) 2008 Tobias Brunner
+ * Copyright (C) 2008 Martin Willi
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+#include "uci_config.h"
+#include "uci_parser.h"
+
+#include <daemon.h>
+
+typedef struct private_uci_config_t private_uci_config_t;
+
+/**
+ * Private data of an uci_config_t object
+ */
+struct private_uci_config_t {
+
+       /**
+        * Public part
+        */
+       uci_config_t public;
+       
+       /**
+        * UCI parser context
+        */
+       uci_parser_t *parser;
+};
+
+/**
+ * enumerator implementation for create_peer_cfg_enumerator
+ */
+typedef struct {
+       /** implements enumerator */
+       enumerator_t public;
+       /** currently enumerated peer config */
+       peer_cfg_t *peer_cfg;
+       /** inner uci_parser section enumerator */
+       enumerator_t *inner;
+} peer_enumerator_t;
+
+/**
+ * Implementation of peer_enumerator_t.public.enumerate
+ */
+static bool peer_enumerator_enumerate(peer_enumerator_t *this, peer_cfg_t **cfg)
+{
+       char *name, *local_id, *remote_ip;
+       child_cfg_t *child_cfg;
+       ike_cfg_t *ike_cfg;
+       
+       /* defaults */
+       name = "unnamed";
+       local_id = "%any";
+       remote_ip = "0.0.0.0";
+       
+       if (this->inner->enumerate(this->inner, &name, &local_id, &remote_ip))
+       {
+               DESTROY_IF(this->peer_cfg);
+               ike_cfg = ike_cfg_create(FALSE, FALSE, "0.0.0.0", remote_ip);
+               ike_cfg->add_proposal(ike_cfg, proposal_create_default(PROTO_IKE));
+               this->peer_cfg = peer_cfg_create(
+                                       name, 2, ike_cfg,
+                                       identification_create_from_string(local_id),
+                                       identification_create_from_encoding(ID_ANY, chunk_empty),
+                                       CERT_SEND_IF_ASKED, UNIQUE_NO, CONF_AUTH_PSK,
+                                       0, 0,                           /* EAP method, vendor */
+                                       1, 3600*12, 0,          /* keytries, rekey, reauth */
+                                       3600, 1800,                     /* jitter, overtime */
+                                       TRUE, 60,                       /* mobike, dpddelay */
+                                       NULL, NULL,             /* vip, pool */
+                                       FALSE, NULL, NULL); /* mediation, med by, peer id */
+               child_cfg = child_cfg_create(
+                                       name, 3600*4, 3600*3, 360, NULL, TRUE,
+                                       MODE_TUNNEL, ACTION_NONE, ACTION_NONE, FALSE);
+               child_cfg->add_proposal(child_cfg, proposal_create_default(PROTO_ESP));
+               child_cfg->add_traffic_selector(child_cfg, TRUE,
+                                                               traffic_selector_create_dynamic(0, 0, 65535));
+               child_cfg->add_traffic_selector(child_cfg, FALSE,
+                                                               traffic_selector_create_dynamic(0, 0, 65535));
+               this->peer_cfg->add_child_cfg(this->peer_cfg, child_cfg);
+               *cfg = this->peer_cfg;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+/**
+ * Implementation of peer_enumerator_t.public.destroy
+ */
+static void peer_enumerator_destroy(peer_enumerator_t *this)
+{
+       DESTROY_IF(this->peer_cfg);
+       this->inner->destroy(this->inner);
+       free(this);
+}
+
+/**
+ * Implementation of backend_t.create_peer_cfg_enumerator.
+ */
+static enumerator_t* create_peer_cfg_enumerator(private_uci_config_t *this,
+                                                                                               identification_t *me, 
+                                                                                               identification_t *other)
+{
+       peer_enumerator_t *e = malloc_thing(peer_enumerator_t);
+       
+       e->public.enumerate = (void*)peer_enumerator_enumerate;
+       e->public.destroy = (void*)peer_enumerator_destroy;
+       e->peer_cfg = NULL;
+       e->inner = this->parser->create_section_enumerator(this->parser, 
+                                                                               "local_id", "remote_ip", NULL);
+       if (!e->inner)
+       {
+               free(e);
+               return NULL;
+       }
+       return &e->public;
+}
+
+/**
+ * enumerator implementation for create_ike_cfg_enumerator
+ */
+typedef struct {
+       /** implements enumerator */
+       enumerator_t public;
+       /** currently enumerated ike config */
+       ike_cfg_t *ike_cfg;
+       /** inner uci_parser section enumerator */
+       enumerator_t *inner;
+} ike_enumerator_t;
+
+/**
+ * Implementation of peer_enumerator_t.public.enumerate
+ */
+static bool ike_enumerator_enumerate(ike_enumerator_t *this, ike_cfg_t **cfg)
+{
+       char *name, *remote_ip;
+       
+       /* defaults */
+       name = "unnamed";
+       remote_ip = "0.0.0.0";
+       
+       if (this->inner->enumerate(this->inner, &name, &remote_ip))
+       {
+               DESTROY_IF(this->ike_cfg);
+               this->ike_cfg = ike_cfg_create(FALSE, FALSE, "0.0.0.0", remote_ip);
+               this->ike_cfg->add_proposal(this->ike_cfg,
+                                                                       proposal_create_default(PROTO_IKE));
+
+               *cfg = this->ike_cfg;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+/**
+ * Implementation of ike_enumerator_t.public.destroy
+ */
+static void ike_enumerator_destroy(ike_enumerator_t *this)
+{
+       DESTROY_IF(this->ike_cfg);
+       this->inner->destroy(this->inner);
+       free(this);
+}
+
+/**
+ * Implementation of backend_t.create_ike_cfg_enumerator.
+ */
+static enumerator_t* create_ike_cfg_enumerator(private_uci_config_t *this,
+                                                                                          host_t *me, host_t *other)
+{
+       ike_enumerator_t *e = malloc_thing(ike_enumerator_t);
+       
+       e->public.enumerate = (void*)ike_enumerator_enumerate;
+       e->public.destroy = (void*)ike_enumerator_destroy;
+       e->ike_cfg = NULL;
+       e->inner = this->parser->create_section_enumerator(this->parser, 
+                                                                                               "remote_ip", NULL);
+       if (!e->inner)
+       {
+               free(e);
+               return NULL;
+       }
+       return &e->public;
+}
+
+/**
+ * implements backend_t.get_peer_cfg_by_name.
+ */
+static peer_cfg_t *get_peer_cfg_by_name(private_uci_config_t *this, char *name)
+{
+       enumerator_t *enumerator;
+       peer_cfg_t *current, *found = NULL;
+               
+       enumerator = create_peer_cfg_enumerator(this, NULL, NULL);
+       if (enumerator)
+       {
+               while (enumerator->enumerate(enumerator, &current))
+               {
+                       if (streq(name, current->get_name(current)))
+                       {
+                               found = current->get_ref(current);
+                               break;
+                       }
+               }
+               enumerator->destroy(enumerator);
+       }
+       return found;
+}
+
+/**
+ * Implementation of uci_config_t.destroy.
+ */
+static void destroy(private_uci_config_t *this)
+{
+       free(this);
+}
+
+/**
+ * Described in header.
+ */
+uci_config_t *uci_config_create(uci_parser_t *parser)
+{
+       private_uci_config_t *this = malloc_thing(private_uci_config_t);
+
+       this->public.backend.create_peer_cfg_enumerator = (enumerator_t*(*)(backend_t*, identification_t *me, identification_t *other))create_peer_cfg_enumerator;
+       this->public.backend.create_ike_cfg_enumerator = (enumerator_t*(*)(backend_t*, host_t *me, host_t *other))create_ike_cfg_enumerator;
+       this->public.backend.get_peer_cfg_by_name = (peer_cfg_t* (*)(backend_t*,char*))get_peer_cfg_by_name;
+       this->public.destroy = (void(*)(uci_config_t*))destroy;
+       
+       this->parser = parser;
+       
+       return &this->public;
+}
+
diff --git a/src/charon/plugins/uci/uci_config.h b/src/charon/plugins/uci/uci_config.h
new file mode 100644 (file)
index 0000000..4d8b286
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+/**
+ * @defgroup uci_config_t uci_config
+ * @{ @ingroup uci
+ */
+
+#ifndef UCI_CONFIG_H_
+#define UCI_CONFIG_H_
+
+#include "uci_parser.h"
+
+#include <config/backend.h>
+
+typedef struct uci_config_t uci_config_t;
+
+/**
+ * OpenWRT UCI configuration backend.
+ */
+struct uci_config_t {
+
+       /**
+        * Implements backend_t interface
+        */
+       backend_t backend;
+       
+       /**
+        * Destroy the backend.
+        */
+       void (*destroy)(uci_config_t *this);    
+};
+
+/**
+ * Create a UCI based configuration backend.
+ *
+ * @param parser       UCI parser to use
+ * @return                     configuration backend
+ */
+uci_config_t *uci_config_create(uci_parser_t *parser);
+
+#endif /* UCI_CONFIG_H_ @}*/
diff --git a/src/charon/plugins/uci/uci_creds.c b/src/charon/plugins/uci/uci_creds.c
new file mode 100644 (file)
index 0000000..f55980c
--- /dev/null
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+#include "uci_creds.h"
+
+#include <daemon.h>
+#include <credentials/keys/shared_key.h>
+#include <utils/identification.h>
+
+typedef struct private_uci_creds_t private_uci_creds_t;
+
+/**
+ * Private data of an uci_creds_t object
+ */
+struct private_uci_creds_t {
+       /**
+        * Public part
+        */
+       uci_creds_t public;
+       
+       /**
+        * UCI parser context
+        */
+       uci_parser_t *parser;
+};
+
+typedef struct {
+       /** implements enumerator */
+       enumerator_t public;
+       /** inneer UCI enumerator */
+       enumerator_t *inner;
+       /** currently enumerated shared shared */
+       shared_key_t *current;
+       /** local ID to match */
+       identification_t *me;
+       /** remote ID to match */
+       identification_t *other;
+} shared_enumerator_t;
+
+/**
+ * Implementation of shared_enumerator_t.public.enumerate
+ */
+static bool shared_enumerator_enumerate(shared_enumerator_t *this,
+                                               shared_key_t **key, id_match_t *me, id_match_t *other)
+{
+       char *local_id, *psk;
+       identification_t *local;
+
+       while (TRUE)
+       {
+               /* defaults */
+               local_id = "%any";
+               psk = NULL;
+               
+               if (!this->inner->enumerate(this->inner, NULL, &local_id, &psk))
+               {
+                       return FALSE;
+               }
+               if (psk == NULL)
+               {
+                       continue;
+               }
+               if (me)
+               {
+                       local = identification_create_from_string(local_id);
+                       if (!local)
+                       {
+                               continue;
+                       }
+                       *me = this->me ? this->me->matches(this->me, local) : ID_MATCH_ANY;
+                       local->destroy(local);
+                       if (!*me)
+                       {
+                               continue;
+                       }
+               }
+               break;
+       }
+       DESTROY_IF(this->current);
+       this->current = shared_key_create(SHARED_IKE,
+                                                               chunk_clone(chunk_create(psk, strlen(psk))));
+       *key = this->current;
+       if (other)
+       {
+               *other = ID_MATCH_ANY;
+       }
+       return TRUE;
+}
+
+/**
+ * Implementation of shared_enumerator_t.public.destroy
+ */
+static void shared_enumerator_destroy(shared_enumerator_t *this)
+{
+       this->inner->destroy(this->inner);
+       DESTROY_IF(this->current);
+       free(this);
+}
+
+/**
+ * Implementation of backend_t.create_shared_cfg_enumerator.
+ */
+static enumerator_t* create_shared_enumerator(private_uci_creds_t *this,
+                                                                                         shared_key_type_t type,
+                                                                                         identification_t *me, 
+                                                                                         identification_t *other)
+{
+       shared_enumerator_t *e;
+       
+       if (type != SHARED_IKE)
+       {
+               return NULL;
+       }
+       
+       e = malloc_thing(shared_enumerator_t);
+       e->current = NULL;
+       e->public.enumerate = (void*)shared_enumerator_enumerate;
+       e->public.destroy = (void*)shared_enumerator_destroy;
+       e->me = me;
+       e->other = other;
+       e->inner = this->parser->create_section_enumerator(this->parser, 
+                                                                                       "local_id", "psk", NULL);
+       if (!e->inner)
+       {
+               free(e);
+               return NULL;
+       }
+       return &e->public;
+}
+
+/**
+ * Implementation of uci_creds_t.destroy
+ */
+static void destroy(private_uci_creds_t *this)
+{
+       free(this);
+}
+
+uci_creds_t *uci_creds_create(uci_parser_t *parser)
+{
+       private_uci_creds_t *this = malloc_thing(private_uci_creds_t);
+
+       this->public.credential_set.create_shared_enumerator = (enumerator_t*(*)(credential_set_t*, shared_key_type_t, identification_t*, identification_t*))create_shared_enumerator;
+       this->public.credential_set.create_private_enumerator = (enumerator_t*(*) (credential_set_t*, key_type_t, identification_t*))return_null;
+       this->public.credential_set.create_cert_enumerator = (enumerator_t*(*) (credential_set_t*,      certificate_type_t, key_type_t,identification_t *, bool))return_null;
+       this->public.credential_set.create_cdp_enumerator  = (enumerator_t*(*) (credential_set_t *,certificate_type_t, identification_t *))return_null;
+       this->public.credential_set.cache_cert = (void (*)(credential_set_t *, certificate_t *))nop;
+       this->public.destroy = (void(*) (uci_creds_t*))destroy;
+       
+       this->parser = parser;
+
+       return &this->public;
+}
+
diff --git a/src/charon/plugins/uci/uci_creds.h b/src/charon/plugins/uci/uci_creds.h
new file mode 100644 (file)
index 0000000..cf82f1c
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+/**
+ * @defgroup uci_creds_t uci_creds
+ * @{ @ingroup uci
+ */
+
+#ifndef UCI_CREDS_H_
+#define UCI_CREDS_H_
+
+#include "uci_parser.h"
+
+#include <credentials/credential_set.h>
+
+typedef struct uci_creds_t uci_creds_t;
+
+/**
+ * OpenWRT UCI credential set implementation.
+ */
+struct uci_creds_t {
+
+       /**
+        * Implements credential set interface.
+        */
+       credential_set_t credential_set;
+       
+       /**
+        * Destroy the backend.
+        */
+       void (*destroy)(uci_creds_t *this);     
+};
+
+/**
+ * Create a UCI based credential set.
+ *
+ * @param parser       UCI parser to use
+ * @return                     credential set
+ */
+uci_creds_t *uci_creds_create(uci_parser_t *parser);
+
+#endif /* UCI_CREDS_H_ @}*/
diff --git a/src/charon/plugins/uci/uci_parser.c b/src/charon/plugins/uci/uci_parser.c
new file mode 100644 (file)
index 0000000..796d299
--- /dev/null
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+#include "uci_parser.h"
+
+#include <stdarg.h>
+
+#include <library.h>
+#include <uci.h>
+
+typedef struct private_uci_parser_t private_uci_parser_t;
+
+/**
+ * Private data of an uci_parser_t object
+ */
+struct private_uci_parser_t {
+
+       /**
+        * Public part
+        */
+       uci_parser_t public;
+       
+       /**
+        * UCI package name this parser reads
+        */
+       char *package;
+};
+
+/**
+ * enumerator implementation create_section_enumerator
+ */
+typedef struct {
+       /** implements enumerator */
+       enumerator_t public;
+       /** currently enumerated uci section */
+       struct uci_element *current;
+       /** all uci ipsec config sections */
+       struct uci_list *list;
+       /** uci conntext */
+       struct uci_context *ctx;
+       /** ipsec uci package */
+       struct uci_package *package;
+       /** NULL terminated list of keywords */
+       char *keywords[];
+} section_enumerator_t;
+
+/**
+ * Implementation of section_enumerator_t.enumerate
+ */
+static bool section_enumerator_enumerate(section_enumerator_t *this, ...)
+{
+       struct uci_element *element;
+       char **value;
+       va_list args;
+       int i;
+       
+       if (&this->current->list == this->list)
+       {
+               return FALSE;
+       }
+       
+       va_start(args, this);
+
+       /* name is first parameter */   
+       value = va_arg(args, char**);
+       if (value)
+       {
+               *value = uci_to_section(this->current)->type;
+       }
+       
+       /* followed by keyword parameters */
+       for (i = 0; this->keywords[i]; i++)
+       {
+               value = va_arg(args, char**);
+               if (value && uci_lookup(this->ctx, &element, this->package,
+                                                 this->current->name, this->keywords[i]) == UCI_OK)
+               {
+                       *value = uci_to_option(element)->value;
+               }
+       }
+       va_end(args);
+       
+       this->current = list_to_element(this->current->list.next);
+       return TRUE;
+}
+
+/**
+ * Implementation of section_enumerator_t.public.destroy
+ */
+static void section_enumerator_destroy(section_enumerator_t *this)
+{
+       uci_free_context(this->ctx);
+       free(this);
+}
+
+/**
+ * Implementation of backend_t.create_section_enumerator.
+ */
+static enumerator_t* create_section_enumerator(private_uci_parser_t *this, ...)
+{
+       section_enumerator_t *e;
+       va_list args;
+       int i;
+       
+       /* allocate enumerator large enought to hold keyword pointers */
+       i = 1;
+       va_start(args, this);
+       while (va_arg(args, char*))
+       {
+               i++;
+       }
+       va_end(args);
+       e = malloc(sizeof(section_enumerator_t) + sizeof(char*) * i);
+       i = 0;
+       va_start(args, this);
+       do 
+       {
+               e->keywords[i] = va_arg(args, char*);
+       }
+       while (e->keywords[i++]);
+       va_end(args);
+       
+       e->public.enumerate = (void*)section_enumerator_enumerate;
+       e->public.destroy = (void*)section_enumerator_destroy;
+       
+       /* load uci context */
+       e->ctx = uci_alloc_context();
+       if (uci_load(e->ctx, this->package, &e->package) != UCI_OK)
+       {
+               section_enumerator_destroy(e);
+               return NULL;
+       }
+       e->list = &e->package->sections;
+       e->current = list_to_element(e->list->next);
+       if (e->current->type != UCI_TYPE_SECTION)
+       {
+               section_enumerator_destroy(e);
+               return NULL;
+       }
+       return &e->public;
+}
+
+/**
+ * Implementation of uci_parser_t.destroy.
+ */
+static void destroy(private_uci_parser_t *this)
+{
+       free(this->package);
+       free(this);
+}
+
+/**
+ * Described in header.
+ */
+uci_parser_t *uci_parser_create(char *package)
+{
+       private_uci_parser_t *this = malloc_thing(private_uci_parser_t);
+
+       this->public.create_section_enumerator = (enumerator_t*(*)(uci_parser_t*, ...))create_section_enumerator;
+       this->public.destroy = (void(*)(uci_parser_t*))destroy;
+       
+       this->package = strdup(package);
+       
+       return &this->public;
+}
+
diff --git a/src/charon/plugins/uci/uci_parser.h b/src/charon/plugins/uci/uci_parser.h
new file mode 100644 (file)
index 0000000..a8633ca
--- /dev/null
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+/**
+ * @defgroup uci_parser_t uci_parser
+ * @{ @ingroup uci
+ */
+
+#ifndef UCI_PARSER_H_
+#define UCI_PARSER_H_
+
+#include <utils/enumerator.h>
+
+typedef struct uci_parser_t uci_parser_t;
+
+/**
+ * Wrapper to parse UCI sections with an enumerator.
+ */
+struct uci_parser_t {
+
+       /**
+        * Create an enumerator over a section.
+        *
+        * The enumerator returns a section name followed by values for the keywords
+        * specified in the variable argument list of this function.
+        *
+        * @param ...           variable argument list with keywords, NULL terminated
+        * @return                      enumerator over sections
+        */
+       enumerator_t* (*create_section_enumerator)(uci_parser_t *this, ...);
+       
+       /**
+        * Destroy the parser.
+        */
+       void (*destroy)(uci_parser_t *this);    
+};
+
+/**
+ * Create a UCI parser.
+ *
+ * @param package      UCI package this parser should read
+ * @return                     parser context
+ */
+uci_parser_t *uci_parser_create(char *package);
+
+#endif /* UCI_PARSER_H_ @}*/
+
diff --git a/src/charon/plugins/uci/uci_plugin.c b/src/charon/plugins/uci/uci_plugin.c
new file mode 100644 (file)
index 0000000..9185238
--- /dev/null
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+#include "uci_plugin.h"
+#include "uci_config.h"
+#include "uci_creds.h"
+
+#include <daemon.h>
+
+/**
+ * UCI package name to use for lookups
+ */
+#define UCI_PACKAGE "strongswan"
+
+typedef struct private_uci_plugin_t private_uci_plugin_t;
+
+/**
+ * private data of uci plugin
+ */
+struct private_uci_plugin_t {
+
+       /**
+        * implements plugin interface
+        */
+       uci_plugin_t public;
+       
+       /**
+        * UCI configuration backend
+        */
+       uci_config_t *config;
+       
+       /**
+        * UCI credential set implementation
+        */
+       uci_creds_t *creds;
+       
+       /**
+        * UCI parser wrapper
+        */
+       uci_parser_t *parser;
+};
+
+/**
+ * Implementation of plugin_t.destroy
+ */
+static void destroy(private_uci_plugin_t *this)
+{
+       charon->backends->remove_backend(charon->backends, &this->config->backend);
+       charon->credentials->remove_set(charon->credentials, &this->creds->credential_set);
+       this->config->destroy(this->config);
+       this->creds->destroy(this->creds);
+       this->parser->destroy(this->parser);
+       free(this);
+}
+
+/*
+ * see header file
+ */
+plugin_t *plugin_create()
+{
+       private_uci_plugin_t *this = malloc_thing(private_uci_plugin_t);
+       
+       this->public.plugin.destroy = (void(*)(plugin_t*))destroy;
+
+       this->parser = uci_parser_create(UCI_PACKAGE);
+       this->config = uci_config_create(this->parser);
+       this->creds = uci_creds_create(this->parser);
+       charon->backends->add_backend(charon->backends, &this->config->backend);
+       charon->credentials->add_set(charon->credentials, &this->creds->credential_set);
+       
+       return &this->public.plugin;
+}
+
diff --git a/src/charon/plugins/uci/uci_plugin.h b/src/charon/plugins/uci/uci_plugin.h
new file mode 100644 (file)
index 0000000..cac95dc
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2008 Thomas Kallenberg
+ * Copyright (C) 2008 Martin Willi
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ *
+ * $Id$
+ */
+
+/**
+ * @defgroup uci uci
+ * @ingroup cplugins
+ *
+ * @defgroup uci_plugin uci_plugin
+ * @{ @ingroup uci
+ */
+
+#ifndef UCI_PLUGIN_H_
+#define UCI_PLUGIN_H_
+
+#include <plugins/plugin.h>
+
+typedef struct uci_plugin_t uci_plugin_t;
+
+/**
+ * OpenWRT UCI (Unified Configuration Interface) configuration plugin.
+ */
+struct uci_plugin_t {
+
+       /**
+        * implements plugin interface
+        */
+       plugin_t plugin;
+};
+
+/**
+ * Create a uci_plugin instance.
+ */
+plugin_t *plugin_create();
+
+#endif /* UCI_PLUGIN_H_ @}*/