- documentation and cleanup of threads package
authorMartin Willi <martin@strongswan.org>
Fri, 25 Nov 2005 13:42:58 +0000 (13:42 -0000)
committerMartin Willi <martin@strongswan.org>
Fri, 25 Nov 2005 13:42:58 +0000 (13:42 -0000)
Source/charon/definitions.h
Source/charon/threads/receiver.c
Source/charon/threads/receiver.h
Source/charon/threads/scheduler.c
Source/charon/threads/scheduler.h
Source/charon/threads/sender.c
Source/charon/threads/sender.h
Source/charon/threads/thread_pool.c
Source/charon/threads/thread_pool.h

index d170cef..03fd74b 100644 (file)
  * 
  * Generic helper classes.
  */
+  
+/**
+ * @addtogroup threads
+ * 
+ * Threaded classes, which will do their 
+ * job alone.
+ */
 
 /**
  * macro gives back larger of two values
index da751dc..b46949b 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file receiver.c
  *
- * @brief Implements the Receiver Thread encapsulated in the receiver_t object
+ * @brief Implementation of receiver_t.
  *
  */
 
@@ -44,6 +44,13 @@ struct private_receiver_t {
         * Public part of a receiver object
         */
         receiver_t public;
+        
+        /**
+         * @brief Thread function started at creation of the receiver object.
+         *
+         * @param this assigned receiver object
+         */
+        void (*receive_packets) (private_receiver_t *this);
 
         /**
          * Assigned thread to the receiver_t object
@@ -58,12 +65,9 @@ struct private_receiver_t {
 };
 
 /**
- * Thread function started at creation of the receiver object
- *
- * @param this assigned receiver object
- * @return SUCCESS if thread_function ended successfully, FAILED otherwise
+ * implements private_receiver_t.receive_packets
  */
-static void receiver_thread_function(private_receiver_t * this)
+static void receive_packets(private_receiver_t * this)
 {
        packet_t * current_packet;
        job_t *current_job;
@@ -108,12 +112,15 @@ static status_t destroy(private_receiver_t *this)
        return SUCCESS;
 }
 
-
+/*
+ * see header
+ */
 receiver_t * receiver_create()
 {
        private_receiver_t *this = allocator_alloc_thing(private_receiver_t);
 
        this->public.destroy = (status_t(*)(receiver_t*)) destroy;
+       this->receive_packets = receive_packets;
        
        this->logger = global_logger_manager->create_logger(global_logger_manager, RECEIVER, NULL);
        if (this->logger == NULL)
@@ -121,9 +128,9 @@ receiver_t * receiver_create()
                allocator_free(this);
        }
        
-       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))receiver_thread_function, this) != 0)
+       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))this->receive_packets, this) != 0)
        {
-               /* thread could not be created  */
+               this->logger->log(this->logger, ERROR, "Receiver thread could not be started");
                global_logger_manager->destroy_logger(global_logger_manager, this->logger);
                allocator_free(this);
                return NULL;
index 2f330ad..9b02165 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file receiver.h
  *
- * @brief Implements the Receiver Thread encapsulated in the receiver_t object
+ * @brief Interface of receiver_t.
  *
  */
 
 typedef struct receiver_t receiver_t;
 
 /**
- * @brief A Receiver object which receives packets on the socket and adds them to the job-queue
+ * @brief Receives packets from the socket and adds them to the job queue.
+ * 
+ * The receiver starts a thread, wich reads on the blocking socket. If 
+ * there is data available, a packet_t is created from the data, wrapped
+ * in an incoming_packet_job_t and added to the job queue.
+ * 
+ * @ingroup threads
  */
 struct receiver_t {
 
        /**
-        * @brief Destroys a receiver object
+        * @brief Destroys a receiver_t
         *
-        * @param receiver receiver object
-        * @return SUCCESSFUL if succeeded, FAILED otherwise
+        * @param receiver      receiver object
+        * @return 
+        *                              - SUCCESS in any case
         */
        status_t (*destroy) (receiver_t *receiver);
 };
 
-
+/**
+ * @brief Create a receiver.
+ * 
+ * The receiver thread will start working, get data
+ * from the socket and add those packets to the job queue.
+ * 
+ * @return
+ *                                     - created receiver_t, or
+ *                                     - NULL of thread could not be started
+ * 
+ * @ingroup threads
+ */
 receiver_t * receiver_create();
 
 #endif /*RECEIVER_H_*/
index 789e39a..8349d36 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file scheduler.c
  *
- * @brief implements the scheduler, looks for jobs in event-queue
+ * @brief Implementation of scheduler_t.
  *
  */
 
@@ -41,6 +41,16 @@ struct private_scheduler_t {
         * Public part of a scheduler object
         */
         scheduler_t public;
+        
+        
+       /**
+        * @brief Get events from the event queue and add them to to job queue.
+        *
+        * Thread function started at creation of the scheduler object.
+        *
+        * @param this          assigned scheduler object
+        */
+       void (*get_events) (private_scheduler_t *this);
 
         /**
          * Assigned thread to the scheduler_t object
@@ -55,12 +65,9 @@ struct private_scheduler_t {
 };
 
 /**
- * Thread function started at creation of the scheduler object
- *
- * @param this assigned scheduler object
- * @return SUCCESS if thread_function ended successfully, FAILED otherwise
+ * implements private_scheduler_t.get_events
  */
-static void scheduler_thread_function(private_scheduler_t * this)
+static void get_events(private_scheduler_t * this)
 {
        /* cancellation disabled by default */
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
@@ -73,7 +80,8 @@ static void scheduler_thread_function(private_scheduler_t * this)
                global_event_queue->get(global_event_queue, &current_job);
                /* queue the job in the job queue, workers will eat them */
                global_job_queue->add(global_job_queue, current_job);
-               this->logger->log(this->logger, CONTROL, "got event, added job %s to job-queue.", mapping_find(job_type_m, current_job->get_type(current_job)));
+               this->logger->log(this->logger, CONTROL, "got event, added job %s to job-queue.", 
+                                                 mapping_find(job_type_m, current_job->get_type(current_job)));
        }
 }
 
@@ -100,6 +108,7 @@ scheduler_t * scheduler_create()
        private_scheduler_t *this = allocator_alloc_thing(private_scheduler_t);
 
        this->public.destroy = (status_t(*)(scheduler_t*)) destroy;
+       this->get_events = get_events;
        
        this->logger = global_logger_manager->create_logger(global_logger_manager, SCHEDULER, NULL);
        if (this->logger == NULL)
@@ -108,9 +117,10 @@ scheduler_t * scheduler_create()
                return NULL;    
        }
        
