denozord/strongswan-ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- rewrite of logger_manager, uses now one instance per context

Browse Source 
- cleanups for logger here and there
- removed critical flag check in payload verification (conformance to IKEv2)
- so thats and theres everywere... ;-)
This commit is contained in:
Martin Willi
2006-03-23 15:25:43 +00:00
parent 3264ce50b9
commit dec598220b
59 changed files with 461 additions and 762 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/charon/utils/logger.c
+22 -13
View File
@@ -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,11 +288,19 @@ 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.
*/
@@ -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 */
Source/charon/utils/logger.h
+23 -15
View File
@@ -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, logger_level_t log_level);
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
*/
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_*/
Source/charon/utils/logger_manager.c
+62 -335
View File
@@ -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.
* Array of loggers, one for each context
*/
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.
*/
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.
* Implementation of logger_manager_t.get_logger.
*/
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)
static logger_t *get_logger(private_logger_manager_t *this, logger_context_t context)
{
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;
return this->loggers[context];
}
/**
* Implementation of logger_manager_t.get_logger_level.
* Implementation of logger_manager_t.get_log_level.
*/
static logger_level_t get_logger_level (private_logger_manager_t *this, logger_context_t context)
static log_level_t get_log_level (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]->get_level(this->loggers[context]);
}
/**
* Implementation of logger_manager_t.destroy_logger.
* Implementation of private_logger_manager_t.enable_log_level.
*/
static void destroy_logger(private_logger_manager_t *this,logger_t *logger)
static void enable_log_level(private_logger_manager_t *this, logger_context_t context, log_level_t level)
{
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));
this->loggers[context]->enable_level(this->loggers[context], level);
}
/**
* Implementation of private_logger_manager_t.set_logger_level.
* Implementation of private_logger_manager_t.disable_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 disable_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]->disable_level(this->loggers[context], level);
}
/**
* Implementation of logger_manager_t.enable_logger_level.
*/
static void enable_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
{
return set_logger_level(this,context,logger_level,TRUE);
}
/**
* 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)
int i;
for (i = 0; i < LOGGER_CONTEXT_ROOF; i++)
{
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);
this->loggers[i]->destroy(this->loggers[i]);
}
while (this->logger_levels->get_count(this->logger_levels) > 0)
{
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->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;
}
Source/charon/utils/logger_manager.h
+12 -33
View File
@@ -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);
logger_t *(*get_logger) (logger_manager_t *this, logger_context_t context);
/**
* @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);
/**
* 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_*/