4 files changed, 119 insertions, 396 deletions

diff --git a/Source/charon/utils/logger.c b/Source/charon/utils/logger.c
index 3e2c93860..51efa2b8c 100644
--- a/Source/charon/utils/logger.c
+++ b/Source/charon/utils/logger.c
@@ -51,7 +51,7 @@ struct private_logger_t {
 	/**
 	 * Detail-level of logger.
 	 */
-	logger_level_t level;
+	log_level_t level;
 	/**
 	 * Name of logger.
 	 */
@@ -72,13 +72,13 @@ struct private_logger_t {
 	 * 
 	 * @warning: buffer must be at least have MAX_LOG size.
 	 */
-	void (*prepend_prefix) (private_logger_t *this, logger_level_t loglevel, char *string, char *buffer);
+	void (*prepend_prefix) (private_logger_t *this, log_level_t loglevel, char *string, char *buffer);
 };
 
 /**
  * Implementation of private_logger_t.prepend_prefix.
  */
-static void prepend_prefix(private_logger_t *this, logger_level_t loglevel, char *string, char *buffer)
+static void prepend_prefix(private_logger_t *this, log_level_t loglevel, char *string, char *buffer)
 {
 	char log_type, log_details;
 	if (loglevel & CONTROL)
@@ -138,7 +138,7 @@ static void prepend_prefix(private_logger_t *this, logger_level_t loglevel, char
  *
  * Yes, logg is wrong written :-).
  */
-static void logg(private_logger_t *this, logger_level_t loglevel, char *format, ...)
+static void logg(private_logger_t *this, log_level_t loglevel, char *format, ...)
 {
 	if ((this->level & loglevel) == loglevel)
 	{
@@ -170,7 +170,7 @@ static void logg(private_logger_t *this, logger_level_t loglevel, char *format,
 /**
  * Implementation of logger_t.log_bytes.
  */
-static void log_bytes(private_logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len)
+static void log_bytes(private_logger_t *this, log_level_t loglevel, char *label, char *bytes, size_t len)
 {
 	static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -272,7 +272,7 @@ static void log_bytes(private_logger_t *this, logger_level_t loglevel, char *lab
 /**
  * Implementation of logger_t.log_chunk.
  */
-static void log_chunk(logger_t *this, logger_level_t loglevel, char *label, chunk_t chunk)
+static void log_chunk(logger_t *this, log_level_t loglevel, char *label, chunk_t chunk)
 {
 	this->log_bytes(this, loglevel, label, chunk.ptr, chunk.len);
 }
@@ -280,7 +280,7 @@ static void log_chunk(logger_t *this, logger_level_t loglevel, char *label, chun
 /**
  * Implementation of logger_t.enable_level.
  */
-static void enable_level(private_logger_t *this, logger_level_t log_level)
+static void enable_level(private_logger_t *this, log_level_t log_level)
 {
 	this->level |= log_level;
 }
@@ -288,12 +288,20 @@ static void enable_level(private_logger_t *this, logger_level_t log_level)
 /**
  * Implementation of logger_t.disable_level.
  */
-static void disable_level(private_logger_t *this, logger_level_t log_level)
+static void disable_level(private_logger_t *this, log_level_t log_level)
 {
 	this->level &= ~log_level;
 }
 
 /**
+ * Implementation of logger_t.get_level.
+ */
+static log_level_t get_level(private_logger_t *this)
+{
+	return this->level;
+}
+
+/**
  * Implementation of logger_t.destroy.
  */
 static void destroy(private_logger_t *this)
@@ -305,16 +313,17 @@ static void destroy(private_logger_t *this)
 /*
  * Described in header.
  */	
-logger_t *logger_create(char *logger_name, logger_level_t log_level, bool log_thread_id, FILE * output)
+logger_t *logger_create(char *logger_name, log_level_t log_level, bool log_thread_id, FILE * output)
 {
 	private_logger_t *this = allocator_alloc_thing(private_logger_t);
 	
 	/* public functions */
-	this->public.log = (void(*)(logger_t*,logger_level_t,char*,...))logg;
-	this->public.log_bytes = (void(*)(logger_t*, logger_level_t, char*,char*,size_t))log_bytes;
+	this->public.log = (void(*)(logger_t*,log_level_t,char*,...))logg;
+	this->public.log_bytes = (void(*)(logger_t*, log_level_t, char*,char*,size_t))log_bytes;
 	this->public.log_chunk = log_chunk;
-	this->public.enable_level = (void(*)(logger_t*,logger_level_t))enable_level;
-	this->public.disable_level = (void(*)(logger_t*,logger_level_t))disable_level;
+	this->public.enable_level = (void(*)(logger_t*,log_level_t))enable_level;
+	this->public.disable_level = (void(*)(logger_t*,log_level_t))disable_level;
+	this->public.get_level = (log_level_t(*)(logger_t*))get_level;
 	this->public.destroy = (void(*)(logger_t*))destroy;
 
 	/* private functions */
diff --git a/Source/charon/utils/logger.h b/Source/charon/utils/logger.h
index 52c21e6ef..bdf5e180e 100644
--- a/Source/charon/utils/logger.h
+++ b/Source/charon/utils/logger.h
@@ -28,7 +28,7 @@
 #include <types.h>
 
 
-typedef enum logger_level_t logger_level_t;
+typedef enum log_level_t log_level_t;
 
 /**
  * @brief Log Levels supported by the logger object.
@@ -43,7 +43,7 @@ typedef enum logger_level_t logger_level_t;
  * 
  * @ingroup utils
  */
-enum logger_level_t {
+enum log_level_t {
 	/**
 	 * Control flow.
 	 */
@@ -107,11 +107,11 @@ struct logger_t {
 	 * the log is done.
 	 *
 	 * @param this 		logger_t object
-	 * @param loglevel 	or'ed set of logger_level_t's
+	 * @param loglevel 	or'ed set of log_level_t's
 	 * @param format 	printf like format string
 	 * @param ... 		printf like parameters
 	 */
-	void (*log) (logger_t *this, logger_level_t log_level, char *format, ...);
+	void (*log) (logger_t *this, log_level_t log_level, char *format, ...);
 
 	/**
 	 * @brief Log some bytes, useful for debugging.
@@ -120,12 +120,12 @@ struct logger_t {
 	 * the log is done.
 	 *
 	 * @param this 		logger_t object
-	 * @param loglevel 	or'ed set of logger_level_t's
+	 * @param loglevel 	or'ed set of log_level_t's
 	 * @param label 	a labeling name, logged with the bytes
 	 * @param bytes 	pointer to the bytes to dump
 	 * @param len	 	number of bytes to dump
 	 */
-	void (*log_bytes) (logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len);
+	void (*log_bytes) (logger_t *this, log_level_t loglevel, char *label, char *bytes, size_t len);
 
 	/**
 	 * @brief Log a chunk, useful for debugging.
@@ -134,27 +134,35 @@ struct logger_t {
 	 * the log is done.
 	 *
 	 * @param this 		logger_t object
-	 * @param loglevel 	or'ed set of logger_level_t's
+	 * @param loglevel 	or'ed set of log_level_t's
 	 * @param label 	a labeling name, logged with the bytes
 	 * @param chunk		chunk to log
 	 */
-	void (*log_chunk) (logger_t *this, logger_level_t loglevel, char *label, chunk_t chunk);
+	void (*log_chunk) (logger_t *this, log_level_t loglevel, char *label, chunk_t chunk);
 
 	/**
 	 * @brief Enables a loglevel for the current logger_t object.
 	 *
-	 * @param 			this logger_t object
-	 * @param 			log_level loglevel to enable
+	 * @param this 		logger_t object
+	 * @param log_level loglevel to enable
 	 */
-	void (*enable_level) (logger_t *this, logger_level_t log_level);
+	void (*enable_level) (logger_t *this, log_level_t log_level);
 
 	/**
 	 * @brief Disables a loglevel for the current logger_t object.
 	 *
-	 * @param 			this logger_t object
-	 * @param 			log_level loglevel to enable
+	 * @param this 		logger_t object
+	 * @param log_level loglevel to enable
+	 */
+	void (*disable_level) (logger_t *this, log_level_t log_level);
+
+	/**
+	 * @brief Get the currently used loglevel.
+	 *
+	 * @param this 		logger_t object
+	 * @return			currently used loglevel
 	 */
-	void (*disable_level) (logger_t *this, logger_level_t log_level);
+	log_level_t (*get_level) (logger_t *this);
 
 	/**
 	 * @brief Destroys a logger_t object.
@@ -175,7 +183,7 @@ struct logger_t {
  * 
  * @ingroup utils
  */
-logger_t *logger_create(char *logger_name, logger_level_t log_level, bool log_thread_id, FILE * output);
+logger_t *logger_create(char *logger_name, log_level_t log_level, bool log_thread_id, FILE * output);
 
 
 #endif /*LOGGER_H_*/
diff --git a/Source/charon/utils/logger_manager.c b/Source/charon/utils/logger_manager.c
index fe8ae9bc5..ad7a03164 100644
--- a/Source/charon/utils/logger_manager.c
+++ b/Source/charon/utils/logger_manager.c
@@ -33,28 +33,49 @@
  */
 mapping_t logger_context_t_mappings[] = {
 	{PARSER, "PARSER"},
-	{GENERATOR, "GENRAT"},
+	{GENERATOR, "GENERATOR"},
 	{IKE_SA, "IKE_SA"},
-	{IKE_SA_MANAGER, "ISAMGR"},
-	{CHILD_SA, "CHLDSA"},
-	{MESSAGE, "MESSAG"},
-	{THREAD_POOL, "THPOOL"},
+	{IKE_SA_MANAGER, "IKE_SA_MANAGER"},
+	{CHILD_SA, "CHILD_SA"},
+	{MESSAGE, "MESSAGE"},
+	{THREAD_POOL, "THREAD_POOL"},
 	{WORKER, "WORKER"},
-	{SCHEDULER, "SCHEDU"},
+	{SCHEDULER, "SCHEDULER"},
 	{SENDER, "SENDER"},
-	{RECEIVER, "RECEVR"},
+	{RECEIVER, "RECEIVER"},
 	{SOCKET, "SOCKET"},
 	{TESTER, "TESTER"},
 	{DAEMON, "DAEMON"},
 	{CONFIG, "CONFIG"},
-	{ENCRYPTION_PAYLOAD, "ENCPLD"},
+	{ENCRYPTION_PAYLOAD, "ENCRYPTION_PAYLOAD"},
+	{PAYLOAD, "PAYLOAD"},
 	{MAPPING_END, NULL},
 };
 
-/** 
- * Maximum length of a logger name in bytes.
- */
-#define MAX_LOGGER_NAME 45
+struct {
+	char *name;
+	log_level_t level;
+	bool log_thread_ids;
+	FILE *output;
+} logger_defaults[] = {
+	{ "PARSR", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* PARSER */
+	{ "GNRAT", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* GENERATOR */
+	{ "IKESA", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* IKE_SA */
+	{ "SAMGR", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* IKE_SA_MANAGER */
+	{ "CHDSA", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* CHILD_SA */
+	{ "MESSG", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* MESSAGE */
+	{ "TPOOL", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* THREAD_POOL */
+	{ "WORKR", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* WORKER */
+	{ "SCHED", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* SCHEDULER */
+	{ "SENDR", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* SENDER */
+	{ "RECVR", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* RECEIVER */
+	{ "SOCKT", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* SOCKET */
+	{ "TESTR", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* TESTER */
+	{ "DAEMN", ERROR|CONTROL|AUDIT|LEVEL0,	FALSE, NULL}, /* DAEMON */
+	{ "CONFG", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* CONFIG */
+	{ "ENCPL", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* ENCRYPTION_PAYLOAD */
+	{ "PAYLD", ERROR|CONTROL|AUDIT|LEVEL0,	TRUE,  NULL}, /* PAYLOAD */
+};
 
 
 typedef struct private_logger_manager_t private_logger_manager_t;
@@ -69,372 +90,78 @@ struct private_logger_manager_t {
 	logger_manager_t public;
 
 	/**
-	 * List of managed loggers.
-	 */
-	linked_list_t *loggers;
-	
-	/**
-	 * Log Levels.
-	 */
-	linked_list_t *logger_levels;
-	
-	/**
-	 * Used to manage logger list.
-	 */
-	pthread_mutex_t mutex;
-	
-	/**
-	 * Default logger level for a created logger used 
-	 * if no specific logger_level is set.
+	 * Array of loggers, one for each context
 	 */
-	logger_level_t default_log_level;
-	
-	/**
-	 * Sets set logger_level of a specific context.
-	 * 
-	 * @param this 			calling object
-	 * @param context 		context to set level
- 	 * @param logger_level 	logger_level to set
- 	 * @param enable 		enable specific level or disable it
-	 */
-	void (*set_logger_level) (private_logger_manager_t *this, 
-							  logger_context_t context,
-							  logger_level_t logger_level,
-							  bool enable);
+	logger_t *loggers[LOGGER_CONTEXT_ROOF];
 	
 };
 
-
-typedef struct logger_levels_entry_t logger_levels_entry_t;
-
-/**
- * Entry in the logger_levels linked list.
- * 
- * This entry specifies the current log level for 
- * logger_t objects in specific context.
- */
-struct logger_levels_entry_t {
-	/**
-	 * Logger context.
-	 */
-	logger_context_t context;
-	
-	/**
-	 * Logger level of logger context.
-	 */
-	logger_level_t level;
-};
-
-
-typedef struct loggers_entry_t loggers_entry_t;
-
-/**
- * Entry in the loggers linked list.
- * 
- * @todo Replace loggers_entry_t with logger_t and add get_context() function to logger_t class.
- */
-struct loggers_entry_t {
-	/**
-	 * Logger context.
-	 */
-	logger_context_t context;
-	/**
-	 * Assigned logger
-	 */
-	logger_t *logger;
-};
-
-/**
- * Implementation of logger_manager_t.create_logger.
- */
-static logger_t *create_logger(private_logger_manager_t *this, logger_context_t context, char * name)
-{
-	
-	char * context_name;
-	bool log_thread_ids = TRUE;
-	FILE * output = NULL;
-	char buffer[MAX_LOGGER_NAME];
-	loggers_entry_t *entry;
-	logger_t *logger;
-	logger_level_t logger_level = 0;
-	
-	context_name = mapping_find(logger_context_t_mappings,context);
-	
-	/* output to stdout, since we are debugging all days */
-	output = LOG_OUTPUT;
-	
-	/* defaults */
-	log_thread_ids = FALSE;
-	logger_level = this->public.get_logger_level(&(this->public), context);
-
-	switch(context)
-	{
-		case TESTER:
-			output = stdout;
-			break;
-		case IKE_SA_MANAGER:
-			log_thread_ids = TRUE;
-			break;
-		case IKE_SA:
-			log_thread_ids = TRUE;
-			break;
-		case CHILD_SA:
-			log_thread_ids = TRUE;
-			break;
-		case CONFIG:
-			log_thread_ids = TRUE;
-			break;
-		case MESSAGE:
-			log_thread_ids = TRUE;
-			break;
-		case ENCRYPTION_PAYLOAD:
-			log_thread_ids = TRUE;
-			break;
-		case GENERATOR:
-			log_thread_ids = TRUE;
-			break;
-		case PARSER:
-			log_thread_ids = TRUE;
-			break;
-		case WORKER:
-			log_thread_ids = TRUE;
-			break;
-		case THREAD_POOL:
-			break;
-		case SCHEDULER:
-			break;
-		case SENDER:
-			break;
-		case RECEIVER:
-			break;
-		case SOCKET:
-			break;
-		case DAEMON:
-			break;
-	}
-	
-	/* logger manager is thread save */
-	pthread_mutex_lock(&(this->mutex));
-	if (name != NULL)
-	{
-		snprintf(buffer, MAX_LOGGER_NAME, "%s - %s",context_name,name);
-			/* create logger with default log_level */
-		logger = logger_create(buffer,logger_level,log_thread_ids,output);
-	}
-	else
-	{
-		logger = logger_create(context_name,logger_level,log_thread_ids,output);
-	}
-	
-
-	entry = allocator_alloc_thing(loggers_entry_t);
-
-	entry->context = context;
-	entry->logger = logger;
-
-	this->loggers->insert_last(this->loggers,entry);
-
-	pthread_mutex_unlock(&(this->mutex));
-	return logger;
-	
-}
-
 /**
- * Implementation of logger_manager_t.get_logger_level.
+ * Implementation of logger_manager_t.get_logger.
  */
-static logger_level_t get_logger_level (private_logger_manager_t *this, logger_context_t context)
+static logger_t *get_logger(private_logger_manager_t *this, logger_context_t context)
 {
-	iterator_t *iterator;
-	/* set logger_level to default logger_level */
-	logger_level_t logger_level = this->default_log_level;
-
-	pthread_mutex_lock(&(this->mutex));
-
-	iterator = this->logger_levels->create_iterator(this->logger_levels,TRUE);
-	/* check for existing logger_level entry */
-	while (iterator->has_next(iterator))
-	{
-		logger_levels_entry_t * entry;
-		iterator->current(iterator,(void **)&entry);
-		if (entry->context == context)
-		{
-			logger_level = entry->level;
-			break;
-		}
-	}
-	iterator->destroy(iterator);
-
-	pthread_mutex_unlock(&(this->mutex));
-	return logger_level;
+	return this->loggers[context];
 }
 
 /**
- * Implementation of logger_manager_t.destroy_logger.
+ * Implementation of logger_manager_t.get_log_level.
  */
-static void destroy_logger(private_logger_manager_t *this,logger_t *logger)
+static log_level_t get_log_level (private_logger_manager_t *this, logger_context_t context)
 {
-	iterator_t *iterator;
-	
-	pthread_mutex_lock(&(this->mutex));
-	
-	iterator = this->loggers->create_iterator(this->loggers,TRUE);
-	while (iterator->has_next(iterator))
-	{
-		loggers_entry_t * entry;
-		iterator->current(iterator,(void **)&entry);
-		if (entry->logger == logger)
-		{
-			iterator->remove(iterator);
-			allocator_free(entry);
-			logger->destroy(logger);
-			break; 
-		}
-	}
-	iterator->destroy(iterator);
-	pthread_mutex_unlock(&(this->mutex));
+	return this->loggers[context]->get_level(this->loggers[context]);
 }
 
 /**
- * Implementation of private_logger_manager_t.set_logger_level.
+ * Implementation of private_logger_manager_t.enable_log_level.
  */
-static void set_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level,bool enable)
+static void enable_log_level(private_logger_manager_t *this, logger_context_t context, log_level_t level)
 {
-	iterator_t *iterator;
-	bool found = FALSE;
-	
-	pthread_mutex_lock(&(this->mutex));
-	iterator = this->logger_levels->create_iterator(this->logger_levels,TRUE);
-
-	/* find existing logger_level entry */
-	while (iterator->has_next(iterator))
-	{	
-		logger_levels_entry_t * entry;
-		iterator->current(iterator,(void **)&entry);
-		if (entry->context == context)
-		{
-			if (enable)
-			{
-				entry->level |= logger_level;
-			}
-			else
-			{
-				entry->level &= ~logger_level;
-			}
-			found = TRUE;
-			break; 
-		}
-	}
-	iterator->destroy(iterator);
-	
-	if (!found)
-	{
-		/* logger_levels entry not existing for current context */
-		logger_levels_entry_t *entry = allocator_alloc_thing(logger_levels_entry_t);
-
-		entry->context = context;
-		entry->level = 	(enable) ? logger_level : (this->default_log_level & (~logger_level));
-
-		this->logger_levels->insert_last(this->logger_levels,entry);
-	}
-	
-	iterator = this->loggers->create_iterator(this->loggers,TRUE);
-	while (iterator->has_next(iterator))
-	{
-		loggers_entry_t * entry;
-		iterator->current(iterator,(void **)&entry);
-
-		if (entry->context == context)
-		{
-			if (enable)
-			{
-				entry->logger->enable_level(entry->logger,logger_level);
-			}
-			else
-			{
-				entry->logger->disable_level(entry->logger,logger_level);
-			}
-			
-		}
-	}
-	iterator->destroy(iterator);
-	
-	pthread_mutex_unlock(&(this->mutex));
+	this->loggers[context]->enable_level(this->loggers[context], level);
 }
 
 /**
- * Implementation of logger_manager_t.enable_logger_level.
+ * Implementation of private_logger_manager_t.disable_log_level.
  */
-static void enable_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
+static void disable_log_level(private_logger_manager_t *this, logger_context_t context, log_level_t level)
 {
-	return set_logger_level(this,context,logger_level,TRUE);
+	this->loggers[context]->disable_level(this->loggers[context], level);
 }
 
-/**
- * Implementation of logger_manager_t.disable_logger_level.
- */
-static void disable_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
-{
-	return set_logger_level(this,context,logger_level,FALSE);
-}
 
 /**
  * Implementation of logger_manager_t.destroy.
  */
 static void destroy(private_logger_manager_t *this)
 {
-
-	while (this->loggers->get_count(this->loggers) > 0)
-	{
-		loggers_entry_t *current_entry;
-		
-		this->loggers->remove_first(this->loggers,(void **)&current_entry);
-		
-		/* destroy logger object */
-		current_entry->logger->destroy(current_entry->logger);
-		
-		/* entry can be destroyed */
-		allocator_free(current_entry);	
-	}
-	
-	while (this->logger_levels->get_count(this->logger_levels) > 0)
+	int i;
+	for (i = 0; i < LOGGER_CONTEXT_ROOF; i++)
 	{
-		logger_levels_entry_t *current_entry;
-		
-		this->logger_levels->remove_first(this->logger_levels,(void **)&current_entry);
-		
-		/* entry can be destroyed */
-		allocator_free(current_entry);
+		this->loggers[i]->destroy(this->loggers[i]);
 	}
-	
-	this->loggers->destroy(this->loggers);
-	this->logger_levels->destroy(this->logger_levels);
-	pthread_mutex_destroy(&(this->mutex));
-	
 	allocator_free(this);
 }
 
 /*
  * Described in header.
  */
-logger_manager_t *logger_manager_create(logger_level_t default_log_level)
+logger_manager_t *logger_manager_create(log_level_t default_log_level)
 {
 	private_logger_manager_t *this = allocator_alloc_thing(private_logger_manager_t);
+	int i;
 	
-	this->public.create_logger = (logger_t *(*)(logger_manager_t*,logger_context_t context, char *))create_logger;
-	this->public.destroy_logger = (void(*)(logger_manager_t*,logger_t *logger))destroy_logger;
+	this->public.get_logger = (logger_t *(*)(logger_manager_t*,logger_context_t context))get_logger;
+	this->public.get_log_level = (log_level_t (*)(logger_manager_t *, logger_context_t)) get_log_level;
+	this->public.enable_log_level = (void (*)(logger_manager_t *, logger_context_t, log_level_t)) enable_log_level;
+	this->public.disable_log_level = (void (*)(logger_manager_t *, logger_context_t, log_level_t)) disable_log_level;
 	this->public.destroy = (void(*)(logger_manager_t*))destroy;
-	this->public.get_logger_level = (logger_level_t (*)(logger_manager_t *, logger_context_t)) get_logger_level;
-	this->public.enable_logger_level = (void (*)(logger_manager_t *, logger_context_t,logger_level_t)) enable_logger_level;
-	this->public.disable_logger_level = (void (*)(logger_manager_t *, logger_context_t,logger_level_t)) disable_logger_level;
-	this->set_logger_level = (void (*)(private_logger_manager_t *, logger_context_t,logger_level_t,bool)) set_logger_level;
 	
-	/* private variables */
-	this->loggers = linked_list_create();
-	this->logger_levels = linked_list_create();
-	this->default_log_level = default_log_level;
+	for (i = 0; i < LOGGER_CONTEXT_ROOF; i++)
+	{
+		this->loggers[i] = logger_create(logger_defaults[i].name, logger_defaults[i].level, 
+										 logger_defaults[i].log_thread_ids, logger_defaults[i].output);
+	}
 	
-	pthread_mutex_init(&(this->mutex), NULL);
-
-	return (logger_manager_t*)this;
+	return &this->public;
 }
 
diff --git a/Source/charon/utils/logger_manager.h b/Source/charon/utils/logger_manager.h
index f160c0c37..475fdc919 100644
--- a/Source/charon/utils/logger_manager.h
+++ b/Source/charon/utils/logger_manager.h
@@ -36,7 +36,7 @@ typedef enum logger_context_t logger_context_t;
  * @ingroup utils
  */
 enum logger_context_t {
-	PARSER,
+	PARSER = 0,
 	GENERATOR,
 	IKE_SA,
 	IKE_SA_MANAGER,
@@ -52,6 +52,8 @@ enum logger_context_t {
 	DAEMON,
 	CONFIG,
 	ENCRYPTION_PAYLOAD,
+	PAYLOAD,
+	LOGGER_CONTEXT_ROOF,
 };
 
 
@@ -69,23 +71,12 @@ typedef struct logger_manager_t logger_manager_t;
  * 
  * @see logger_t
  * 
- * @todo We currently give out a new instance for every logger requested.
- * This is unnecessary. One logger for each class would be sufficient.
- * 
- * @todo We could remove logger naming (additional to classes), since we have
- * never used it (and probably never will).
- * 
  * @ingroup utils
  */
 struct logger_manager_t {
 	
 	/**
 	 * @brief Gets a logger_t object for a specific logger context.
-	 * 
-	 * @warning Objects of type logger_t which are not destroyed over function
-	 * #logger_manager_t.destroy_logger are destroyed in logger_managers 
-	 * destroy function. Don't use logger_t's own destroy function with 
-	 * managed logger_t objects.
 	 *
 	 * @param this			logger_manager_t object
 	 * @param context		logger_context to use the logger for
@@ -93,37 +84,25 @@ struct logger_manager_t {
 	 * 						and has not to be specified (so NULL is allowed)
 	 * @return				logger_t object
 	 */
-	logger_t *(*create_logger) (logger_manager_t *this, logger_context_t context, char *name);
-	
-	/**
-	 * @brief Destroys a logger_t object which is not used anymore.
-	 * 
-	 * Objects of type logger_t which are not destroyed over function
-	 * #logger_manager_t.destroy_logger are destroyed in logger_managers 
-	 * destroy function.
-	 *
-	 * @param this		logger_manager_t object
-	 * @param logger	pointer to the logger which has to be destroyed
-	 */
-	void (*destroy_logger) (logger_manager_t *this,logger_t *logger);
+	logger_t *(*get_logger) (logger_manager_t *this, logger_context_t context);
 	
 	/**
-	 * Returns the set logger_level of a specific context or 0.
+	 * Returns the set log_level of a specific context or 0.
 	 * 
 	 * @param this 			calling object
 	 * @param context 		context to check level
-	 * @return				logger_level for the given logger_context
+	 * @return				log_level for the given logger_context
 	 */
-	logger_level_t (*get_logger_level) (logger_manager_t *this, logger_context_t context);
+	log_level_t (*get_log_level) (logger_manager_t *this, logger_context_t context);
 	
 	/**
 	 * Enables a logger level of a specific context.
 	 * 
 	 * @param this 			calling object
 	 * @param context 		context to set level
- 	 * @param logger_level 	logger level to eanble
+ 	 * @param log_level 	logger level to eanble
 	 */
-	void (*enable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
+	void (*enable_log_level) (logger_manager_t *this, logger_context_t context,log_level_t log_level);
 		
 
 	/**
@@ -131,9 +110,9 @@ struct logger_manager_t {
 	 * 
 	 * @param this 			calling object
 	 * @param context 		context to set level
- 	 * @param logger_level 	logger level to disable
+ 	 * @param log_level 	logger level to disable
 	 */
-	void (*disable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
+	void (*disable_log_level) (logger_manager_t *this, logger_context_t context,log_level_t log_level);
 
 
 	/**
@@ -154,7 +133,7 @@ struct logger_manager_t {
  * 
  * @ingroup utils
  */
-logger_manager_t *logger_manager_create(logger_level_t default_log_level);
+logger_manager_t *logger_manager_create(log_level_t default_log_level);
 
 
 #endif /*LOGGER_MANAGER_H_*/