[svn-upgrade] new version strongswan (4.5.0)

5 files changed, 98 insertions, 31 deletions

diff --git a/src/libcharon/network/receiver.c b/src/libcharon/network/receiver.c
index 63a8cab58..d8cebe192 100644
--- a/src/libcharon/network/receiver.c
+++ b/src/libcharon/network/receiver.c
@@ -146,7 +146,7 @@ static void send_notify(message_t *request, notify_type_t type, chunk_t data)
 		ike_sa_id->switch_initiator(ike_sa_id);
 		response->set_ike_sa_id(response, ike_sa_id);
 		response->add_notify(response, FALSE, type, data);
-		if (response->generate(response, NULL, NULL, &packet) == SUCCESS)
+		if (response->generate(response, NULL, &packet) == SUCCESS)
 		{
 			charon->sender->send(charon->sender, packet);
 			response->destroy(response);
@@ -274,9 +274,17 @@ static job_requeue_t receive_packets(private_receiver_t *this)
 {
 	packet_t *packet;
 	message_t *message;
+	status_t status;
 
 	/* read in a packet */
-	if (charon->socket->receive(charon->socket, &packet) != SUCCESS)
+	status = charon->socket->receive(charon->socket, &packet);
+	if (status == NOT_SUPPORTED)
+	{
+		/* the processor destroys this job  */
+		this->job = NULL;
+		return JOB_REQUEUE_NONE;
+	}
+	else if (status != SUCCESS)
 	{
 		DBG2(DBG_NET, "receiving from socket failed!");
 		return JOB_REQUEUE_FAIR;
@@ -353,22 +361,25 @@ static job_requeue_t receive_packets(private_receiver_t *this)
 			{
 				DBG1(DBG_NET, "using receive delay: %dms",
 					 this->receive_delay);
-				charon->scheduler->schedule_job_ms(charon->scheduler,
+				lib->scheduler->schedule_job_ms(lib->scheduler,
 								(job_t*)process_message_job_create(message),
 								this->receive_delay);
 				return JOB_REQUEUE_DIRECT;
 			}
 		}
 	}
-	charon->processor->queue_job(charon->processor,
-								 (job_t*)process_message_job_create(message));
+	lib->processor->queue_job(lib->processor,
+							  (job_t*)process_message_job_create(message));
 	return JOB_REQUEUE_DIRECT;
 }
 
 METHOD(receiver_t, destroy, void,
 	private_receiver_t *this)
 {
-	this->job->cancel(this->job);
+	if (this->job)
+	{
+		this->job->cancel(this->job);
+	}
 	this->rng->destroy(this->rng);
 	this->hasher->destroy(this->hasher);
 	free(this);
@@ -383,7 +394,9 @@ receiver_t *receiver_create()
 	u_int32_t now = time_monotonic(NULL);
 
 	INIT(this,
-		.public.destroy = _destroy,
+		.public = {
+			.destroy = _destroy,
+		},
 		.secret_switch = now,
 		.secret_offset = random() % now,
 	);
@@ -424,7 +437,7 @@ receiver_t *receiver_create()
 
 	this->job = callback_job_create((callback_job_cb_t)receive_packets,
 									this, NULL, NULL);
-	charon->processor->queue_job(charon->processor, (job_t*)this->job);
+	lib->processor->queue_job(lib->processor, (job_t*)this->job);
 
 	return &this->public;
 }
diff --git a/src/libcharon/network/sender.c b/src/libcharon/network/sender.c
index bb6d50605..4177fb3e1 100644
--- a/src/libcharon/network/sender.c
+++ b/src/libcharon/network/sender.c
@@ -195,7 +195,7 @@ sender_t * sender_create()
 											"charon.send_delay_response", TRUE),
 	);
 
-	charon->processor->queue_job(charon->processor, (job_t*)this->job);
+	lib->processor->queue_job(lib->processor, (job_t*)this->job);
 
 	return &this->public;
 }
diff --git a/src/libcharon/network/socket.h b/src/libcharon/network/socket.h
index 5c5a4edfb..51b26920f 100644
--- a/src/libcharon/network/socket.h
+++ b/src/libcharon/network/socket.h
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2006 Tobias Brunner, Daniel Roethlisberger
+ * Copyright (C) 2006-2010 Tobias Brunner
  * Copyright (C) 2005-2010 Martin Willi
+ * Copyright (C) 2006 Daniel Roethlisberger
  * Copyright (C) 2005 Jan Hutter
  * Hochschule fuer Technik Rapperswil
  *
