245 lines
6.4 KiB
C
245 lines
6.4 KiB
C
/**
|
|
* @file backend_manager.c
|
|
*
|
|
* @brief Implementation of backend_manager_t.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2007 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.
|
|
*/
|
|
|
|
#include "backend_manager.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#include <sys/stat.h>
|
|
#include <dlfcn.h>
|
|
|
|
#include <daemon.h>
|
|
#include <utils/linked_list.h>
|
|
#include <config/backends/writeable_backend.h>
|
|
|
|
|
|
typedef struct private_backend_manager_t private_backend_manager_t;
|
|
|
|
/**
|
|
* Private data of an backend_manager_t object.
|
|
*/
|
|
struct private_backend_manager_t {
|
|
|
|
/**
|
|
* Public part of backend_manager_t object.
|
|
*/
|
|
backend_manager_t public;
|
|
|
|
/**
|
|
* list of registered backends
|
|
*/
|
|
linked_list_t *backends;
|
|
|
|
/**
|
|
* Additional list of writable backends.
|
|
*/
|
|
linked_list_t *writeable;
|
|
|
|
/**
|
|
* List of dlopen() handles we used to open backends
|
|
*/
|
|
linked_list_t *handles;
|
|
};
|
|
|
|
/**
|
|
* implements backend_manager_t.get_ike_cfg.
|
|
*/
|
|
static ike_cfg_t *get_ike_cfg(private_backend_manager_t *this,
|
|
host_t *my_host, host_t *other_host)
|
|
{
|
|
backend_t *backend;
|
|
ike_cfg_t *config = NULL;
|
|
iterator_t *iterator = this->backends->create_iterator(this->backends, TRUE);
|
|
while (config == NULL && iterator->iterate(iterator, (void**)&backend))
|
|
{
|
|
config = backend->get_ike_cfg(backend, my_host, other_host);
|
|
}
|
|
iterator->destroy(iterator);
|
|
return config;
|
|
}
|
|
|
|
/**
|
|
* implements backend_manager_t.get_peer_cfg.
|
|
*/
|
|
static peer_cfg_t *get_peer_cfg(private_backend_manager_t *this,
|
|
identification_t *my_id, identification_t *other_id,
|
|
identification_t *other_ca, char *other_group,
|
|
host_t *my_host, host_t *other_host)
|
|
{
|
|
backend_t *backend;
|
|
peer_cfg_t *config = NULL;
|
|
iterator_t *iterator = this->backends->create_iterator(this->backends, TRUE);
|
|
while (config == NULL && iterator->iterate(iterator, (void**)&backend))
|
|
{
|
|
config = backend->get_peer_cfg(backend, my_id, other_id, other_ca,
|
|
other_group, my_host, other_host);
|
|
}
|
|
iterator->destroy(iterator);
|
|
return config;
|
|
}
|
|
|
|
/**
|
|
* implements backend_manager_t.add_peer_cfg.
|
|
*/
|
|
static void add_peer_cfg(private_backend_manager_t *this, peer_cfg_t *config)
|
|
{
|
|
writeable_backend_t *backend;
|
|
|
|
if (this->writeable->get_first(this->writeable, (void**)&backend) == SUCCESS)
|
|
{
|
|
backend->add_cfg(backend, config);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* implements backend_manager_t.create_iterator.
|
|
*/
|
|
static iterator_t* create_iterator(private_backend_manager_t *this)
|
|
{
|
|
writeable_backend_t *backend;
|
|
|
|
if (this->writeable->get_first(this->writeable, (void**)&backend) == SUCCESS)
|
|
{
|
|
return backend->create_iterator(backend);
|
|
}
|
|
/* give out an empty iterator if we have no writable backend*/
|
|
return this->writeable->create_iterator(this->writeable, TRUE);
|
|
}
|
|
|
|
/**
|
|
* load the configuration backend modules
|
|
*/
|
|
static void load_backends(private_backend_manager_t *this)
|
|
{
|
|
struct dirent* entry;
|
|
struct stat stb;
|
|
DIR* dir;
|
|
|
|
if (stat(IPSEC_BACKENDDIR, &stb) == -1 || !(stb.st_mode & S_IFDIR))
|
|
{
|
|
DBG1(DBG_CFG, "error opening backend modules directory "IPSEC_BACKENDDIR);
|
|
return;
|
|
}
|
|
|
|
dir = opendir(IPSEC_BACKENDDIR);
|
|
if (dir == NULL)
|
|
{
|
|
DBG1(DBG_CFG, "error opening backend modules directory "IPSEC_BACKENDDIR);
|
|
return;
|
|
}
|
|
|
|
DBG1(DBG_CFG, "loading backend modules from '"IPSEC_BACKENDDIR"'");
|
|
|
|
while ((entry = readdir(dir)) != NULL)
|
|
{
|
|
char file[256];
|
|
backend_t *backend;
|
|
backend_constructor_t constructor;
|
|
void *handle;
|
|
char *ending;
|
|
|
|
snprintf(file, sizeof(file), IPSEC_BACKENDDIR"/%s", entry->d_name);
|
|
|
|
if (stat(file, &stb) == -1 || !(stb.st_mode & S_IFREG))
|
|
{
|
|
DBG2(DBG_CFG, " skipping %s, doesn't look like a file",
|
|
entry->d_name);
|
|
continue;
|
|
}
|
|
ending = entry->d_name + strlen(entry->d_name) - 3;
|
|
if (ending <= entry->d_name || !streq(ending, ".so"))
|
|
{
|
|
/* skip anything which does not look like a library */
|
|
DBG2(DBG_CFG, " skipping %s, doesn't look like a library",
|
|
entry->d_name);
|
|
continue;
|
|
}
|
|
/* try to load the library */
|
|
handle = dlopen(file, RTLD_LAZY);
|
|
if (handle == NULL)
|
|
{
|
|
DBG1(DBG_CFG, " opening backend module %s failed: %s",
|
|
entry->d_name, dlerror());
|
|
continue;
|
|
}
|
|
constructor = dlsym(handle, "backend_create");
|
|
if (constructor == NULL)
|
|
{
|
|
DBG1(DBG_CFG, " backend module %s has no backend_create() "
|
|
"function, skipped", entry->d_name);
|
|
dlclose(handle);
|
|
continue;
|
|
}
|
|
|
|
backend = constructor();
|
|
if (backend == NULL)
|
|
{
|
|
DBG1(DBG_CFG, " unable to create instance of backend "
|
|
"module %s, skipped", entry->d_name);
|
|
dlclose(handle);
|
|
continue;
|
|
}
|
|
DBG1(DBG_CFG, " loaded backend module successfully from %s", entry->d_name);
|
|
this->backends->insert_last(this->backends, backend);
|
|
if (backend->is_writeable(backend))
|
|
{
|
|
this->writeable->insert_last(this->writeable, backend);
|
|
}
|
|
this->handles->insert_last(this->handles, handle);
|
|
}
|
|
closedir(dir);
|
|
}
|
|
|
|
/**
|
|
* Implementation of backend_manager_t.destroy.
|
|
*/
|
|
static void destroy(private_backend_manager_t *this)
|
|
{
|
|
this->backends->destroy_offset(this->backends, offsetof(backend_t, destroy));
|
|
this->writeable->destroy(this->writeable);
|
|
this->handles->destroy_function(this->handles, (void*)dlclose);
|
|
free(this);
|
|
}
|
|
|
|
/*
|
|
* Described in header-file
|
|
*/
|
|
backend_manager_t *backend_manager_create()
|
|
{
|
|
private_backend_manager_t *this = malloc_thing(private_backend_manager_t);
|
|
|
|
this->public.get_ike_cfg = (ike_cfg_t*(*)(backend_manager_t*, host_t *, host_t *))get_ike_cfg;
|
|
this->public.get_peer_cfg = (peer_cfg_t*(*)(backend_manager_t*, identification_t *, identification_t *))get_peer_cfg;
|
|
this->public.add_peer_cfg = (void(*)(backend_manager_t*, peer_cfg_t*))add_peer_cfg;
|
|
this->public.create_iterator = (iterator_t*(*)(backend_manager_t*))create_iterator;
|
|
this->public.destroy = (void(*)(backend_manager_t*))destroy;
|
|
|
|
this->backends = linked_list_create();
|
|
this->writeable = linked_list_create();
|
|
this->handles = linked_list_create();
|
|
|
|
load_backends(this);
|
|
|
|
return &this->public;
|
|
}
|
|
|