debug_t group;
level_t def;
- sys_logger = sys_logger_create(LOG_DAEMON, FALSE);
+ sys_logger = sys_logger_create(LOG_DAEMON);
def = lib->settings->get_int(lib->settings,
"charon-nm.syslog.default", 1);
for (group = 0; group < DBG_MAX; group++)
int loggers_defined = 0;
debug_t group;
level_t def;
- bool append, ike_name;
- FILE *file;
/* setup sysloggers */
identifier = lib->settings->get_str(lib->settings,
{
loggers_defined++;
- ike_name = lib->settings->get_bool(lib->settings,
- "charon.syslog.%s.ike_name", FALSE, facility);
if (streq(facility, "daemon"))
{
- sys_logger = sys_logger_create(LOG_DAEMON, ike_name);
+ sys_logger = sys_logger_create(LOG_DAEMON);
}
else if (streq(facility, "auth"))
{
- sys_logger = sys_logger_create(LOG_AUTHPRIV, ike_name);
+ sys_logger = sys_logger_create(LOG_AUTHPRIV);
}
else
{
continue;
}
+ sys_logger->set_options(sys_logger,
+ lib->settings->get_bool(lib->settings,
+ "charon.syslog.%s.ike_name", FALSE, facility));
+
def = lib->settings->get_int(lib->settings,
"charon.syslog.%s.default", 1, facility);
for (group = 0; group < DBG_MAX; group++)
while (enumerator->enumerate(enumerator, &filename))
{
loggers_defined++;
- if (streq(filename, "stderr"))
- {
- file = stderr;
- }
- else if (streq(filename, "stdout"))
- {
- file = stdout;
- }
- else
- {
- append = lib->settings->get_bool(lib->settings,
- "charon.filelog.%s.append", TRUE, filename);
- file = fopen(filename, append ? "a" : "w");
- if (file == NULL)
- {
- DBG1(DBG_DMN, "opening file %s for logging failed: %s",
- filename, strerror(errno));
- continue;
- }
- if (lib->settings->get_bool(lib->settings,
- "charon.filelog.%s.flush_line", FALSE, filename))
- {
- setlinebuf(file);
- }
- }
- file_logger = file_logger_create(file,
+ file_logger = file_logger_create(filename);
+ file_logger->set_options(file_logger,
lib->settings->get_str(lib->settings,
"charon.filelog.%s.time_format", NULL, filename),
lib->settings->get_bool(lib->settings,
"charon.filelog.%s.ike_name", FALSE, filename));
+ file_logger->open(file_logger,
+ lib->settings->get_bool(lib->settings,
+ "charon.filelog.%s.flush_line", FALSE, filename),
+ lib->settings->get_bool(lib->settings,
+ "charon.filelog.%s.append", TRUE, filename));
def = lib->settings->get_int(lib->settings,
"charon.filelog.%s.default", 1, filename);
for (group = 0; group < DBG_MAX; group++)
if (!loggers_defined)
{
/* set up default stdout file_logger */
- file_logger = file_logger_create(stdout, NULL, FALSE);
+ file_logger = file_logger_create("stdout");
+ file_logger->open(file_logger, FALSE, FALSE);
charon->file_loggers->insert_last(charon->file_loggers, file_logger);
/* set up default daemon sys_logger */
- sys_logger = sys_logger_create(LOG_DAEMON, FALSE);
+ sys_logger = sys_logger_create(LOG_DAEMON);
charon->sys_loggers->insert_last(charon->sys_loggers, sys_logger);
for (group = 0; group < DBG_MAX; group++)
{
charon->bus->add_logger(charon->bus, &sys_logger->logger);
/* set up default auth sys_logger */
- sys_logger = sys_logger_create(LOG_AUTHPRIV, FALSE);
+ sys_logger = sys_logger_create(LOG_AUTHPRIV);
sys_logger->set_level(sys_logger, DBG_ANY, LEVEL_AUDIT);
charon->sys_loggers->insert_last(charon->sys_loggers, sys_logger);
charon->bus->add_logger(charon->bus, &sys_logger->logger);
#include "config.h"
#include "hooks/hook.h"
+#include <bus/listeners/file_logger.h>
#include <threading/thread.h>
#include <credentials/certificates/x509.h>
{
enumerator_t *enumerator;
char *section;
- FILE *file;
load_log_levels(logger, "stdout");
{
if (!streq(section, "stdout"))
{
- file = fopen(section, "w");
- if (file == NULL)
- {
- fprintf(stderr, "opening file %s for logging failed: %s",
- section, strerror(errno));
- continue;
- }
- logger = file_logger_create(file, NULL, FALSE);
+ logger = file_logger_create(section);
+ logger->set_options(logger, NULL, FALSE);
+ logger->open(logger, FALSE, FALSE);
load_log_levels(logger, section);
charon->bus->add_logger(charon->bus, &logger->logger);
conftest->loggers->insert_last(conftest->loggers, logger);
);
lib->credmgr->add_set(lib->credmgr, &conftest->creds->set);
- logger = file_logger_create(stdout, NULL, FALSE);
+ logger = file_logger_create("stdout");
+ logger->set_options(logger, NULL, FALSE);
+ logger->open(logger, FALSE, FALSE);
logger->set_level(logger, DBG_ANY, LEVEL_CTRL);
charon->bus->add_logger(charon->bus, &logger->logger);
conftest->loggers->insert_last(conftest->loggers, logger);
{
file_logger_t *file_logger;
debug_t group;
- FILE *file;
- /* truncate an existing file */
- file = fopen(logfile, "w");
- if (!file)
- {
- DBG1(DBG_DMN, "opening file %s for logging failed: %s",
- logfile, strerror(errno));
- return;
- }
- /* flush each line */
- setlinebuf(file);
-
- file_logger = file_logger_create(file, "%b %e %T", FALSE);
+ file_logger = file_logger_create(logfile);
+ file_logger->set_options(file_logger, "%b %e %T", FALSE);
+ file_logger->open(file_logger, TRUE, FALSE);
for (group = 0; group < DBG_MAX; group++)
{
file_logger->set_level(file_logger, group, ANDROID_DEBUG_LEVEL);
#include <stdio.h>
#include <string.h>
#include <time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
#include "file_logger.h"
+#include <daemon.h>
#include <threading/mutex.h>
+#include <threading/rwlock.h>
typedef struct private_file_logger_t private_file_logger_t;
file_logger_t public;
/**
- * output file
+ * File name of the target
+ */
+ char *filename;
+
+ /**
+ * Current output file
*/
FILE *out;
* Mutex to ensure multi-line log messages are not torn apart
*/
mutex_t *mutex;
+
+ /**
+ * Lock to read/write options (FD, levels, time_format, etc.)
+ */
+ rwlock_t *lock;
};
METHOD(logger_t, log_, void,
struct tm tm;
time_t t;
+ this->lock->read_lock(this->lock);
+ if (!this->out)
+ { /* file is not open */
+ this->lock->unlock(this->lock);
+ return;
+ }
if (this->time_format)
{
t = time(NULL);
current = next + 1;
}
this->mutex->unlock(this->mutex);
+ this->lock->unlock(this->lock);
}
METHOD(logger_t, get_level, level_t,
private_file_logger_t *this, debug_t group)
{
- return this->levels[group];
+ level_t level;
+
+ this->lock->read_lock(this->lock);
+ level = this->levels[group];
+ this->lock->unlock(this->lock);
+ return level;
}
METHOD(file_logger_t, set_level, void,
private_file_logger_t *this, debug_t group, level_t level)
{
+ this->lock->write_lock(this->lock);
if (group < DBG_ANY)
{
this->levels[group] = level;
this->levels[group] = level;
}
}
+ this->lock->unlock(this->lock);
}
-METHOD(file_logger_t, destroy, void,
- private_file_logger_t *this)
+METHOD(file_logger_t, set_options, void,
+ private_file_logger_t *this, char *time_format, bool ike_name)
{
- if (this->out != stdout && this->out != stderr)
+ this->lock->write_lock(this->lock);
+ free(this->time_format);
+ this->time_format = strdupnull(time_format);
+ this->ike_name = ike_name;
+ this->lock->unlock(this->lock);
+}
+
+/**
+ * Close the current file, if any
+ */
+static void close_file(private_file_logger_t *this)
+{
+ if (this->out && this->out != stdout && this->out != stderr)
{
fclose(this->out);
+ this->out = NULL;
+ }
+}
+
+METHOD(file_logger_t, open_, void,
+ private_file_logger_t *this, bool flush_line, bool append)
+{
+ FILE *file;
+
+ if (streq(this->filename, "stderr"))
+ {
+ file = stderr;
+ }
+ else if (streq(this->filename, "stdout"))
+ {
+ file = stdout;
+ }
+ else
+ {
+ file = fopen(this->filename, append ? "a" : "w");
+ if (file == NULL)
+ {
+ DBG1(DBG_DMN, "opening file %s for logging failed: %s",
+ this->filename, strerror(errno));
+ return;
+ }
+ if (flush_line)
+ {
+ setlinebuf(file);
+ }
}
+ this->lock->write_lock(this->lock);
+ close_file(this);
+ this->out = file;
+ this->lock->unlock(this->lock);
+}
+
+METHOD(file_logger_t, destroy, void,
+ private_file_logger_t *this)
+{
+ this->lock->write_lock(this->lock);
+ close_file(this);
+ this->lock->unlock(this->lock);
this->mutex->destroy(this->mutex);
+ this->lock->destroy(this->lock);
+ free(this->time_format);
+ free(this->filename);
free(this);
}
/*
* Described in header.
*/
-file_logger_t *file_logger_create(FILE *out, char *time_format, bool ike_name)
+file_logger_t *file_logger_create(char *filename)
{
private_file_logger_t *this;
.get_level = _get_level,
},
.set_level = _set_level,
+ .set_options = _set_options,
+ .open = _open_,
.destroy = _destroy,
},
- .out = out,
- .time_format = time_format,
- .ike_name = ike_name,
+ .filename = strdup(filename),
.mutex = mutex_create(MUTEX_TYPE_DEFAULT),
+ .lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
);
set_level(this, DBG_ANY, LEVEL_SILENT);
return &this->public;
}
-
/*
+ * Copyright (C) 2012 Tobias Brunner
* Copyright (C) 2006 Martin Willi
* Hochschule fuer Technik Rapperswil
*
void (*set_level) (file_logger_t *this, debug_t group, level_t level);
/**
+ * Set options used by this logger
+ *
+ * @param time_format format of timestamp prefix, as in strftime(), cloned
+ * @param ike_name TRUE to prefix the name of the IKE_SA
+ */
+ void (*set_options) (file_logger_t *this, char *time_format, bool ike_name);
+
+ /**
+ * Open (or reopen) the log file according to the given parameters
+ *
+ * @param flush_line TRUE to flush buffers after every logged line
+ * @param append FALSE to overwrite an existing file, TRUE to append
+ */
+ void (*open) (file_logger_t *this, bool flush_line, bool append);
+
+ /**
* Destroys a file_logger_t object.
*/
void (*destroy) (file_logger_t *this);
/**
* Constructor to create a file_logger_t object.
*
- * @param out FILE to write to
- * @param time_format format of timestamp prefix, as in strftime()
- * @param ike_name TRUE to prefix the name of the IKE_SA
- * @return file_logger_t object
+ * The logger has to be opened via file_logger_t.open() before anything is
+ * logged.
+ *
+ * @param filename name of the log file (stderr and stdout are handled
+ * specially), cloned
+ * @return file_logger_t object
*/
-file_logger_t *file_logger_create(FILE *out, char *time_format, bool ike_name);
+file_logger_t *file_logger_create(char *filename);
#endif /** FILE_LOGGER_H_ @}*/
#include "sys_logger.h"
#include <threading/mutex.h>
+#include <threading/rwlock.h>
typedef struct private_sys_logger_t private_sys_logger_t;
* Mutex to ensure multi-line log messages are not torn apart
*/
mutex_t *mutex;
+
+ /**
+ * Lock to read/write options (levels, ike_name)
+ */
+ rwlock_t *lock;
};
METHOD(logger_t, log_, void,
/* cache group name and optional name string */
snprintf(groupstr, sizeof(groupstr), "%N", debug_names, group);
+ this->lock->read_lock(this->lock);
if (this->ike_name && ike_sa)
{
if (ike_sa->get_peer_cfg(ike_sa))
ike_sa->get_unique_id(ike_sa));
}
}
+ this->lock->unlock(this->lock);
/* do a syslog for every line */
this->mutex->lock(this->mutex);
METHOD(logger_t, get_level, level_t,
private_sys_logger_t *this, debug_t group)
{
- return this->levels[group];
+ level_t level;
+
+ this->lock->read_lock(this->lock);
+ level = this->levels[group];
+ this->lock->unlock(this->lock);
+ return level;
}
METHOD(sys_logger_t, set_level, void,
private_sys_logger_t *this, debug_t group, level_t level)
{
+ this->lock->write_lock(this->lock);
if (group < DBG_ANY)
{
this->levels[group] = level;
this->levels[group] = level;
}
}
+ this->lock->unlock(this->lock);
+}
+
+METHOD(sys_logger_t, set_options, void,
+ private_sys_logger_t *this, bool ike_name)
+{
+ this->lock->write_lock(this->lock);
+ this->ike_name = ike_name;
+ this->lock->unlock(this->lock);
}
METHOD(sys_logger_t, destroy, void,
private_sys_logger_t *this)
{
- closelog();
+ this->lock->destroy(this->lock);
this->mutex->destroy(this->mutex);
free(this);
}
/*
* Described in header.
*/
-sys_logger_t *sys_logger_create(int facility, bool ike_name)
+sys_logger_t *sys_logger_create(int facility)
{
private_sys_logger_t *this;
.get_level = _get_level,
},
.set_level = _set_level,
+ .set_options = _set_options,
.destroy = _destroy,
},
.facility = facility,
- .ike_name = ike_name,
.mutex = mutex_create(MUTEX_TYPE_DEFAULT),
+ .lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
);
set_level(this, DBG_ANY, LEVEL_SILENT);
/*
+ * Copyright (C) 2012 Tobias Brunner
* Copyright (C) 2006 Martin Willi
* Hochschule fuer Technik Rapperswil
*
void (*set_level) (sys_logger_t *this, debug_t group, level_t level);
/**
+ * Set options used by this logger.
+ *
+ * @param ike_name TRUE to prefix the name of the IKE_SA
+ */
+ void (*set_options) (sys_logger_t *this, bool ike_name);
+
+ /**
* Destroys a sys_logger_t object.
*/
void (*destroy) (sys_logger_t *this);
* Constructor to create a sys_logger_t object.
*
* @param facility syslog facility to use
- * @param ike_name TRUE to prefix the name of the IKE_SA
* @return sys_logger_t object
*/
-sys_logger_t *sys_logger_create(int facility, bool ike_name);
+sys_logger_t *sys_logger_create(int facility);
#endif /** SYS_LOGGER_H_ @}*/
projects / strongswan.git / commitdiff