-       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))scheduler_thread_function, this) != 0)
+       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))this->get_events, this) != 0)
        {
                /* thread could not be created  */
+               this->logger->log(this->logger, ERROR, "Scheduler thread could not be created!");       
                global_logger_manager->destroy_logger(global_logger_manager, this->logger);
                allocator_free(this);
                return NULL;
index 1bd9e62..9eeccbb 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file scheduler.h
  * 
- * @brief implements the scheduler, looks for jobs in event-queue
+ * @brief Interface of scheduler_t.
  * 
  */
 
@@ -31,20 +31,34 @@ typedef struct scheduler_t scheduler_t;
  * @brief The scheduler, looks for timed events in event-queue and adds them
  * to the job-queue.
  * 
- * Starts a thread which does the work, since event-queue is blocking
+ * Starts a thread which does the work, since event-queue is blocking.
+ * 
+ * @ingroup threads
  */
 struct scheduler_t {   
 
        /**
-        * @brief Destroys a scheduler object
+        * @brief Destroys a scheduler object.
         * 
-        * @param scheduler scheduler object
-        * @return SUCCESSFUL if succeeded, FAILED otherwise
+        * @param scheduler     scheduler object
+        * @return 
+        *                                              - SUCCESS in any case
         */
        status_t (*destroy) (scheduler_t *scheduler);
 };
 
-
+/**
+ * @brief Create a scheduler with its thread.
+ * 
+ * The thread will start to get jobs form the event queue 
+ * and adds them to the job queue.
+ * 
+ * @return 
+ *                     - the created scheduler_t instance, or
+ *                     - NULL if thread could not be started
+ * 
+ * @ingroup threads
+ */
 scheduler_t * scheduler_create();
 
 #endif /*SCHEDULER_H_*/
index 94ebda3..5ad00e0 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file sender.c
  *
- * @brief Implements the Sender Thread encapsulated in the sender_t object
+ * @brief Implementation of sender_t.
  *
  */
 
@@ -49,6 +49,13 @@ struct private_sender_t {
         pthread_t assigned_thread;
         
         /**
+         * @brief The threads function, sends out packets.
+         * 
+         * @param this         assigned sender object
+         */
+        void (*send_packets) (private_sender_t * this);
+        
+        /**
          * logger for this sender
          */
         logger_t *logger;
@@ -56,12 +63,9 @@ struct private_sender_t {
 };
 
 /**
- * Thread function started at creation of the sender object
- *
- * @param this assigned sender object
- * @return SUCCESS if thread_function ended successfully, FAILED otherwise
+ * implements private_sender_t.send_packets
  */
-static void sender_thread_function(private_sender_t * this)
+static void send_packets(private_sender_t * this)
 {
        packet_t * current_packet;
        status_t status;
@@ -86,7 +90,7 @@ static void sender_thread_function(private_sender_t * this)
 }
 
 /**
- * Implementation of sender_t's destroy function
+ * implements sender_t.destroy
  */
 static status_t destroy(private_sender_t *this)
 {
@@ -102,11 +106,14 @@ static status_t destroy(private_sender_t *this)
        return SUCCESS;
 }
 
-
+/*
+ * see header
+ */
 sender_t * sender_create()
 {
        private_sender_t *this = allocator_alloc_thing(private_sender_t);
 
+       this->send_packets = send_packets;
        this->public.destroy = (status_t(*)(sender_t*)) destroy;
        
        this->logger = global_logger_manager->create_logger(global_logger_manager, SENDER, NULL);
@@ -116,9 +123,9 @@ sender_t * sender_create()
                return NULL;    
        }
        
-       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))sender_thread_function, this) != 0)
+       if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))this->send_packets, this) != 0)
        {
-               /* thread could not be created  */
+               this->logger->log(this->logger, ERROR, "Sender thread could not be created");
                allocator_free(this);
                return NULL;
        }