@@ -30,6 +31,11 @@ typedef struct socket_t socket_t;
 #include <utils/enumerator.h>
 
 /**
+ * Constructor prototype for sockets.
+ */
+typedef socket_t *(*socket_constructor_t)();
+
+/**
  * Socket interface definition.
  */
 struct socket_t {
@@ -42,8 +48,8 @@ struct socket_t {
 	 *
 	 * @param packet		pinter gets address from allocated packet_t
 	 * @return
-	 * 						- SUCCESS when packet successfully received
-	 * 						- FAILED when unable to receive
+	 *						- SUCCESS when packet successfully received
+	 *						- FAILED when unable to receive
 	 */
 	status_t (*receive) (socket_t *this, packet_t **packet);
 
@@ -55,10 +61,15 @@ struct socket_t {
 	 *
 	 * @param packet		packet_t to send
 	 * @return
-	 * 						- SUCCESS when packet successfully sent
-	 * 						- FAILED when unable to send
+	 *						- SUCCESS when packet successfully sent
+	 *						- FAILED when unable to send
 	 */
 	status_t (*send) (socket_t *this, packet_t *packet);
+
+	/**
+	 * Destroy a socket implementation.
+	 */
+	void (*destroy) (socket_t *this);
 };
 
 #endif /** SOCKET_H_ @}*/
diff --git a/src/libcharon/network/socket_manager.c b/src/libcharon/network/socket_manager.c
index 0dbce4b1b..72a454301 100644
--- a/src/libcharon/network/socket_manager.c
+++ b/src/libcharon/network/socket_manager.c
@@ -1,4 +1,6 @@
 /*
+ * Copyright (C) 2010 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
  * Copyright (C) 2010 Martin Willi
  * Copyright (C) 2010 revosec AG
  *
@@ -33,11 +35,21 @@ struct private_socket_manager_t {
 	socket_manager_t public;
 
 	/**
-	 * List of registered socket
+	 * List of registered socket constructors
 	 */
 	linked_list_t *sockets;
 
 	/**
+	 * Instantiated socket implementation
+	 */
+	socket_t *socket;
+
+	/**
+	 * The constructor used to create the current socket
+	 */
+	socket_constructor_t create;
+
+	/**
 	 * Lock for sockets list
 	 */
 	rwlock_t *lock;
@@ -46,11 +58,9 @@ struct private_socket_manager_t {
 METHOD(socket_manager_t, receiver, status_t,
 	private_socket_manager_t *this, packet_t **packet)
 {
-	socket_t *socket;
 	status_t status;
-
 	this->lock->read_lock(this->lock);
-	if (this->sockets->get_first(this->sockets, (void**)&socket) != SUCCESS)
+	if (!this->socket)
 	{
 		DBG1(DBG_NET, "no socket implementation registered, receiving failed");
 		this->lock->unlock(this->lock);
@@ -58,7 +68,7 @@ METHOD(socket_manager_t, receiver, status_t,
 	}
 	/* receive is blocking and the thread can be cancelled */
 	thread_cleanup_push((thread_cleanup_t)this->lock->unlock, this->lock);
-	status = socket->receive(socket, packet);
+	status = this->socket->receive(this->socket, packet);
 	thread_cleanup_pop(TRUE);
 	return status;
 }
@@ -66,40 +76,67 @@ METHOD(socket_manager_t, receiver, status_t,
 METHOD(socket_manager_t, sender, status_t,
 	private_socket_manager_t *this, packet_t *packet)
 {
-	socket_t *socket;
 	status_t status;
-
 	this->lock->read_lock(this->lock);
-	if (this->sockets->get_first(this->sockets, (void**)&socket) != SUCCESS)
+	if (!this->socket)
 	{
 		DBG1(DBG_NET, "no socket implementation registered, sending failed");
 		this->lock->unlock(this->lock);
 		return NOT_SUPPORTED;
 	}
-	status = socket->send(socket, packet);
+	status = this->socket->send(this->socket, packet);
 	this->lock->unlock(this->lock);
 	return status;
 }
 
+static void create_socket(private_socket_manager_t *this)
+{
+	socket_constructor_t create;
+	/* remove constructors in order to avoid trying to create broken ones
+	 * multiple times */
+	while (this->sockets->remove_first(this->sockets,
+									   (void**)&create) == SUCCESS)
+	{
+		this->socket = create();
+		if (this->socket)
+		{
+			this->create = create;
+			break;
+		}
+	}
+}
+
 METHOD(socket_manager_t, add_socket, void,
-	private_socket_manager_t *this, socket_t *socket)
+	private_socket_manager_t *this, socket_constructor_t create)
 {
 	this->lock->write_lock(this->lock);
-	this->sockets->insert_last(this->sockets, socket);
+	this->sockets->insert_last(this->sockets, create);
+	if (!this->socket)
+	{
+		create_socket(this);
+	}
 	this->lock->unlock(this->lock);
 }
 
 METHOD(socket_manager_t, remove_socket, void,
-	private_socket_manager_t *this, socket_t *socket)
+	private_socket_manager_t *this, socket_constructor_t create)
 {
 	this->lock->write_lock(this->lock);
-	this->sockets->remove(this->sockets, socket, NULL);
+	this->sockets->remove(this->sockets, create, NULL);
+	if (this->create == create)
+	{
+		this->socket->destroy(this->socket);
+		this->socket = NULL;
+		this->create = NULL;
+		create_socket(this);
+	}
 	this->lock->unlock(this->lock);
 }
 
 METHOD(socket_manager_t, destroy, void,
 	private_socket_manager_t *this)
 {
+	DESTROY_IF(this->socket);
 	this->sockets->destroy(this->sockets);
 	this->lock->destroy(this->lock);
 	free(this);
diff --git a/src/libcharon/network/socket_manager.h b/src/libcharon/network/socket_manager.h
index b33d5c71c..94185d21c 100644
--- a/src/libcharon/network/socket_manager.h
+++ b/src/libcharon/network/socket_manager.h
@@ -1,4 +1,6 @@
 /*
+ * Copyright (C) 2010 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
  * Copyright (C) 2010 Martin Willi
  * Copyright (C) 2010 revosec AG
  *
@@ -51,14 +53,18 @@ struct socket_manager_t {
 	status_t (*send) (socket_manager_t *this, packet_t *packet);
 
 	/**
-	 * Register a socket implementation.
+	 * Register a socket constructor.
+	 *
+	 * @param create		constructor for the socket
 	 */
-	void (*add_socket)(socket_manager_t *this, socket_t *socket);
+	void (*add_socket)(socket_manager_t *this, socket_constructor_t create);
 
 	/**
-	 * Unregister a registered socket implementation.
+	 * Unregister a registered socket constructor.
+	 *
+	 * @param create		constructor for the socket
 	 */
-	void (*remove_socket)(socket_manager_t *this, socket_t *socket);
+	void (*remove_socket)(socket_manager_t *this, socket_constructor_t create);
 
 	/**
 	 * Destroy a socket_manager_t.