Imported Upstream version 4.5.2

4 files changed, 116 insertions, 50 deletions

diff --git a/src/libstrongswan/fetcher/fetcher.c b/src/libstrongswan/fetcher/fetcher.c
new file mode 100644
index 000000000..ca5a72165
--- /dev/null
+++ b/src/libstrongswan/fetcher/fetcher.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * 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 "fetcher.h"
+
+/**
+ * See header.
+ */
+bool fetcher_default_callback(void *userdata, chunk_t chunk)
+{
+	chunk_t *accu = userdata;
+
+	accu->ptr = realloc(accu->ptr, accu->len + chunk.len);
+	if (accu->ptr)
+	{
+		memcpy(&accu->ptr[accu->len], chunk.ptr, chunk.len);
+		accu->len += chunk.len;
+		return TRUE;
+	}
+	return FALSE;
+}
diff --git a/src/libstrongswan/fetcher/fetcher.h b/src/libstrongswan/fetcher/fetcher.h
index f312206bb..5b734da3d 100644
--- a/src/libstrongswan/fetcher/fetcher.h
+++ b/src/libstrongswan/fetcher/fetcher.h
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2008 Martin Willi
+ * Copyright (C) 2008-2011 Martin Willi
  * Hochschule fuer Technik Rapperswil
+ * Copyright (C) 2011 revosec AG
  *
  * 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
@@ -25,6 +26,23 @@ typedef struct fetcher_t fetcher_t;
 typedef enum fetcher_option_t fetcher_option_t;
 
 #include <stdarg.h>
+#include <chunk.h>
+
+/**
+ * Constructor function which creates fetcher instances.
+ *
+ * @return			fetcher instance
+ */
+typedef fetcher_t* (*fetcher_constructor_t)();
+
+/**
+ * Callback function used with FETCH_CALLBACK.
+ *
+ * @param userdata	userdata passed to fetcher_t.fetch()
+ * @param chunk		chunk with next chunk of data
+ * @return			TRUE to continue with transfer, FALSE to abort
+ */
+typedef bool (*fetcher_callback_t)(void *userdata, chunk_t chunk);
 
 #include <library.h>
 
@@ -64,19 +82,20 @@ enum fetcher_option_t {
 	FETCH_TIMEOUT,
 
 	/**
+	 * Callback to invoke with each chunk of data.
+	 * Additional argument fetch_callback_t.
+	 * If this option is not given, the fetcher_default_callback is used,
+	 * which accumulates the data into an allocated chunk.
+	 */
+	FETCH_CALLBACK,
+
+	/**
 	 * 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 {
@@ -87,15 +106,18 @@ struct fetcher_t {
 	 * 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.
+	 * If no FETCH_CALLBACK function is set as option, userdata must be
+	 * a chunk_t*. This chunk gets allocated, accumulated data using the
+	 * fetcher_default_callback() function.
 	 *
 	 * @param uri		URI to fetch from
-	 * @param result	chunk which receives allocated data
+	 * @param userdata	userdata to pass to callback function.
 	 * @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);
+	status_t (*fetch)(fetcher_t *this, char *uri, void *userdata);
 
 	/**
 	 * Set a fetcher option, as defined in fetcher_option_t.
@@ -114,4 +136,13 @@ struct fetcher_t {
 	void (*destroy)(fetcher_t *this);
 };
 
+/**
+ * Default fetcher callback function, accumulates data to a chunk.
+ *
+ * @param userdata		chunk for allocated data, empty on first invocation
+ * @param chunk			current chunk of data
+ * @return				FALSE if chunk too large to allocate
+ */
+bool fetcher_default_callback(void *userdata, chunk_t chunk);
+
 #endif /** FETCHER_H_ @}*/
diff --git a/src/libstrongswan/fetcher/fetcher_manager.c b/src/libstrongswan/fetcher/fetcher_manager.c
index b007c8b08..9b363c7eb 100644
--- a/src/libstrongswan/fetcher/fetcher_manager.c
+++ b/src/libstrongswan/fetcher/fetcher_manager.c
@@ -58,11 +58,8 @@ static void entry_destroy(entry_t *entry)
 	free(entry);
 }
 