index c57213c..5ddad80 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file sender.h
  *
- * @brief Implements the Sender Thread encapsulated in the sender_t object
+ * @brief Interface of sender_t.
  *
  */
 
 typedef struct sender_t sender_t;
 
 /**
- * @brief A Sender object which sends packets on the socket
+ * @brief Sends packets over the socket.
+ * 
+ * @ingroup threads
  */
 struct sender_t {
 
        /**
         * @brief Destroys a sender object
         *
-        * @param sender sender object
-        * @return SUCCESSFUL if succeeded, FAILED otherwise
+        * @param sender        sender object
+        * @return 
+        *                                      - SUCCESS in any case
         */
        status_t (*destroy) (sender_t *sender);
 };
 
 
+/**
+ * @brief Create the sender thread.
+ * 
+ * The thread will start to work, getting packets
+ * from the send queue and sends them out.
+ * 
+ * @return
+ *                                     - created sender_t, or
+ *                                     - NULL of thread could not be started
+ * 
+ * @ingroup threads
+ */
 sender_t * sender_create();
 
 #endif /*SENDER_H_*/
index 1ed3a20..ee8d50b 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file thread_pool.c
  * 
- * @brief Thread pool with some threads processing the job_queue.
+ * @brief Implementation of thread_pool_t.
  * 
  */
 
 typedef struct private_thread_pool_t private_thread_pool_t;
 
 /**
- * @brief structure with private members for thread_pool_t
+ * @brief Structure with private members for thread_pool_t.
  */
 struct private_thread_pool_t {
        /**
         * inclusion of public members
         */
        thread_pool_t public;
+       
+       /**
+        * @brief Main processing functino for worker threads.
+        *
+        * Gets a job from the job queue and calls corresponding
+        * function for processing.
+        * 
+        * @param this  private_thread_pool_t-Object
+        */
+       void (*process_jobs) (private_thread_pool_t *this);
+
+       /**
+        * @brief Process a INCOMING_PACKET_JOB.
+        * 
+        * @param this  private_thread_pool_t-Object
+        */
+       void (*process_incoming_packet_job) (private_thread_pool_t *this, incoming_packet_job_t *job);
+
+       /**
+        * @brief Process a INITIATE_IKE_SA_JOB.
+        * 
+        * @param this  private_thread_pool_t-Object
+        */
+       void (*process_initiate_ike_sa_job) (private_thread_pool_t *this, initiate_ike_sa_job_t *job);
+
        /**
-        * @brief Processing function of a worker thread
+        * @brief Process a DELETE_IKE_SA_JOB.
         * 
         * @param this  private_thread_pool_t-Object
         */
-       void (*function) (private_thread_pool_t *this);
+       void (*process_delete_ike_sa_job) (private_thread_pool_t *this, delete_ike_sa_job_t *job);
+       
        /**
         * number of running threads
         */
@@ -64,7 +90,7 @@ struct private_thread_pool_t {
         */
        logger_t *pool_logger;
        /**
-        * logger of the threadpool
+        * logger of the worker threads
         */
        logger_t *worker_logger;
 } ;
@@ -74,9 +100,8 @@ struct private_thread_pool_t {
 /**
  * implements private_thread_pool_t.function
  */
-static void job_processing(private_thread_pool_t *this)
+static void process_jobs(private_thread_pool_t *this)
 {
-
        /* cancellation disabled by default */
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
        this->worker_logger->log(this->worker_logger, CONTROL, "started working");
@@ -87,180 +112,196 @@ static void job_processing(private_thread_pool_t *this)
                
                global_job_queue->get(global_job_queue, &job);
                job_type = job->get_type(job);
-               this->worker_logger->log(this->worker_logger, CONTROL|MORE, "got a job of type %s", mapping_find(job_type_m,job_type));
+               this->worker_logger->log(this->worker_logger, CONTROL|MORE, "got a job of type %s", 
+                                                                mapping_find(job_type_m,job_type));
                
-               /* process them here */
                switch (job_type)
                {
                        case INCOMING_PACKET:
                        {
-                               packet_t        *packet;
-                               message_t       *message;
-                               ike_sa_t        *ike_sa;
-                               ike_sa_id_t *ike_sa_id;
-                               status_t        status;
-                               incoming_packet_job_t *incoming_packet_job = (incoming_packet_job_t *)job;
+                               this->process_incoming_packet_job(this, (incoming_packet_job_t*)job);
+                               break;
+                       }
+                       case INITIATE_IKE_SA:
+                       {
+                               this->process_initiate_ike_sa_job(this, (initiate_ike_sa_job_t*)job);
+                               break;
+                       }
+                       case DELETE_IKE_SA:
+                       {
+                               this->process_delete_ike_sa_job(this, (delete_ike_sa_job_t*)job);
+                               break;
+                       }
+                       default:
+                       {
+                               this->worker_logger->log(this->worker_logger, ERROR, "job of type %s not supported!", 
+                                                                                mapping_find(job_type_m,job_type));                            
+                               break;
+                       }
+               }
+               job->destroy(job);
+       }
+}
+
+/**
+ * implementation of private_thread_pool_t.process_incoming_packet_job
+ */
+void process_incoming_packet_job(private_thread_pool_t *this, incoming_packet_job_t *job)
+{
+       packet_t        *packet;
+       message_t       *message;
+       ike_sa_t        *ike_sa;
+       ike_sa_id_t *ike_sa_id;
+       status_t        status;
                                
                                
-                               if (incoming_packet_job->get_packet(incoming_packet_job,&packet) != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "packet in job %s could not be retrieved!",
-                                                                               mapping_find(job_type_m,job_type));                             
-                                       break;
-                               }
+       if (job->get_packet(job,&packet) != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "packet in job could not be retrieved!");                          
+               return;
+       }
                                
