bird/sysdep/unix/log.c
Jan Moskyto Matejka 7152e5efbb Build system reworked to one global Makefile with includes and no nesting
Also removed the lib-dir merging with sysdep. Updated #include's
accordingly.

Fixed make doc on recent Debian together with moving generated doc into
objdir.

Moved Makefile.in into root dir

Retired all.o and birdlib.a
Linking the final binaries directly from all the .o files.
2016-05-10 14:07:34 +02:00

329 lines
6.8 KiB
C

/*
* BIRD Library -- Logging Functions
*
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Logging
*
* The Logging module offers a simple set of functions for writing
* messages to system logs and to the debug output. Message classes
* used by this module are described in |birdlib.h| and also in the
* user's manual.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>
#include <unistd.h>
#include "nest/bird.h"
#include "nest/cli.h"
#include "nest/mrtdump.h"
#include "lib/string.h"
#include "lib/lists.h"
#include "sysdep/unix/unix.h"
static FILE *dbgf;
static list *current_log_list;
static char *current_syslog_name; /* NULL -> syslog closed */
#ifdef USE_PTHREADS
#include <pthread.h>
static pthread_mutex_t log_mutex;
static inline void log_lock(void) { pthread_mutex_lock(&log_mutex); }
static inline void log_unlock(void) { pthread_mutex_unlock(&log_mutex); }
static pthread_t main_thread;
void main_thread_init(void) { main_thread = pthread_self(); }
static int main_thread_self(void) { return pthread_equal(pthread_self(), main_thread); }
#else
static inline void log_lock(void) { }
static inline void log_unlock(void) { }
void main_thread_init(void) { }
static int main_thread_self(void) { return 1; }
#endif
#ifdef HAVE_SYSLOG
#include <sys/syslog.h>
static int syslog_priorities[] = {
LOG_DEBUG,
LOG_DEBUG,
LOG_DEBUG,
LOG_INFO,
LOG_ERR,
LOG_WARNING,
LOG_ERR,
LOG_ERR,
LOG_CRIT,
LOG_CRIT
};
#endif
static char *class_names[] = {
"???",
"DBG",
"TRACE",
"INFO",
"RMT",
"WARN",
"ERR",
"AUTH",
"FATAL",
"BUG"
};
/**
* log_commit - commit a log message
* @class: message class information (%L_DEBUG to %L_BUG, see |lib/birdlib.h|)
*
* This function writes a message prepared in the log buffer to the
* log file (as specified in the configuration). The log buffer is
* reset after that. The log message is a full line, log_commit()
* terminates it.
*
* The message class is an integer, not a first char of a string like
* in log(), so it should be written like *L_INFO.
*/
void
log_commit(int class, buffer *buf)
{
struct log_config *l;
if (buf->pos == buf->end)
strcpy(buf->end - 100, " ... <too long>");
log_lock();
WALK_LIST(l, *current_log_list)
{
if (!(l->mask & (1 << class)))
continue;
if (l->fh)
{
if (l->terminal_flag)
fputs("bird: ", l->fh);
else
{
byte tbuf[TM_DATETIME_BUFFER_SIZE];
tm_format_datetime(tbuf, &config->tf_log, now);
fprintf(l->fh, "%s <%s> ", tbuf, class_names[class]);
}
fputs(buf->start, l->fh);
fputc('\n', l->fh);
fflush(l->fh);
}
#ifdef HAVE_SYSLOG
else
syslog(syslog_priorities[class], "%s", buf->start);
#endif
}
log_unlock();
/* cli_echo is not thread-safe, so call it just from the main thread */
if (main_thread_self())
cli_echo(class, buf->start);
buf->pos = buf->start;
}
int buffer_vprint(buffer *buf, const char *fmt, va_list args);
static void
vlog(int class, const char *msg, va_list args)
{
buffer buf;
LOG_BUFFER_INIT(buf);
buffer_vprint(&buf, msg, args);
log_commit(class, &buf);
}
/**
* log - log a message
* @msg: printf-like formatting string with message class information
* prepended (%L_DEBUG to %L_BUG, see |lib/birdlib.h|)
*
* This function formats a message according to the format string @msg
* and writes it to the corresponding log file (as specified in the
* configuration). Please note that the message is automatically
* formatted as a full line, no need to include |\n| inside.
* It is essentially a sequence of log_reset(), logn() and log_commit().
*/
void
log_msg(const char *msg, ...)
{
int class = 1;
va_list args;
va_start(args, msg);
if (*msg >= 1 && *msg <= 8)
class = *msg++;
vlog(class, msg, args);
va_end(args);
}
void
log_rl(struct tbf *f, const char *msg, ...)
{
int last_hit = f->mark;
int class = 1;
va_list args;
/* Rate limiting is a bit tricky here as it also logs '...' during the first hit */
if (tbf_limit(f) && last_hit)
return;
if (*msg >= 1 && *msg <= 8)
class = *msg++;
va_start(args, msg);
vlog(class, (f->mark ? "..." : msg), args);
va_end(args);
}
/**
* bug - report an internal error
* @msg: a printf-like error message
*
* This function logs an internal error and aborts execution
* of the program.
*/
void
bug(const char *msg, ...)
{
va_list args;
va_start(args, msg);
vlog(L_BUG[0], msg, args);
abort();
}
/**
* bug - report a fatal error
* @msg: a printf-like error message
*
* This function logs a fatal error and aborts execution
* of the program.
*/
void
die(const char *msg, ...)
{
va_list args;
va_start(args, msg);
vlog(L_FATAL[0], msg, args);
exit(1);
}
/**
* debug - write to debug output
* @msg: a printf-like message
*
* This function formats the message @msg and prints it out
* to the debugging output. No newline character is appended.
*/
void
debug(const char *msg, ...)
{
va_list args;
char buf[1024];
va_start(args, msg);
if (dbgf)
{
if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
bsprintf(buf + sizeof(buf) - 100, " ... <too long>\n");
fputs(buf, dbgf);
}
va_end(args);
}
static list *
default_log_list(int debug, int init, char **syslog_name)
{
static list init_log_list;
init_list(&init_log_list);
*syslog_name = NULL;
#ifdef HAVE_SYSLOG
if (!debug)
{
static struct log_config lc_syslog = { .mask = ~0 };
add_tail(&init_log_list, &lc_syslog.n);
*syslog_name = bird_name;
if (!init)
return &init_log_list;
}
#endif
static struct log_config lc_stderr = { .mask = ~0, .terminal_flag = 1 };
lc_stderr.fh = stderr;
add_tail(&init_log_list, &lc_stderr.n);
return &init_log_list;
}
void
log_switch(int debug, list *l, char *new_syslog_name)
{
if (!l || EMPTY_LIST(*l))
l = default_log_list(debug, !l, &new_syslog_name);
current_log_list = l;
#ifdef HAVE_SYSLOG
if (current_syslog_name && new_syslog_name &&
!strcmp(current_syslog_name, new_syslog_name))
return;
if (current_syslog_name)
closelog();
if (new_syslog_name)
openlog(new_syslog_name, LOG_CONS | LOG_NDELAY, LOG_DAEMON);
current_syslog_name = new_syslog_name;
#endif
}
void
log_init_debug(char *f)
{
if (dbgf && dbgf != stderr)
fclose(dbgf);
if (!f)
dbgf = NULL;
else if (!*f)
dbgf = stderr;
else if (!(dbgf = fopen(f, "a")))
log(L_ERR "Error opening debug file `%s': %m", f);
if (dbgf)
setvbuf(dbgf, NULL, _IONBF, 0);
}
void
mrt_dump_message(struct proto *p, u16 type, u16 subtype, byte *buf, u32 len)
{
/* Prepare header */
put_u32(buf+0, now_real);
put_u16(buf+4, type);
put_u16(buf+6, subtype);
put_u32(buf+8, len - MRTDUMP_HDR_LENGTH);
if (p->cf->global->mrtdump_file != -1)
write(p->cf->global->mrtdump_file, buf, len);
}