ims-volte-vowifi
/
strongswan
9
0
Fork 0
Code Pull Requests Releases Activity

first simple prototype of a UCI configuration plugin for OpenWRT

laforge/swu
Martin Willi 2008-06-17 14:17:51 +00:00
parent 285152b33d
commit 61c4638646
11 changed files with 944 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
configure.in
View 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

5
src/charon/Makefile.am
View File

@ -185,5 +185,10 @@ if USE_MEDCLI
PLUGINS += medcli
endif
if USE_UCI
SUBDIRS += plugins/uci
PLUGINS += uci
endif
AM_CFLAGS += -DPLUGINS=\""${PLUGINS}\""

13
src/charon/plugins/uci/Makefile.am Normal file
View File

@ -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

247
src/charon/plugins/uci/uci_config.c Normal file
View File

@ -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;
}

57
src/charon/plugins/uci/uci_config.h Normal file
View File

@ -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_ @}*/

170
src/charon/plugins/uci/uci_creds.c Normal file
View File

@ -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;
}

57
src/charon/plugins/uci/uci_creds.h Normal file
View File

@ -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_ @}*/

181
src/charon/plugins/uci/uci_parser.c Normal file
View File

@ -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;
}

62
src/charon/plugins/uci/uci_parser.h Normal file
View File

@ -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_ @}*/

87
src/charon/plugins/uci/uci_plugin.c Normal file
View File

@ -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;
}

50
src/charon/plugins/uci/uci_plugin.h Normal file
View File

@ -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_ @}*/