-                               message = message_create_from_packet(packet);
-                               if (message == NULL)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "message could not be created from packet!", 
-                                                                               mapping_find(job_type_m,job_type));                             
-                                       packet->destroy(packet);
-                                       break;                                  
-                               }
+       message = message_create_from_packet(packet);
+       if (message == NULL)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "message could not be created from packet!");
+               packet->destroy(packet);
+               return;                                 
+       }
 
-                               status = message->parse_header(message);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "message header could not be verified!");                          
-                                       message->destroy(message);
-                                       break;                                                                          
-                               }
+       status = message->parse_header(message);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "message header could not be verified!");                          
+               message->destroy(message);
+               return;                                                                         
+       }
                                
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "message is a %s %s", 
-                                                                       mapping_find(exchange_type_m, message->get_exchange_type(message)),
-                                                                       message->get_request(message) ? "request" : "reply");
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "message is a %s %s", 
+                                                        mapping_find(exchange_type_m, message->get_exchange_type(message)),
+                                                        message->get_request(message) ? "request" : "reply");
                                
-                               if ((message->get_major_version(message) != IKE_MAJOR_VERSION) || 
-                                       (message->get_minor_version(message) != IKE_MINOR_VERSION))
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "IKE version %d.%d not supported", 
-                                                                                               message->get_major_version(message),
-                                                                                               message->get_minor_version(message));   
-                                       /* Todo send notify */
-                               }
+       if ((message->get_major_version(message) != IKE_MAJOR_VERSION) || 
+                       (message->get_minor_version(message) != IKE_MINOR_VERSION))
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "IKE version %d.%d not supported", 
+                                                                message->get_major_version(message),
+                                                                message->get_minor_version(message));  
+               /* Todo send notify */
+       }
                                