-/**
- * Implementation of fetcher_manager_t.fetch.
- */
-static status_t fetch(private_fetcher_manager_t *this,
-					  char *url, chunk_t *response, ...)
+METHOD(fetcher_manager_t, fetch, status_t,
+	private_fetcher_manager_t *this, char *url, void *userdata, ...)
 {
 	enumerator_t *enumerator;
 	status_t status = NOT_SUPPORTED;
@@ -89,25 +86,31 @@ static status_t fetch(private_fetcher_manager_t *this,
 		{
 			continue;
 		}
-		va_start(args, response);
+		va_start(args, userdata);
 		while (good)
 		{
 			opt = va_arg(args, int);
 			switch (opt)
 			{
 				case FETCH_REQUEST_DATA:
-					good = fetcher->set_option(fetcher, opt, va_arg(args, chunk_t));
+					good = fetcher->set_option(fetcher, opt,
+											va_arg(args, chunk_t));
 					continue;
 				case FETCH_REQUEST_TYPE:
 				case FETCH_REQUEST_HEADER:
-					good = fetcher->set_option(fetcher, opt, va_arg(args, char*));
+					good = fetcher->set_option(fetcher, opt,
+											va_arg(args, char*));
 					continue;
 				case FETCH_HTTP_VERSION_1_0:
 					good = fetcher->set_option(fetcher, opt);
 					continue;
 				case FETCH_TIMEOUT:
-					good = fetcher->set_option(fetcher, opt, va_arg(args, u_int));
+					good = fetcher->set_option(fetcher, opt,
+											va_arg(args, u_int));
 					continue;
+				case FETCH_CALLBACK:
+					good = fetcher->set_option(fetcher, opt,
+											va_arg(args, fetcher_callback_t));
 				case FETCH_END:
 					break;
 			}
@@ -120,7 +123,7 @@ static status_t fetch(private_fetcher_manager_t *this,
 			continue;
 		}
 
-		status = fetcher->fetch(fetcher, url, response);
+		status = fetcher->fetch(fetcher, url, userdata);
 		fetcher->destroy(fetcher);
 		/* try another fetcher only if this one does not support that URL */
 		if (status == NOT_SUPPORTED)
@@ -139,27 +142,22 @@ static status_t fetch(private_fetcher_manager_t *this,
 	return status;
 }
 
-/**
- * Implementation of fetcher_manager_t.add_fetcher.
- */
-static void add_fetcher(private_fetcher_manager_t *this,
-						fetcher_constructor_t create, char *url)
+METHOD(fetcher_manager_t, add_fetcher, void,
+	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;
+	entry_t *entry;
 
+	INIT(entry,
+		.url = strdup(url),
+		.create = create,
+	);
 	this->lock->write_lock(this->lock);
 	this->fetchers->insert_last(this->fetchers, entry);
 	this->lock->unlock(this->lock);
 }
 
-/**
- * Implementation of fetcher_manager_t.remove_fetcher.
- */
-static void remove_fetcher(private_fetcher_manager_t *this,
-						   fetcher_constructor_t create)
+METHOD(fetcher_manager_t, remove_fetcher, void,
+	private_fetcher_manager_t *this, fetcher_constructor_t create)
 {
 	enumerator_t *enumerator;
 	entry_t *entry;
@@ -178,10 +176,8 @@ static void remove_fetcher(private_fetcher_manager_t *this,
 	this->lock->unlock(this->lock);
 }
 
-/**
- * Implementation of fetcher_manager_t.destroy
- */
-static void destroy(private_fetcher_manager_t *this)
+METHOD(fetcher_manager_t, destroy, void,
+	private_fetcher_manager_t *this)
 {
 	this->fetchers->destroy_function(this->fetchers, (void*)entry_destroy);
 	this->lock->destroy(this->lock);
@@ -193,15 +189,18 @@ static void destroy(private_fetcher_manager_t *this)
  */
 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();
-	this->lock = rwlock_create(RWLOCK_TYPE_DEFAULT);
+	private_fetcher_manager_t *this;
+
+	INIT(this,
+		.public = {
+			.fetch = _fetch,
+			.add_fetcher = _add_fetcher,
+			.remove_fetcher = _remove_fetcher,
+			.destroy = _destroy,
+		},
+		.fetchers = linked_list_create(),
+		.lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
+	);
 
 	return &this->public;
 }
diff --git a/src/libstrongswan/fetcher/fetcher_manager.h b/src/libstrongswan/fetcher/fetcher_manager.h
index a7ac6611e..15250d531 100644
--- a/src/libstrongswan/fetcher/fetcher_manager.h
+++ b/src/libstrongswan/fetcher/fetcher_manager.h
@@ -31,17 +31,20 @@ typedef struct fetcher_manager_t fetcher_manager_t;
 struct fetcher_manager_t {
 
 	/**
-	 * Fetch data from URI into chunk.
+	 * Fetch data from URI.
 	 *
 	 * The variable argument list contains fetcher_option_t's, followed
 	 * by a option specific data argument.
+	 * If no FETCH_CALLBACK function is given as option, userdata must be
+	 * a chunk_t*. This chunk gets allocated, accumulated data using the
+	 * fetcher_default_callback() function.
 	 *
 	 * @param uri			URI to fetch from
-	 * @param result		chunk which receives allocated data
+	 * @param userdata		userdata to pass to callback function.
 	 * @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, ...);
+	status_t (*fetch)(fetcher_manager_t *this, char *url, void *userdata, ...);
 
 	/**
 	 * Register a fetcher implementation.