[svn-upgrade] Integrating new upstream version, strongswan (4.2.4)

3 files changed, 387 insertions, 0 deletions

diff --git a/src/libstrongswan/fetcher/fetcher.h b/src/libstrongswan/fetcher/fetcher.h
new file mode 100644
index 000000000..4fc37e35e
--- /dev/null
+++ b/src/libstrongswan/fetcher/fetcher.h
@@ -0,0 +1,105 @@
+/*
+ * 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.
+ */
+
+/**
+ * @defgroup fetcheri fetcher
+ * @{ @ingroup fetcher
+ */
+
+#ifndef FETCHER_H_
+#define FETCHER_H_
+
+typedef struct fetcher_t fetcher_t;
+typedef enum fetcher_option_t fetcher_option_t;
+
+#include <stdarg.h>
+
+#include <library.h>
+
+/**
+ * Fetching options to use for fetcher_t.fetch() call.
+ */
+enum fetcher_option_t {
+
+	/** 
+	 * Data to include in fetch request, e.g. on a HTTP post.
+	 * Additional argument is a chunk_t
+	 */
+	FETCH_REQUEST_DATA,
+	
+	/** 
+	 * Mime-Type of data included in FETCH_REQUEST_DATA.
+	 * Additional argument is a char*.
+	 */
+	FETCH_REQUEST_TYPE,
+	
+	/** 
+	 * Timeout to use for fetch, in seconds.
+	 * Additional argument is u_int
+	 */
+	FETCH_TIMEOUT,
+	
+	/**
+	 * end of fetching options
+	 */
+	FETCH_END,
+};
+
+/**
+ * Constructor function which creates fetcher instances.
+ *
+ * @return			fetcher instance
+ */
+typedef fetcher_t* (*fetcher_constructor_t)();
+
+/**
+ * Fetcher interface, an implementation fetches data from an URL.
+ */
+struct fetcher_t {
+
+	/**
+	 * Fetch data from URI into chunk.
+	 *
+	 * The fetcher returns NOT_SUPPORTED to indicate that it is uncappable
+	 * to handle such URLs. Other return values indicate a failure, and
+	 * fetching of that URL gets cancelled.
+	 *
+	 * @param uri		URI to fetch from
+	 * @param result	chunk which receives allocated data
+	 * @return
+	 *					- SUCCESS if fetch was successful
+	 * 					- NOT_SUPPORTED if fetcher does not support such URLs
+	 *					- FAILED, NOT_FOUND, PARSE_ERROR on failure
+	 */
+	status_t (*fetch)(fetcher_t *this, char *uri, chunk_t *result);
+	
+	/**
+	 * Set a fetcher option, as defined in fetcher_option_t.
+	 *
+	 * Arguments passed to options must stay in memory until fetch() returns.
+	 *
+	 * @param option	option to set
+	 * @param ...		variable argument(s) to option
+	 * @return			TRUE if option supported, FALSE otherwise
+	 */
+	bool (*set_option)(fetcher_t *this, fetcher_option_t option, ...);
+	
+	/**
+	 * Destroy the fetcher instance.
+	 */
+	void (*destroy)(fetcher_t *this);	
+};
+
+#endif /* FETCHER_H_ @}*/
diff --git a/src/libstrongswan/fetcher/fetcher_manager.c b/src/libstrongswan/fetcher/fetcher_manager.c
new file mode 100644
index 000000000..517c9dfc9
--- /dev/null
+++ b/src/libstrongswan/fetcher/fetcher_manager.c
@@ -0,0 +1,208 @@
+/*
+ * 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: fetcher_manager.c 3630 2008-03-20 11:27:55Z martin $
+ */
+
+#define _GNU_SOURCE
+
+#include "fetcher_manager.h"
+
+#include <debug.h>
+#include <utils/linked_list.h>
+#include <utils/mutex.h>
+
+typedef struct private_fetcher_manager_t private_fetcher_manager_t;
+
+/**
+ * private data of fetcher_manager
+ */
+struct private_fetcher_manager_t {
+
+	/**
+	 * public functions
+	 */
+	fetcher_manager_t public;
+	
+	/**
+	 * list of registered fetchers, as entry_t
+	 */
+	linked_list_t *fetchers;
+	
+	/**
+	 * read write lock to list
+	 */
+	pthread_rwlock_t lock;
+};
+
+typedef struct {
+	/** assocaited fetcher construction function */
+	fetcher_constructor_t create;
+	/** URL this fetcher support */
+	char *url;
+} entry_t;
+
+/**
+ * destroy an entry_t
+ */
+static void entry_destroy(entry_t *entry)
+{
+	free(entry->url);
+	free(entry);
+}
+
+/**
+ * Implementation of fetcher_manager_t.fetch.
+ */
+static status_t fetch(private_fetcher_manager_t *this,
+					  char *url, chunk_t *response, ...)
+{
+	enumerator_t *enumerator;
+	status_t status = NOT_SUPPORTED;
+	entry_t *entry;
+	bool capable = FALSE;
+	
+	pthread_rwlock_rdlock(&this->lock);
+	enumerator = this->fetchers->create_enumerator(this->fetchers);
+	while (enumerator->enumerate(enumerator, &entry))
+	{
+		fetcher_option_t opt;
+		fetcher_t *fetcher;
+		bool good = TRUE;
+		va_list args;
+
+		/* check URL support of fetcher */
+		if (strncasecmp(entry->url, url, strlen(entry->url)))
+		{
+			continue;
+		}
+		/* create fetcher instance and set options */
+		fetcher = entry->create();
+		if (!fetcher)
+		{
+			continue;
+		}
+		va_start(args, response);
+		while (good)
+		{
+			opt = va_arg(args, fetcher_option_t);
+			switch (opt)
+			{
+				case FETCH_REQUEST_DATA:
+					good = fetcher->set_option(fetcher, opt, va_arg(args, chunk_t));
+					continue;
+				case FETCH_REQUEST_TYPE:
+					good = fetcher->set_option(fetcher, opt, va_arg(args, char*));
+					continue;
+				case FETCH_TIMEOUT:
+					good = fetcher->set_option(fetcher, opt, va_arg(args, u_int));
+					continue;
+				case FETCH_END:
+					break;;
+			}
+			break;
+		}
+		va_end(args);
+		if (!good)
+		{	/* fetcher does not support supplied options, try another */
+			fetcher->destroy(fetcher);
+			continue;
+		}
+		
+		status = fetcher->fetch(fetcher, url, response);
+		fetcher->destroy(fetcher);
+		/* try another fetcher only if this one does not support that URL */
+		if (status == NOT_SUPPORTED)
+		{
+			continue;
+		}
+		capable = TRUE;
+		break;
+	}
+	enumerator->destroy(enumerator);
+	pthread_rwlock_unlock(&this->lock);
+	if (!capable)
+	{
+		DBG1("unable to fetch from %s, no capable fetcher found", url);
+	}
+	return status;
+}
+
+/**
+ * Implementation of fetcher_manager_t.add_fetcher.
+ */
+static void add_fetcher(private_fetcher_manager_t *this,	
+						fetcher_constructor_t create, char *url)
+{
+	entry_t *entry = malloc_thing(entry_t);
+	
+	entry->url = strdup(url);
+	entry->create = create;
+
+	pthread_rwlock_wrlock(&this->lock);
+	this->fetchers->insert_last(this->fetchers, entry);
+	pthread_rwlock_unlock(&this->lock);
+}
+
+/**
+ * Implementation of fetcher_manager_t.remove_fetcher.
+ */
+static void remove_fetcher(private_fetcher_manager_t *this,
+						   fetcher_constructor_t create)
+{
+	enumerator_t *enumerator;
+	entry_t *entry;
+	
+	pthread_rwlock_wrlock(&this->lock);
+	enumerator = this->fetchers->create_enumerator(this->fetchers);
+	while (enumerator->enumerate(enumerator, &entry))
+	{
+		if (entry->create == create)
+		{
+			this->fetchers->remove_at(this->fetchers, enumerator);
+			entry_destroy(entry);
+		}
+	}
+	enumerator->destroy(enumerator);
+	pthread_rwlock_unlock(&this->lock);
+}
+
+/**
+ * Implementation of fetcher_manager_t.destroy
+ */
+static void destroy(private_fetcher_manager_t *this)
+{
+	this->fetchers->destroy_function(this->fetchers, (void*)entry_destroy);
+	pthread_rwlock_destroy(&this->lock);
+	free(this);
+}
+
+/*
+ * see header file
+ */
+fetcher_manager_t *fetcher_manager_create()
+{
+	private_fetcher_manager_t *this = malloc_thing(private_fetcher_manager_t);
+	
+	this->public.fetch = (status_t(*)(fetcher_manager_t*, char *url, chunk_t *response, ...))fetch;
+	this->public.add_fetcher = (void(*)(fetcher_manager_t*, fetcher_constructor_t,char*))add_fetcher;
+	this->public.remove_fetcher = (void(*)(fetcher_manager_t*, fetcher_constructor_t))remove_fetcher;
+	this->public.destroy = (void(*)(fetcher_manager_t*))destroy;
+	
+	this->fetchers = linked_list_create();
+	pthread_rwlock_init(&this->lock, NULL);
+	
+	return &this->public;
+}
+
diff --git a/src/libstrongswan/fetcher/fetcher_manager.h b/src/libstrongswan/fetcher/fetcher_manager.h
new file mode 100644
index 000000000..e94d44494
--- /dev/null
+++ b/src/libstrongswan/fetcher/fetcher_manager.h
@@ -0,0 +1,74 @@
+/*
+ * 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.
+ */
+
+/**
+ * @defgroup fetcher_manager fetcher_manager
+ * @{ @ingroup fetcher
+ */
+
+#ifndef FETCHER_MANAGER_H_
+#define FETCHER_MANAGER_H_
+
+typedef struct fetcher_manager_t fetcher_manager_t;
+
+#include <fetcher/fetcher.h>
+
+/**
+ * Fetches from URIs using registerd fetcher_t instances.
+ */
+struct fetcher_manager_t {
+
+	/**
+	 * Fetch data from URI into chunk.
+	 *
+	 * The variable argument list contains fetcher_option_t's, followed
+	 * by a option specific data argument.
+	 *
+	 * @param uri			URI to fetch from
+	 * @param result		chunk which receives allocated data
+	 * @param options		FETCH_END terminated fetcher_option_t arguments
+	 * @return				status indicating result of fetch
+	 */
+	status_t (*fetch)(fetcher_manager_t *this, char *url, chunk_t *response, ...);
+
+	/**
+	 * Register a fetcher implementation.
+	 *
+	 * @param constructor	fetcher constructor function
+	 * @param url			URL type this fetcher fetches, e.g. "http://"
+	 */
+	void (*add_fetcher)(fetcher_manager_t *this,
+						fetcher_constructor_t constructor, char *url);
+	
+	/**
+	 * Unregister a previously registered fetcher implementation.
+	 *
+	 * @param constructor	fetcher constructor function to unregister
+	 */
+	void (*remove_fetcher)(fetcher_manager_t *this, 
+						   fetcher_constructor_t constructor);
+	
+	/**
+     * Destroy a fetcher_manager instance.
+     */
+    void (*destroy)(fetcher_manager_t *this);
+};
+
+/**
+ * Create a fetcher_manager instance.
+ */
+fetcher_manager_t *fetcher_manager_create();
+
+#endif /* FETCHER_MANAGER_H_ @}*/