-                               status = message->get_ike_sa_id(message, &ike_sa_id);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "IKE SA ID of message could not be created!");
-                                       message->destroy(message);
-                                       break;
-                               }
+       status = message->get_ike_sa_id(message, &ike_sa_id);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "IKE SA ID of message could not be created!");
+               message->destroy(message);
+               return;
+       }
                        
-                               ike_sa_id->switch_initiator(ike_sa_id);
+       ike_sa_id->switch_initiator(ike_sa_id);
                                
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking out IKE SA %lld:%lld, role %s", 
-                                                                       ike_sa_id->get_initiator_spi(ike_sa_id),
-                                                                       ike_sa_id->get_responder_spi(ike_sa_id),
-                                                                       ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking out IKE SA %lld:%lld, role %s", 
+                                                        ike_sa_id->get_initiator_spi(ike_sa_id),
+                                                        ike_sa_id->get_responder_spi(ike_sa_id),
+                                                        ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
                                
-                               status = global_ike_sa_manager->checkout(global_ike_sa_manager,ike_sa_id, &ike_sa);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "IKE SA could not be checked out");
-                                       ike_sa_id->destroy(ike_sa_id);  
-                                       message->destroy(message);
-                                       break;
-                               }
+       status = global_ike_sa_manager->checkout(global_ike_sa_manager,ike_sa_id, &ike_sa);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "IKE SA could not be checked out");
+               ike_sa_id->destroy(ike_sa_id);  
+               message->destroy(message);
+               return;
+       }
                                
-                               status = ike_sa->process_message(ike_sa, message);                              
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "message could not be processed by IKE SA");
-                               }
+       status = ike_sa->process_message(ike_sa, message);                              
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "message could not be processed by IKE SA");
+       }
                                
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking in IKE SA %lld:%lld, role %s", 
-                                                                       ike_sa_id->get_initiator_spi(ike_sa_id),
-                                                                       ike_sa_id->get_responder_spi(ike_sa_id),
-                                                                       ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
-                               ike_sa_id->destroy(ike_sa_id);
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking in IKE SA %lld:%lld, role %s", 
+                                                        ike_sa_id->get_initiator_spi(ike_sa_id),
+                                                        ike_sa_id->get_responder_spi(ike_sa_id),
+                                                        ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
+       ike_sa_id->destroy(ike_sa_id);
                                                                        
-                               status = global_ike_sa_manager->checkin(global_ike_sa_manager, ike_sa);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "checkin of IKE SA failed");
-                               }
-                               message->destroy(message);
-                               break;
-                       }
-                       case INITIATE_IKE_SA:
-                       {
-                               /*
-                                * Initiatie an IKE_SA:
-                                * - is defined by a name of a configuration
-                                * - create an empty IKE_SA via manager
-                                * - call initiate_connection on this sa
-                                */
-                               initiate_ike_sa_job_t *initiate_job;
-                               ike_sa_t *ike_sa;
-                               status_t status;
-                               
-                               initiate_job = (initiate_ike_sa_job_t *)job;                    
+       status = global_ike_sa_manager->checkin(global_ike_sa_manager, ike_sa);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "checkin of IKE SA failed");
+       }
+       message->destroy(message);
+}
+
+/**
+ * implementation of private_thread_pool_t.process_initiate_ike_sa_job
+ */
+void process_initiate_ike_sa_job(private_thread_pool_t *this, initiate_ike_sa_job_t *job)
+{
+       /*
+        * Initiatie an IKE_SA:
+        * - is defined by a name of a configuration
+        * - create an empty IKE_SA via manager
+        * - call initiate_connection on this sa
+        */
+       ike_sa_t *ike_sa;
+       status_t status;
+                                                       
                                        
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "create and checking out IKE SA");
-                               
-                               status = global_ike_sa_manager->create_and_checkout(global_ike_sa_manager, &ike_sa);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "%s by checking out new IKE_SA, job rejected.", 
-                                                                               mapping_find(status_m, status));
-                                       break;
-                               }
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "create and checking out IKE SA");
                                
+       status = global_ike_sa_manager->create_and_checkout(global_ike_sa_manager, &ike_sa);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "%s by checking out new IKE_SA, job rejected.", 
+                                                                mapping_find(status_m, status));
+               return;
+       }
                                
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "initializing connection \"%s\"", 
-                                                                       initiate_job->get_configuration_name(initiate_job));
-                               status = ike_sa->initialize_connection(ike_sa, initiate_job->get_configuration_name(initiate_job));
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "%s by initialize_conection, job and rejected, IKE_SA deleted.", 
-                                                                               mapping_find(status_m, status));
-                                       global_ike_sa_manager->checkin_and_delete(global_ike_sa_manager, ike_sa);
-                                       break;
-                               }
                                
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking in IKE SA");
-                               status = global_ike_sa_manager->checkin(global_ike_sa_manager, ike_sa);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "%s could not checkin IKE_SA.", 
-                                                                               mapping_find(status_m, status));
-                               }
-                               break;
-                       }
-                       case RETRANSMIT_REQUEST:
-                       {
-                               this->worker_logger->log(this->worker_logger, ERROR, "job of type %s not supported!", mapping_find(job_type_m,job_type));                               
-                               break;
-                       }
-                       
-                       case DELETE_IKE_SA:
-                       {
-                               delete_ike_sa_job_t *delete_ike_sa_job = (delete_ike_sa_job_t*) job;
-                               ike_sa_id_t *ike_sa_id = delete_ike_sa_job->get_ike_sa_id(delete_ike_sa_job);
-                               status_t status;
-                                                               
-                               
-                               this->worker_logger->log(this->worker_logger, CONTROL|MOST, "deleting IKE SA %lld:%lld, role %s", 
-                                                                       ike_sa_id->get_initiator_spi(ike_sa_id),
-                                                                       ike_sa_id->get_responder_spi(ike_sa_id),
-                                                                       ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
-                                                                       
-                               status = global_ike_sa_manager->delete(global_ike_sa_manager, ike_sa_id);
-                               if (status != SUCCESS)
-                               {
-                                       this->worker_logger->log(this->worker_logger, ERROR, "could not delete IKE_SA (%s)", 
-                                                                               mapping_find(status_m, status));
-                               }
-                               break;
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "initializing connection \"%s\"", 
+                                                        job->get_configuration_name(job));
+       status = ike_sa->initialize_connection(ike_sa, job->get_configuration_name(job));
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "%s by initialize_conection, job and rejected, IKE_SA deleted.", 
+                                                                mapping_find(status_m, status));
+               global_ike_sa_manager->checkin_and_delete(global_ike_sa_manager, ike_sa);
+               return;
+       }
                                
-                       }
-               }
-               job->destroy(job);
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "checking in IKE SA");
+       status = global_ike_sa_manager->checkin(global_ike_sa_manager, ike_sa);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "%s could not checkin IKE_SA.", 
+                                                                mapping_find(status_m, status));
        }
+}
 
+/**
+ * implementation of private_thread_pool_t.process_delete_ike_sa_job
+ */
+void process_delete_ike_sa_job(private_thread_pool_t *this, delete_ike_sa_job_t *job)
+{
+       status_t status;
+       ike_sa_id_t *ike_sa_id = job->get_ike_sa_id(job);
+                                                                               
+       this->worker_logger->log(this->worker_logger, CONTROL|MOST, "deleting IKE SA %lld:%lld, role %s", 
+                                                        ike_sa_id->get_initiator_spi(ike_sa_id),
+                                                        ike_sa_id->get_responder_spi(ike_sa_id),
+                                                        ike_sa_id->is_initiator(ike_sa_id) ? "initiator" : "responder");
+                                                                       
+       status = global_ike_sa_manager->delete(global_ike_sa_manager, ike_sa_id);
+       if (status != SUCCESS)
+       {
+               this->worker_logger->log(this->worker_logger, ERROR, "could not delete IKE_SA (%s)", 
+                                                                mapping_find(status_m, status));
+       }       
 }
 
+
 /**
  * implementation of thread_pool_t.get_pool_size
  */
@@ -310,7 +351,10 @@ thread_pool_t *thread_pool_create(size_t pool_size)
        this->public.destroy = (status_t(*)(thread_pool_t*))destroy;
        this->public.get_pool_size = (size_t(*)(thread_pool_t*))get_pool_size;
        
-       this->function = job_processing;
+       this->process_jobs = process_jobs;
+       this->process_initiate_ike_sa_job = process_initiate_ike_sa_job;
+       this->process_delete_ike_sa_job = process_delete_ike_sa_job;
+       this->process_incoming_packet_job = process_incoming_packet_job;
        this->pool_size = pool_size;
        
        this->threads = allocator_alloc(sizeof(pthread_t) * pool_size);
@@ -338,7 +382,7 @@ thread_pool_t *thread_pool_create(size_t pool_size)
        /* try to create as many threads as possible, up tu pool_size */
        for (current = 0; current < pool_size; current++) 
        {
-               if (pthread_create(&(this->threads[current]), NULL, (void*(*)(void*))this->function, this) == 0) 
+               if (pthread_create(&(this->threads[current]), NULL, (void*(*)(void*))this->process_jobs, this) == 0) 
                {
                        this->pool_logger->log(this->pool_logger, CONTROL, "thread %u created", this->threads[current]);
                }
index 609fb04..aac803a 100644 (file)
@@ -1,7 +1,7 @@
 /**
  * @file thread_pool.h
  * 
- * @brief Thread pool with some threads processing the job_queue
+ * @brief Interface for thread_pool_t.
  * 
  */
 
@@ -34,18 +34,20 @@ typedef struct thread_pool_t thread_pool_t;
  * @brief A thread_pool contains a pool of threads processing the job queue.
  * 
  * Current implementation uses as many threads as specified in constructor.
- * A more improved version would dynamically increase thread count if necessary...
+ * A more improved version would dynamically increase thread count if necessary.
+ * 
+ * @ingroup threads
  */
 struct thread_pool_t {
        /**
-        * @brief return currently instanciated threads
+        * @brief Return currently instanciated threads.
         * 
         * @param thread_pool   thread_pool_t object            
         * @return                              size of thread pool
         */
        size_t (*get_pool_size) (thread_pool_t *thread_pool);
        /**
-        * @brief destroy pool
+        * @brief Destroy a thread_pool_t.
         * 
         * sends cancellation request to all threads and AWAITS their termination.
         * 
@@ -57,12 +59,14 @@ struct thread_pool_t {
 };
 
 /**
- * @brief Create the thread pool using using pool_size of threads
- *  
+ * @brief Create the thread pool using using pool_size of threads.
+ * 
  * @param pool_size                    desired pool size
- * @return                                     
- *                                                     - NULL if no threads could be created
- *                                                     - thread_pool if one ore more threads could be instanciated
+ * @return
+ *                                                     - thread_pool_t if one ore more threads could be started, or
+ *                                                     - NULL if no threads could be created
+ *
+ * @ingroup threads
  */
 thread_pool_t *thread_pool_create(size_t pool_size);