Asterisk Logger. More...

#include "asterisk.h"
#include <syslog.h>
#include "asterisk/_private.h"
#include "asterisk/paths.h"
#include "asterisk/logger.h"
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/term.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/manager.h"
#include "asterisk/threadstorage.h"
#include "asterisk/strings.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include <signal.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <execinfo.h>

Include dependency graph for logger.c:

Go to the source code of this file.

Data Structures
struct	logchannel
struct	logchannels
struct	logmsg
struct	logmsgs
struct	verb
struct	verbosers
Defines
#define	FORMATL "%-35.35s %-8.8s %-9.9s "
#define	GETTID() getpid()
#define	LOG_BUF_INIT_SIZE 256
#define	MAX_BACKTRACE_FRAMES 20
#define	VERBOSE_BUF_INIT_SIZE 256
Enumerations
enum	logmsgtypes { LOGMSG_NORMAL = 0, LOGMSG_VERBOSE }
enum	logtypes { LOGTYPE_SYSLOG, LOGTYPE_FILE, LOGTYPE_CONSOLE }
enum	rotatestrategy { SEQUENTIAL = 1 << 0, ROTATE = 1 << 1, TIMESTAMP = 1 << 2 }
Functions
void	__ast_verbose (const char file, int line, const char func, const char *fmt,...)
	This works like ast_log, but prints verbose messages to the console depending on verbosity level set. ast_verbose(VERBOSE_PREFIX_3 "Whatever %s is happening\n", "nothing"); This will print the message to the console if the verbose level is set to a level >= 3 Note the abscence of a comma after the VERBOSE_PREFIX_3. This is important. VERBOSE_PREFIX_1 through VERBOSE_PREFIX_3 are defined.
void	__ast_verbose_ap (const char file, int line, const char func, const char *fmt, va_list ap)
static void	__init_log_buf (void)
static void	__init_verbose_buf (void)
static void	_handle_SIGXFSZ (int sig)
void	ast_backtrace (void)
struct ast_bt *	ast_bt_create (void)
void *	ast_bt_destroy (struct ast_bt *bt)
int	ast_bt_get_addresses (struct ast_bt *bt)
char **	ast_bt_get_symbols (void **addresses, size_t num_frames)
void	ast_child_verbose (int level, const char *fmt,...)
void	ast_log (int level, const char file, int line, const char function, const char *fmt,...)
	send log messages to syslog and/or the console
static void	ast_log_vsyslog (struct logmsg *msg)
int	ast_logger_register_level (const char *name)
	Register a new logger level.
void	ast_logger_unregister_level (const char *name)
	Unregister a previously registered logger level.
void	ast_queue_log (const char queuename, const char callid, const char agent, const char event, const char *fmt,...)
int	ast_register_verbose (void(v)(const char string))
int	ast_unregister_verbose (void(v)(const char string))
void	ast_verbose (const char *fmt,...)
void	close_logger (void)
static char *	handle_logger_reload (struct ast_cli_entry e, int cmd, struct ast_cli_args a)
static char *	handle_logger_rotate (struct ast_cli_entry e, int cmd, struct ast_cli_args a)
static char *	handle_logger_set_level (struct ast_cli_entry e, int cmd, struct ast_cli_args a)
static char *	handle_logger_show_channels (struct ast_cli_entry e, int cmd, struct ast_cli_args a)
	CLI command to show logging system configuration.
int	init_logger (void)
static void	init_logger_chain (int locked)
static void	logger_print_normal (struct logmsg *logmsg)
	Print a normal log message to the channels.
static void	logger_queue_init (void)
static int	logger_queue_restart (int queue_rotate)
static int	logger_queue_rt_start (void)
int	logger_reload (void)
	Reload the logger module without rotating log files (also used from loader.c during a full Asterisk reload)
static void *	logger_thread (void *data)
	Actual logging thread.
static unsigned int	make_components (const char *s, int lineno)
static struct logchannel *	make_logchannel (const char channel, const char components, int lineno)
static int	reload_logger (int rotate)
static int	rotate_file (const char *filename)
static void	update_logchannels (void)
Variables
static struct ast_cli_entry	cli_logger []
static int	close_logger_thread = 0
static const int	colors [32]
	Colors used in the console for logging.
static char	dateformat [256] = "%b %e %T"
static char	exec_after_rotate [256] = ""
static int	filesize_reload_needed
static unsigned int	global_logmask = 0xFFFF
static struct sigaction	handle_SIGXFSZ
static char	hostname [MAXHOSTNAMELEN]
static char *	levels [32]
	Logging channels used in the Asterisk logging system.
static struct ast_threadstorage	log_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_log_buf , .custom_init = NULL , }
static struct logchannels	logchannels
static ast_cond_t	logcond
struct {
unsigned int queue_adaptive_realtime:1
unsigned int queue_log:1
unsigned int queue_log_to_file:1
}	logfiles
static int	logger_initialized
static struct logmsgs	logmsgs
static pthread_t	logthread = AST_PTHREADT_NULL
static FILE *	qlog
static char	queue_log_name [256] = QUEUELOG
static int	queuelog_init
static enum rotatestrategy	rotatestrategy
static struct ast_threadstorage	verbose_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_verbose_buf , .custom_init = NULL , }
static struct verbosers	verbosers

Detailed Description

Asterisk Logger.

Logging routines

Author:: Mark Spencer <markster@digium.com>

Definition in file logger.c.

Define Documentation

#define FORMATL "%-35.35s %-8.8s %-9.9s "

Referenced by handle_logger_show_channels().

#define GETTID ( ) getpid()

Definition at line 72 of file logger.c.

Referenced by ast_log().

#define LOG_BUF_INIT_SIZE 256

Definition at line 215 of file logger.c.

Referenced by ast_log().

#define MAX_BACKTRACE_FRAMES 20

Definition at line 58 of file logger.c.

#define VERBOSE_BUF_INIT_SIZE 256

Definition at line 212 of file logger.c.

Referenced by __ast_verbose_ap().

Enumeration Type Documentation

enum logmsgtypes

Enumerator:

LOGMSG_NORMAL
LOGMSG_VERBOSE

Definition at line 127 of file logger.c.

                 {
   LOGMSG_NORMAL = 0,
   LOGMSG_VERBOSE,
};

enum logtypes

Enumerator:

LOGTYPE_SYSLOG
LOGTYPE_FILE
LOGTYPE_CONSOLE

Definition at line 98 of file logger.c.

              {
   LOGTYPE_SYSLOG,
   LOGTYPE_FILE,
   LOGTYPE_CONSOLE,
};

enum rotatestrategy

Enumerator:

SEQUENTIAL
ROTATE
TIMESTAMP

Definition at line 84 of file logger.c.

                           {
   SEQUENTIAL = 1 << 0,     /* Original method - create a new file, in order */
   ROTATE = 1 << 1,         /* Rotate all files, such that the oldest file has the highest suffix */
   TIMESTAMP = 1 << 2,      /* Append the epoch timestamp onto the end of the archived file */
} rotatestrategy = SEQUENTIAL;

Function Documentation

void __ast_verbose	(	const char *	file,
		int	line,
		const char *	func,
		const char *	fmt,
			...
	)

This works like ast_log, but prints verbose messages to the console depending on verbosity level set. ast_verbose(VERBOSE_PREFIX_3 "Whatever %s is happening\n", "nothing"); This will print the message to the console if the verbose level is set to a level >= 3 Note the abscence of a comma after the VERBOSE_PREFIX_3. This is important. VERBOSE_PREFIX_1 through VERBOSE_PREFIX_3 are defined.

Send a verbose message (based on verbose level)

Definition at line 1523 of file logger.c.

References __ast_verbose_ap().

{
   va_list ap;

   va_start(ap, fmt);
   __ast_verbose_ap(file, line, func, fmt, ap);
   va_end(ap);
}

void __ast_verbose_ap	(	const char *	file,
		int	line,
		const char *	func,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1487 of file logger.c.

References ast_str_thread_get(), verbose_buf, VERBOSE_BUF_INIT_SIZE, ast_opt_timestamp, ast_tvnow(), ast_localtime(), ast_strftime(), ast_str_set_va(), AST_DYNSTR_BUILD_FAILED, ast_log(), __LOG_VERBOSE, and ast_str_buffer().

Referenced by __ast_verbose(), and ast_verbose().

{
   struct ast_str *buf = NULL;
   int res = 0;

   if (!(buf = ast_str_thread_get(&verbose_buf, VERBOSE_BUF_INIT_SIZE)))
      return;

   if (ast_opt_timestamp) {
      struct timeval now;
      struct ast_tm tm;
      char date[40];
      char *datefmt;

      now = ast_tvnow();
      ast_localtime(&now, &tm, NULL);
      ast_strftime(date, sizeof(date), dateformat, &tm);
      datefmt = alloca(strlen(date) + 3 + strlen(fmt) + 1);
      sprintf(datefmt, "%c[%s] %s", 127, date, fmt);
      fmt = datefmt;
   } else {
      char *tmp = alloca(strlen(fmt) + 2);
      sprintf(tmp, "%c%s", 127, fmt);
      fmt = tmp;
   }

   /* Build string */
   res = ast_str_set_va(&buf, 0, fmt, ap);

   /* If the build failed then we can drop this allocated message */
   if (res == AST_DYNSTR_BUILD_FAILED)
      return;

   ast_log(__LOG_VERBOSE, file, line, func, "%s", ast_str_buffer(buf));
}

static void __init_log_buf ( void ) [static]

Definition at line 214 of file logger.c.

static void __init_verbose_buf ( void ) [static]

Definition at line 211 of file logger.c.

static void _handle_SIGXFSZ ( int sig ) [static]

Definition at line 934 of file logger.c.

{
   /* Indicate need to reload */
   filesize_reload_needed = 1;
}

void ast_backtrace ( void )

Definition at line 1457 of file logger.c.

References ast_bt_create(), ast_log(), LOG_WARNING, ast_bt_get_symbols(), ast_bt::addresses, ast_bt::num_frames, ast_debug, LOG_DEBUG, free, and ast_bt_destroy().

{
#ifdef HAVE_BKTR
   struct ast_bt *bt;
   int i = 0;
   char **strings;

   if (!(bt = ast_bt_create())) {
      ast_log(LOG_WARNING, "Unable to allocate space for backtrace structure\n");
      return;
   }

   if ((strings = ast_bt_get_symbols(bt->addresses, bt->num_frames))) {
      ast_debug(1, "Got %d backtrace record%c\n", bt->num_frames, bt->num_frames != 1 ? 's' : ' ');
      for (i = 3; i < bt->num_frames - 2; i++) {
         ast_log(LOG_DEBUG, "#%d: [%p] %s\n", i - 3, bt->addresses[i], strings[i]);
      }

      /* MALLOC_DEBUG will erroneously report an error here, unless we undef the macro. */
#undef free
      free(strings);
   } else {
      ast_debug(1, "Could not allocate memory for backtrace\n");
   }
   ast_bt_destroy(bt);
#else
   ast_log(LOG_WARNING, "Must run configure with '--with-execinfo' for stack backtraces.\n");
#endif /* defined(HAVE_BKTR) */
}

struct ast_bt* ast_bt_create ( void ) [read]

Definition at line 1280 of file logger.c.

References ast_calloc, ast_log(), LOG_ERROR, ast_bt::alloced, and ast_bt_get_addresses().

Referenced by ast_backtrace().

{
   struct ast_bt *bt = ast_calloc(1, sizeof(*bt));
   if (!bt) {
      ast_log(LOG_ERROR, "Unable to allocate memory for backtrace structure!\n");
      return NULL;
   }

   bt->alloced = 1;

   ast_bt_get_addresses(bt);

   return bt;
}

void* ast_bt_destroy ( struct ast_bt * bt )

Definition at line 1302 of file logger.c.

References ast_bt::alloced, and ast_free.

Referenced by ast_backtrace().

{
   if (bt->alloced) {
      ast_free(bt);
   }

   return NULL;
}

int ast_bt_get_addresses ( struct ast_bt * bt )

Definition at line 1295 of file logger.c.

References ast_bt::num_frames, ast_bt::addresses, and AST_MAX_BT_FRAMES.

Referenced by __ast_pthread_mutex_lock(), __ast_pthread_mutex_trylock(), __ast_cond_wait(), __ast_cond_timedwait(), __ast_rwlock_rdlock(), __ast_rwlock_wrlock(), __ast_rwlock_timedrdlock(), __ast_rwlock_timedwrlock(), __ast_rwlock_tryrdlock(), __ast_rwlock_trywrlock(), and ast_bt_create().

{
   bt->num_frames = backtrace(bt->addresses, AST_MAX_BT_FRAMES);

   return 0;
}

char** ast_bt_get_symbols	(	void **	addresses,
		size_t	num_frames
	)

Definition at line 1311 of file logger.c.

References ast_calloc, ast_bt::num_frames, ast_utils_which(), ast_log(), LOG_DEBUG, ast_malloc, S_OR, ast_free, ast_strlen_zero(), ast_realloc, and ast_copy_string().

Referenced by ao2_bt(), and ast_backtrace().

{
   char **strings = NULL;
#if defined(BETTER_BACKTRACES)
   int stackfr;
   bfd *bfdobj;           /* bfd.h */
   Dl_info dli;           /* dlfcn.h */
   long allocsize;
   asymbol **syms = NULL; /* bfd.h */
   bfd_vma offset;        /* bfd.h */
   const char *lastslash;
   asection *section;
   const char *file, *func;
   unsigned int line;
   char address_str[128];
   char msg[1024];
   size_t strings_size;
   size_t *eachlen;
#endif

#if defined(BETTER_BACKTRACES)
   strings_size = num_frames * sizeof(*strings);
   eachlen = ast_calloc(num_frames, sizeof(*eachlen));

   if (!(strings = ast_calloc(num_frames, sizeof(*strings)))) {
      return NULL;
   }

   for (stackfr = 0; stackfr < num_frames; stackfr++) {
      int found = 0, symbolcount;

      msg[0] = '\0';

      if (!dladdr(addresses[stackfr], &dli)) {
         continue;
      }

      if (strcmp(dli.dli_fname, "asterisk") == 0) {
         char asteriskpath[256];
         if (!(dli.dli_fname = ast_utils_which("asterisk", asteriskpath, sizeof(asteriskpath)))) {
            /* This will fail to find symbols */
            ast_log(LOG_DEBUG, "Failed to find asterisk binary for debug symbols.\n");
            dli.dli_fname = "asterisk";
         }
      }

      lastslash = strrchr(dli.dli_fname, '/');
      if (  (bfdobj = bfd_openr(dli.dli_fname, NULL)) &&
            bfd_check_format(bfdobj, bfd_object) &&
            (allocsize = bfd_get_symtab_upper_bound(bfdobj)) > 0 &&
            (syms = ast_malloc(allocsize)) &&
            (symbolcount = bfd_canonicalize_symtab(bfdobj, syms))) {

         if (bfdobj->flags & DYNAMIC) {
            offset = addresses[stackfr] - dli.dli_fbase;
         } else {
            offset = addresses[stackfr] - (void *) 0;
         }

         for (section = bfdobj->sections; section; section = section->next) {
            if (  !bfd_get_section_flags(bfdobj, section) & SEC_ALLOC ||
                  section->vma > offset ||
                  section->size + section->vma < offset) {
               continue;
            }

            if (!bfd_find_nearest_line(bfdobj, section, syms, offset - section->vma, &file, &func, &line)) {
               continue;
            }

            /* Stack trace output */
            found++;
            if ((lastslash = strrchr(file, '/'))) {
               const char *prevslash;
               for (prevslash = lastslash - 1; *prevslash != '/' && prevslash >= file; prevslash--);
               if (prevslash >= file) {
                  lastslash = prevslash;
               }
            }
            if (dli.dli_saddr == NULL) {
               address_str[0] = '\0';
            } else {
               snprintf(address_str, sizeof(address_str), " (%p+%lX)",
                  dli.dli_saddr,
                  (unsigned long) (addresses[stackfr] - dli.dli_saddr));
            }
            snprintf(msg, sizeof(msg), "%s:%u %s()%s",
               lastslash ? lastslash + 1 : file, line,
               S_OR(func, "???"),
               address_str);

            break; /* out of section iteration */
         }
      }
      if (bfdobj) {
         bfd_close(bfdobj);
         if (syms) {
            ast_free(syms);
         }
      }

      /* Default output, if we cannot find the information within BFD */
      if (!found) {
         if (dli.dli_saddr == NULL) {
            address_str[0] = '\0';
         } else {
            snprintf(address_str, sizeof(address_str), " (%p+%lX)",
               dli.dli_saddr,
               (unsigned long) (addresses[stackfr] - dli.dli_saddr));
         }
         snprintf(msg, sizeof(msg), "%s %s()%s",
            lastslash ? lastslash + 1 : dli.dli_fname,
            S_OR(dli.dli_sname, "<unknown>"),
            address_str);
      }

      if (!ast_strlen_zero(msg)) {
         char **tmp;
         eachlen[stackfr] = strlen(msg);
         if (!(tmp = ast_realloc(strings, strings_size + eachlen[stackfr] + 1))) {
            ast_free(strings);
            strings = NULL;
            break; /* out of stack frame iteration */
         }
         strings = tmp;
         strings[stackfr] = (char *) strings + strings_size;
         ast_copy_string(strings[stackfr], msg, eachlen[stackfr] + 1);
         strings_size += eachlen[stackfr] + 1;
      }
   }

   if (strings) {
      /* Recalculate the offset pointers */
      strings[0] = (char *) strings + num_frames * sizeof(*strings);
      for (stackfr = 1; stackfr < num_frames; stackfr++) {
         strings[stackfr] = strings[stackfr - 1] + eachlen[stackfr - 1] + 1;
      }
   }
#else /* !defined(BETTER_BACKTRACES) */
   strings = backtrace_symbols(addresses, num_frames);
#endif /* defined(BETTER_BACKTRACES) */
   return strings;
}

void ast_child_verbose	(	int	level,
		const char *	fmt,
			...
	)

Definition at line 426 of file logger.c.

References option_verbose, ast_malloc, and ast_free.

Referenced by launch_script().

{
   char *msg = NULL, *emsg = NULL, *sptr, *eptr;
   va_list ap, aq;
   int size;

   /* Don't bother, if the level isn't that high */
   if (option_verbose < level) {
      return;
   }

   va_start(ap, fmt);
   va_copy(aq, ap);
   if ((size = vsnprintf(msg, 0, fmt, ap)) < 0) {
      va_end(ap);
      va_end(aq);
      return;
   }
   va_end(ap);

   if (!(msg = ast_malloc(size + 1))) {
      va_end(aq);
      return;
   }

   vsnprintf(msg, size + 1, fmt, aq);
   va_end(aq);

   if (!(emsg = ast_malloc(size * 2 + 1))) {
      ast_free(msg);
      return;
   }

   for (sptr = msg, eptr = emsg; ; sptr++) {
      if (*sptr == '"') {
         *eptr++ = '\\';
      }
      *eptr++ = *sptr;
      if (*sptr == '\0') {
         break;
      }
   }
   ast_free(msg);

   fprintf(stdout, "verbose \"%s\" %d\n", emsg, level);
   fflush(stdout);
   ast_free(emsg);
}

void ast_log	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		const char *	fmt,
			...
	)

send log messages to syslog and/or the console

Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments.

Definition at line 1186 of file logger.c.

References ast_tvnow(), ast_str_thread_get(), log_buf, LOG_BUF_INIT_SIZE, __LOG_VERBOSE, AST_RWLIST_EMPTY, ast_str_set_va(), AST_DYNSTR_BUILD_FAILED, term_filter_escapes(), ast_str_buffer(), option_verbose, option_debug, __LOG_DEBUG, ast_calloc_with_stringfields, ast_string_field_set, logmsg::type, LOGMSG_VERBOSE, LOGMSG_NORMAL, ast_localtime(), ast_strftime(), logmsg::level, logmsg::line, levels, logmsg::process_id, GETTID, logthread, AST_PTHREADT_NULL, AST_LIST_LOCK, AST_LIST_INSERT_TAIL, logchannel::list, ast_cond_signal, logcond, AST_LIST_UNLOCK, logger_print_normal(), and ast_free.

{
   struct logmsg *logmsg = NULL;
   struct ast_str *buf = NULL;
   struct ast_tm tm;
   struct timeval now = ast_tvnow();
   int res = 0;
   va_list ap;
   char datestring[256];

   if (!(buf = ast_str_thread_get(&log_buf, LOG_BUF_INIT_SIZE)))
      return;

   if (level != __LOG_VERBOSE && AST_RWLIST_EMPTY(&logchannels)) {
      /*
       * we don't have the logger chain configured yet,
       * so just log to stdout
       */
      int result;
      va_start(ap, fmt);
      result = ast_str_set_va(&buf, BUFSIZ, fmt, ap); /* XXX BUFSIZ ? */
      va_end(ap);
      if (result != AST_DYNSTR_BUILD_FAILED) {
         term_filter_escapes(ast_str_buffer(buf));
         fputs(ast_str_buffer(buf), stdout);
      }
      return;
   }
   
   /* don't display LOG_DEBUG messages unless option_verbose _or_ option_debug
      are non-zero; LOG_DEBUG messages can still be displayed if option_debug
      is zero, if option_verbose is non-zero (this allows for 'level zero'
      LOG_DEBUG messages to be displayed, if the logmask on any channel
      allows it)
   */
   if (!option_verbose && !option_debug && (level == __LOG_DEBUG))
      return;

   /* Ignore anything that never gets logged anywhere */
   if (level != __LOG_VERBOSE && !(global_logmask & (1 << level)))
      return;
   
   /* Build string */
   va_start(ap, fmt);
   res = ast_str_set_va(&buf, BUFSIZ, fmt, ap);
   va_end(ap);

   /* If the build failed, then abort and free this structure */
   if (res == AST_DYNSTR_BUILD_FAILED)
      return;

   /* Create a new logging message */
   if (!(logmsg = ast_calloc_with_stringfields(1, struct logmsg, res + 128)))
      return;

   /* Copy string over */
   ast_string_field_set(logmsg, message, ast_str_buffer(buf));

   /* Set type */
   if (level == __LOG_VERBOSE) {
      logmsg->type = LOGMSG_VERBOSE;
   } else {
      logmsg->type = LOGMSG_NORMAL;
   }

   /* Create our date/time */
   ast_localtime(&now, &tm, NULL);
   ast_strftime(datestring, sizeof(datestring), dateformat, &tm);
   ast_string_field_set(logmsg, date, datestring);

   /* Copy over data */
   logmsg->level = level;
   logmsg->line = line;
   ast_string_field_set(logmsg, level_name, levels[level]);
   ast_string_field_set(logmsg, file, file);
   ast_string_field_set(logmsg, function, function);
   logmsg->process_id = (long) GETTID();

   /* If the logger thread is active, append it to the tail end of the list - otherwise skip that step */
   if (logthread != AST_PTHREADT_NULL) {
      AST_LIST_LOCK(&logmsgs);
      AST_LIST_INSERT_TAIL(&logmsgs, logmsg, list);
      ast_cond_signal(&logcond);
      AST_LIST_UNLOCK(&logmsgs);
   } else {
      logger_print_normal(logmsg);
      ast_free(logmsg);
   }

   return;
}

static void ast_log_vsyslog ( struct logmsg * msg ) [static]

Definition at line 945 of file logger.c.

References ast_syslog_priority_from_loglevel(), logmsg::level, levels, logmsg::process_id, logmsg::file, logmsg::line, logmsg::function, logmsg::message, and term_strip().

Referenced by logger_print_normal().

{
   char buf[BUFSIZ];
   int syslog_level = ast_syslog_priority_from_loglevel(msg->level);

   if (syslog_level < 0) {
      /* we are locked here, so cannot ast_log() */
      fprintf(stderr, "ast_log_vsyslog called with bogus level: %d\n", msg->level);
      return;
   }

   snprintf(buf, sizeof(buf), "%s[%ld]: %s:%d in %s: %s",
       levels[msg->level], msg->process_id, msg->file, msg->line, msg->function, msg->message);

   term_strip(buf, buf, strlen(buf) + 1);
   syslog(syslog_level, "%s", buf);
}

int ast_logger_register_level ( const char * name )

Register a new logger level.

Parameters:

name	The name of the level to be registered

Return values:

-1	if an error occurs
non-zero	level to be used with ast_log for sending messages to this level

Since:: 1.8

Definition at line 1594 of file logger.c.

References available(), AST_RWLIST_WRLOCK, ARRAY_LEN, levels, ast_log(), LOG_WARNING, AST_RWLIST_UNLOCK, ast_strdup, ast_debug, and update_logchannels().

Referenced by ast_cc_init(), and load_module().

{
   unsigned int level;
   unsigned int available = 0;

   AST_RWLIST_WRLOCK(&logchannels);

   for (level = 0; level < ARRAY_LEN(levels); level++) {
      if ((level >= 16) && !available && !levels[level]) {
         available = level;
         continue;
      }

      if (levels[level] && !strcasecmp(levels[level], name)) {
         ast_log(LOG_WARNING,
            "Unable to register dynamic logger level '%s': a standard logger level uses that name.\n",
            name);
         AST_RWLIST_UNLOCK(&logchannels);

         return -1;
      }
   }

   if (!available) {
      ast_log(LOG_WARNING,
         "Unable to register dynamic logger level '%s'; maximum number of levels registered.\n",
         name);
      AST_RWLIST_UNLOCK(&logchannels);

      return -1;
   }

   levels[available] = ast_strdup(name);

   AST_RWLIST_UNLOCK(&logchannels);

   ast_debug(1, "Registered dynamic logger level '%s' with index %d.\n", name, available);

   update_logchannels();

   return available;
}

void ast_logger_unregister_level ( const char * name )

Unregister a previously registered logger level.

Parameters:

name	The name of the level to be unregistered

Returns:: nothing

Since:: 1.8

Definition at line 1637 of file logger.c.

References AST_RWLIST_WRLOCK, ARRAY_LEN, levels, free, AST_RWLIST_UNLOCK, ast_debug, and update_logchannels().

Referenced by unload_module(), and load_module().

{
   unsigned int found = 0;
   unsigned int x;

   AST_RWLIST_WRLOCK(&logchannels);

   for (x = 16; x < ARRAY_LEN(levels); x++) {
      if (!levels[x]) {
         continue;
      }

      if (strcasecmp(levels[x], name)) {
         continue;
      }

      found = 1;
      break;
   }

   if (found) {
      /* take this level out of the global_logmask, to ensure that no new log messages
       * will be queued for it
       */

      global_logmask &= ~(1 << x);

      free(levels[x]);
      levels[x] = NULL;
      AST_RWLIST_UNLOCK(&logchannels);

      ast_debug(1, "Unregistered dynamic logger level '%s' with index %d.\n", name, x);

      update_logchannels();
   } else {
      AST_RWLIST_UNLOCK(&logchannels);
   }
}

void ast_queue_log	(	const char *	queuename,
		const char *	callid,
		const char *	agent,
		const char *	event,
		const char *	fmt,
			...
	)

Definition at line 475 of file logger.c.

References AST_RWLIST_WRLOCK, logger_queue_init(), AST_RWLIST_UNLOCK, ast_queue_log(), ast_check_realtime(), ast_tvnow(), ast_localtime(), ast_strftime(), logfiles, AST_DECLARE_APP_ARGS, args, AST_APP_ARG, AST_NONSTANDARD_APP_ARGS, ast_realtime_require_field(), RQ_CHAR, S_OR, SENTINEL, ast_store_realtime(), qlog, and AST_RWLIST_RDLOCK.

Referenced by rt_handle_member_record(), find_queue_by_name_rt(), update_realtime_members(), rna(), wait_our_turn(), queue_transfer_fixup(), try_calling(), set_member_paused(), set_member_penalty(), rqm_exec(), aqm_exec(), ql_exec(), queue_exec(), manager_add_queue_member(), manager_remove_queue_member(), manager_queue_log_custom(), handle_queue_add_member(), handle_queue_remove_member(), login_exec(), ast_queue_log(), and reload_logger().

{
   va_list ap;
   struct timeval tv;
   struct ast_tm tm;
   char qlog_msg[8192];
   int qlog_len;
   char time_str[30];

   if (!logger_initialized) {
      /* You are too early.  We are not open yet! */
      return;
   }
   if (!queuelog_init) {
      AST_RWLIST_WRLOCK(&logchannels);
      if (!queuelog_init) {
         /*
          * We have delayed initializing the queue logging system so
          * preloaded realtime modules can get up.  We must initialize
          * now since someone is trying to log something.
          */
         logger_queue_init();
         queuelog_init = 1;
         AST_RWLIST_UNLOCK(&logchannels);
         ast_queue_log("NONE", "NONE", "NONE", "QUEUESTART", "%s", "");
      } else {
         AST_RWLIST_UNLOCK(&logchannels);
      }
   }

   if (ast_check_realtime("queue_log")) {
      tv = ast_tvnow();
      ast_localtime(&tv, &tm, NULL);
      ast_strftime(time_str, sizeof(time_str), "%F %T.%6q", &tm);
      va_start(ap, fmt);
      vsnprintf(qlog_msg, sizeof(qlog_msg), fmt, ap);
      va_end(ap);
      if (logfiles.queue_adaptive_realtime) {
         AST_DECLARE_APP_ARGS(args,
            AST_APP_ARG(data)[5];
         );
         AST_NONSTANDARD_APP_ARGS(args, qlog_msg, '|');
         /* Ensure fields are large enough to receive data */
         ast_realtime_require_field("queue_log",
            "data1", RQ_CHAR, strlen(S_OR(args.data[0], "")),
            "data2", RQ_CHAR, strlen(S_OR(args.data[1], "")),
            "data3", RQ_CHAR, strlen(S_OR(args.data[2], "")),
            "data4", RQ_CHAR, strlen(S_OR(args.data[3], "")),
            "data5", RQ_CHAR, strlen(S_OR(args.data[4], "")),
            SENTINEL);

         /* Store the log */
         ast_store_realtime("queue_log", "time", time_str,
            "callid", callid,
            "queuename", queuename,
            "agent", agent,
            "event", event,
            "data1", S_OR(args.data[0], ""),
            "data2", S_OR(args.data[1], ""),
            "data3", S_OR(args.data[2], ""),
            "data4", S_OR(args.data[3], ""),
            "data5", S_OR(args.data[4], ""),
            SENTINEL);
      } else {
         ast_store_realtime("queue_log", "time", time_str,
            "callid", callid,
            "queuename", queuename,
            "agent", agent,
            "event", event,
            "data", qlog_msg,
            SENTINEL);
      }

      if (!logfiles.queue_log_to_file) {
         return;
      }
   }

   if (qlog) {
      va_start(ap, fmt);
      qlog_len = snprintf(qlog_msg, sizeof(qlog_msg), "%ld|%s|%s|%s|%s|", (long)time(NULL), callid, queuename, agent, event);
      vsnprintf(qlog_msg + qlog_len, sizeof(qlog_msg) - qlog_len, fmt, ap);
      va_end(ap);
      AST_RWLIST_RDLOCK(&logchannels);
      if (qlog) {
         fprintf(qlog, "%s\n", qlog_msg);
         fflush(qlog);
      }
      AST_RWLIST_UNLOCK(&logchannels);
   }
}

int ast_register_verbose ( void(*)(const char *string) v )

Definition at line 1544 of file logger.c.

References ast_malloc, verb::verboser, AST_RWLIST_WRLOCK, AST_RWLIST_INSERT_HEAD, logchannel::list, and AST_RWLIST_UNLOCK.

Referenced by ast_makesocket(), and main().

{
   struct verb *verb;

   if (!(verb = ast_malloc(sizeof(*verb))))
      return -1;

   verb->verboser = v;

   AST_RWLIST_WRLOCK(&verbosers);
   AST_RWLIST_INSERT_HEAD(&verbosers, verb, list);
   AST_RWLIST_UNLOCK(&verbosers);
   
   return 0;
}

int ast_unregister_verbose ( void(*)(const char *string) v )

Definition at line 1560 of file logger.c.

References AST_RWLIST_WRLOCK, AST_RWLIST_TRAVERSE_SAFE_BEGIN, logchannel::list, verb::verboser, AST_RWLIST_REMOVE_CURRENT, ast_free, AST_RWLIST_TRAVERSE_SAFE_END, and AST_RWLIST_UNLOCK.

{
   struct verb *cur;

   AST_RWLIST_WRLOCK(&verbosers);
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&verbosers, cur, list) {
      if (cur->verboser == v) {
         AST_RWLIST_REMOVE_CURRENT(list);
         ast_free(cur);
         break;
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END;
   AST_RWLIST_UNLOCK(&verbosers);
   
   return cur ? 0 : -1;
}

void ast_verbose	(	const char *	fmt,
			...
	)

Definition at line 1535 of file logger.c.

References __ast_verbose_ap().

Referenced by dumpchan_exec(), ivr_demo_func(), conf_run(), mdc1200_notify(), load_rpt_vars(), attempt_reconnect(), rpt(), rpt_exec(), verbose_exec(), dialout(), play_record_review(), ast_set_priority(), quit_handler(), ast_remotecontrol(), ast_readconfig(), main(), ao2_bt(), __ast_bridge_technology_register(), ast_bridge_technology_unregister(), __agent_start_monitoring(), alsa_digit(), alsa_text(), alsa_call(), alsa_answer(), alsa_hangup(), alsa_indicate(), console_answer(), dahdi_ss7_message(), dahdi_pri_message(), dahdi_softhangup_all(), find_gtalk(), gtalk_handle_dtmf(), h323_reload(), iax_debug_output(), jb_debug_output(), timing_read(), jingle_handle_dtmf(), mgcp_reload(), handle_cli_misdn_send_facility(), oss_digit_end(), oss_text(), oss_call(), oss_answer(), oss_hangup(), oss_indicate(), phone_exception(), phone_check_exception(), initialize_initreq(), retrans_pkt(), sip_scheddestroy(), send_response(), send_request(), sip_sendtext(), __sip_destroy(), sip_rtp_read(), sip_read(), process_sdp(), process_sdp_a_audio(), process_sdp_a_video(), process_sdp_a_text(), set_destination(), add_codec_to_sdp(), add_vcodec_to_sdp(), add_tcodec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), transmit_register(), auth_headers(), parse_register_contact(), list_route(), get_rdnis(), get_destination(), get_refer_info(), get_also_info(), check_via(), check_peer_ok(), receive_message(), handle_request_info(), do_register_auth(), handle_response(), handle_request_invite(), handle_request_refer(), handle_request_message(), handle_request_subscribe(), handle_incoming(), handle_request_do(), sip_reload(), load_module(), transmit_softkeysetres(), handle_transfer_button(), handle_offhook_message(), setformat(), usbradio_digit_end(), usbradio_text(), usbradio_indicate(), find_transcoders(), handle_frame(), ast_frame_dump(), hook_event_cb(), print_frame(), timeout_write(), ast_module_reload(), start_resource(), astman_append(), dundi_debug_output(), ast_agi_send(), run_agi(), load_config(), aji_log_hook(), aji_handle_presence(), aji_handle_subscribe(), aji_receive_node_list(), aji_test(), moh_files_release(), init_files_class(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_continuation(), ast_rtp_dtmf_end_with_duration(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_raw_write(), process_dtmf_rfc2833(), ast_rtcp_read(), bridge_p2p_rtp_write(), ast_rtp_read(), ast_rtp_sendcng(), ast_say_number_full_he(), ast_say_enumeration_full_he(), pri_dchannel(), ss7_reset_linkset(), ss7_linkset(), __ast_str_helper(), stun_process_attr(), and ast_stun_handle_packet().

{
   va_list ap;

   va_start(ap, fmt);
   __ast_verbose_ap("", 0, "", fmt, ap);
   va_end(ap);
}

void close_logger ( void )

Provided by logger.c

Definition at line 1147 of file logger.c.

References f, AST_LIST_LOCK, close_logger_thread, ast_cond_signal, logcond, AST_LIST_UNLOCK, logthread, AST_PTHREADT_NULL, AST_RWLIST_WRLOCK, qlog, AST_RWLIST_TRAVERSE, logchannel::list, logchannel::fileptr, and AST_RWLIST_UNLOCK.

Referenced by quit_handler().

{
   struct logchannel *f = NULL;

   logger_initialized = 0;

   /* Stop logger thread */
   AST_LIST_LOCK(&logmsgs);
   close_logger_thread = 1;
   ast_cond_signal(&logcond);
   AST_LIST_UNLOCK(&logmsgs);

   if (logthread != AST_PTHREADT_NULL)
      pthread_join(logthread, NULL);

   AST_RWLIST_WRLOCK(&logchannels);

   if (qlog) {
      fclose(qlog);
      qlog = NULL;
   }

   AST_RWLIST_TRAVERSE(&logchannels, f, list) {
      if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
         fclose(f->fileptr);
         f->fileptr = NULL;
      }
   }

   closelog(); /* syslog */

   AST_RWLIST_UNLOCK(&logchannels);

   return;
}

static char* handle_logger_reload	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)		`[static]`

Definition at line 801 of file logger.c.

References CLI_INIT, ast_cli_entry::command, ast_cli_entry::usage, CLI_GENERATE, reload_logger(), ast_cli(), ast_cli_args::fd, CLI_FAILURE, and CLI_SUCCESS.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger reload";
      e->usage = 
         "Usage: logger reload\n"
         "       Reloads the logger subsystem state.  Use after restarting syslogd(8) if you are using syslog logging.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }
   if (reload_logger(0)) {
      ast_cli(a->fd, "Failed to reload the logger\n");
      return CLI_FAILURE;
   }
   return CLI_SUCCESS;
}

static char* handle_logger_rotate	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)		`[static]`

Definition at line 820 of file logger.c.

References CLI_INIT, ast_cli_entry::command, ast_cli_entry::usage, CLI_GENERATE, reload_logger(), ast_cli(), ast_cli_args::fd, CLI_FAILURE, and CLI_SUCCESS.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger rotate";
      e->usage = 
         "Usage: logger rotate\n"
         "       Rotates and Reopens the log files.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;   
   }
   if (reload_logger(1)) {
      ast_cli(a->fd, "Failed to reload the logger and rotate log files\n");
      return CLI_FAILURE;
   } 
   return CLI_SUCCESS;
}

static char* handle_logger_set_level	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)		`[static]`

Definition at line 839 of file logger.c.

References state, CLI_INIT, ast_cli_entry::command, ast_cli_entry::usage, CLI_GENERATE, ast_cli_args::argc, CLI_SHOWUSAGE, AST_RWLIST_WRLOCK, ARRAY_LEN, levels, ast_cli_args::argv, AST_RWLIST_UNLOCK, ast_true(), ast_console_toggle_loglevel(), ast_cli_args::fd, ast_cli(), and CLI_SUCCESS.

{
   int x;
   int state;
   int level = -1;

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger set level {DEBUG|NOTICE|WARNING|ERROR|VERBOSE|DTMF} {on|off}";
      e->usage = 
         "Usage: logger set level {DEBUG|NOTICE|WARNING|ERROR|VERBOSE|DTMF} {on|off}\n"
         "       Set a specific log level to enabled/disabled for this console.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc < 5)
      return CLI_SHOWUSAGE;

   AST_RWLIST_WRLOCK(&logchannels);

   for (x = 0; x < ARRAY_LEN(levels); x++) {
      if (levels[x] && !strcasecmp(a->argv[3], levels[x])) {
         level = x;
         break;
      }
   }

   AST_RWLIST_UNLOCK(&logchannels);

   state = ast_true(a->argv[4]) ? 1 : 0;

   if (level != -1) {
      ast_console_toggle_loglevel(a->fd, level, state);
      ast_cli(a->fd, "Logger status for '%s' has been set to '%s'.\n", levels[level], state ? "on" : "off");
   } else
      return CLI_SHOWUSAGE;

   return CLI_SUCCESS;
}

static char* handle_logger_show_channels	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)		`[static]`

CLI command to show logging system configuration.

Definition at line 882 of file logger.c.

References CLI_INIT, ast_cli_entry::command, ast_cli_entry::usage, CLI_GENERATE, ast_cli(), ast_cli_args::fd, FORMATL, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, logchannel::list, logchannel::filename, logchannel::type, LOGTYPE_CONSOLE, LOGTYPE_SYSLOG, logchannel::disabled, ARRAY_LEN, levels, logchannel::logmask, AST_RWLIST_UNLOCK, and CLI_SUCCESS.

{
#define FORMATL   "%-35.35s %-8.8s %-9.9s "
   struct logchannel *chan;
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger show channels";
      e->usage = 
         "Usage: logger show channels\n"
         "       List configured logger channels.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;   
   }
   ast_cli(a->fd, FORMATL, "Channel", "Type", "Status");
   ast_cli(a->fd, "Configuration\n");
   ast_cli(a->fd, FORMATL, "-------", "----", "------");
   ast_cli(a->fd, "-------------\n");
   AST_RWLIST_RDLOCK(&logchannels);
   AST_RWLIST_TRAVERSE(&logchannels, chan, list) {
      unsigned int level;

      ast_cli(a->fd, FORMATL, chan->filename, chan->type == LOGTYPE_CONSOLE ? "Console" : (chan->type == LOGTYPE_SYSLOG ? "Syslog" : "File"),
         chan->disabled ? "Disabled" : "Enabled");
      ast_cli(a->fd, " - ");
      for (level = 0; level < ARRAY_LEN(levels); level++) {
         if ((chan->logmask & (1 << level)) && levels[level]) {
            ast_cli(a->fd, "%s ", levels[level]);
         }
      }
      ast_cli(a->fd, "\n");
   }
   AST_RWLIST_UNLOCK(&logchannels);
   ast_cli(a->fd, "\n");

   return CLI_SUCCESS;
}

int init_logger ( void )

Provided by logger.c

Definition at line 1123 of file logger.c.

References handle_SIGXFSZ, ast_cond_init, logcond, ast_pthread_create, logthread, logger_thread(), ast_cond_destroy, ast_cli_register_multiple(), cli_logger, ARRAY_LEN, ast_mkdir(), ast_config_AST_LOG_DIR, and init_logger_chain().

Referenced by main().

{
   /* auto rotate if sig SIGXFSZ comes a-knockin */
   sigaction(SIGXFSZ, &handle_SIGXFSZ, NULL);

   /* start logger thread */
   ast_cond_init(&logcond, NULL);
   if (ast_pthread_create(&logthread, NULL, logger_thread, NULL) < 0) {
      ast_cond_destroy(&logcond);
      return -1;
   }

   /* register the logger cli commands */
   ast_cli_register_multiple(cli_logger, ARRAY_LEN(cli_logger));

   ast_mkdir(ast_config_AST_LOG_DIR, 0777);

   /* create log channels */
   init_logger_chain(0 /* locked */);
   logger_initialized = 1;

   return 0;
}

static void init_logger_chain ( int locked ) [static]

Definition at line 303 of file logger.c.

References var, ast_config_load2(), CONFIG_STATUS_FILEINVALID, AST_RWLIST_WRLOCK, AST_RWLIST_REMOVE_HEAD, logchannel::list, ast_free, AST_RWLIST_UNLOCK, errno, ast_calloc, logchannel::type, LOGTYPE_CONSOLE, logchannel::logmask, __LOG_WARNING, __LOG_NOTICE, __LOG_ERROR, AST_RWLIST_INSERT_HEAD, ast_variable_retrieve(), ast_true(), ast_copy_string(), logfiles, TIMESTAMP, ROTATE, SEQUENTIAL, ast_variable_browse(), ast_variable::next, make_logchannel(), ast_variable::name, ast_variable::value, ast_variable::lineno, ast_console_puts_mutable(), qlog, and ast_config_destroy().

Referenced by reload_logger(), and init_logger().

{
   struct logchannel *chan;
   struct ast_config *cfg;
   struct ast_variable *var;
   const char *s;
   struct ast_flags config_flags = { 0 };

   if (!(cfg = ast_config_load2("logger.conf", "logger", config_flags)) || cfg == CONFIG_STATUS_FILEINVALID) {
      return;
   }

   /* delete our list of log channels */
   if (!locked) {
      AST_RWLIST_WRLOCK(&logchannels);
   }
   while ((chan = AST_RWLIST_REMOVE_HEAD(&logchannels, list))) {
      ast_free(chan);
   }
   global_logmask = 0;
   if (!locked) {
      AST_RWLIST_UNLOCK(&logchannels);
   }

   errno = 0;
   /* close syslog */
   closelog();

   /* If no config file, we're fine, set default options. */
   if (!cfg) {
      if (errno) {
         fprintf(stderr, "Unable to open logger.conf: %s; default settings will be used.\n", strerror(errno));
      } else {
         fprintf(stderr, "Errors detected in logger.conf: see above; default settings will be used.\n");
      }
      if (!(chan = ast_calloc(1, sizeof(*chan)))) {
         return;
      }
      chan->type = LOGTYPE_CONSOLE;
      chan->logmask = __LOG_WARNING | __LOG_NOTICE | __LOG_ERROR;
      if (!locked) {
         AST_RWLIST_WRLOCK(&logchannels);
      }
      AST_RWLIST_INSERT_HEAD(&logchannels, chan, list);
      global_logmask |= chan->logmask;
      if (!locked) {
         AST_RWLIST_UNLOCK(&logchannels);
      }
      return;
   }

   if ((s = ast_variable_retrieve(cfg, "general", "appendhostname"))) {
      if (ast_true(s)) {
         if (gethostname(hostname, sizeof(hostname) - 1)) {
            ast_copy_string(hostname, "unknown", sizeof(hostname));
            fprintf(stderr, "What box has no hostname???\n");
         }
      } else
         hostname[0] = '\0';
   } else
      hostname[0] = '\0';
   if ((s = ast_variable_retrieve(cfg, "general", "dateformat")))
      ast_copy_string(dateformat, s, sizeof(dateformat));
   else
      ast_copy_string(dateformat, "%b %e %T", sizeof(dateformat));
   if ((s = ast_variable_retrieve(cfg, "general", "queue_log"))) {
      logfiles.queue_log = ast_true(s);
   }
   if ((s = ast_variable_retrieve(cfg, "general", "queue_log_to_file"))) {
      logfiles.queue_log_to_file = ast_true(s);
   }
   if ((s = ast_variable_retrieve(cfg, "general", "queue_log_name"))) {
      ast_copy_string(queue_log_name, s, sizeof(queue_log_name));
   }
   if ((s = ast_variable_retrieve(cfg, "general", "exec_after_rotate"))) {
      ast_copy_string(exec_after_rotate, s, sizeof(exec_after_rotate));
   }
   if ((s = ast_variable_retrieve(cfg, "general", "rotatestrategy"))) {
      if (strcasecmp(s, "timestamp") == 0) {
         rotatestrategy = TIMESTAMP;
      } else if (strcasecmp(s, "rotate") == 0) {
         rotatestrategy = ROTATE;
      } else if (strcasecmp(s, "sequential") == 0) {
         rotatestrategy = SEQUENTIAL;
      } else {
         fprintf(stderr, "Unknown rotatestrategy: %s\n", s);
      }
   } else {
      if ((s = ast_variable_retrieve(cfg, "general", "rotatetimestamp"))) {
         rotatestrategy = ast_true(s) ? TIMESTAMP : SEQUENTIAL;
         fprintf(stderr, "rotatetimestamp option has been deprecated.  Please use rotatestrategy instead.\n");
      }
   }

   if (!locked) {
      AST_RWLIST_WRLOCK(&logchannels);
   }
   var = ast_variable_browse(cfg, "logfiles");
   for (; var; var = var->next) {
      if (!(chan = make_logchannel(var->name, var->value, var->lineno))) {
         /* Print error message directly to the consoles since the lock is held
          * and we don't want to unlock with the list partially built */
         ast_console_puts_mutable("ERROR: Unable to create log channel '", __LOG_ERROR);
         ast_console_puts_mutable(var->name, __LOG_ERROR);
         ast_console_puts_mutable("'\n", __LOG_ERROR);
         continue;
      }
      AST_RWLIST_INSERT_HEAD(&logchannels, chan, list);
      global_logmask |= chan->logmask;
   }

   if (qlog) {
      fclose(qlog);
      qlog = NULL;
   }

   if (!locked) {
      AST_RWLIST_UNLOCK(&logchannels);
   }

   ast_config_destroy(cfg);
}

static void logger_print_normal ( struct logmsg * logmsg ) [static]

Print a normal log message to the channels.

Definition at line 964 of file logger.c.

References logmsg::level, __LOG_VERBOSE, ast_strdupa, logmsg::message, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, logchannel::list, verb::verboser, AST_RWLIST_UNLOCK, ast_string_field_set, AST_RWLIST_EMPTY, logchannel::disabled, logchannel::type, LOGTYPE_SYSLOG, logchannel::logmask, ast_log_vsyslog(), LOGTYPE_CONSOLE, logmsg::line, logmsg::date, term_color(), logmsg::level_name, colors, logmsg::process_id, logmsg::file, COLOR_BRWHITE, logmsg::function, ast_console_puts_mutable(), LOGTYPE_FILE, logchannel::fileptr, term_strip(), ast_strlen_zero(), errno, logchannel::filename, manager_event, EVENT_FLAG_SYSTEM, reload_logger(), and ast_verb.

Referenced by logger_thread(), and ast_log().

{
   struct logchannel *chan = NULL;
   char buf[BUFSIZ];
   struct verb *v = NULL;

   if (logmsg->level == __LOG_VERBOSE) {
      char *tmpmsg = ast_strdupa(logmsg->message + 1);
      /* Iterate through the list of verbosers and pass them the log message string */
      AST_RWLIST_RDLOCK(&verbosers);
      AST_RWLIST_TRAVERSE(&verbosers, v, list)
         v->verboser(logmsg->message);
      AST_RWLIST_UNLOCK(&verbosers);
      ast_string_field_set(logmsg, message, tmpmsg);
   }

   AST_RWLIST_RDLOCK(&logchannels);

   if (!AST_RWLIST_EMPTY(&logchannels)) {
      AST_RWLIST_TRAVERSE(&logchannels, chan, list) {
         /* If the channel is disabled, then move on to the next one */
         if (chan->disabled)
            continue;
         /* Check syslog channels */
         if (chan->type == LOGTYPE_SYSLOG && (chan->logmask & (1 << logmsg->level))) {
            ast_log_vsyslog(logmsg);
         /* Console channels */
         } else if (chan->type == LOGTYPE_CONSOLE && (chan->logmask & (1 << logmsg->level))) {
            char linestr[128];
            char tmp1[80], tmp2[80], tmp3[80], tmp4[80];

            /* If the level is verbose, then skip it */
            if (logmsg->level == __LOG_VERBOSE)
               continue;

            /* Turn the numerical line number into a string */
            snprintf(linestr, sizeof(linestr), "%d", logmsg->line);
            /* Build string to print out */
            snprintf(buf, sizeof(buf), "[%s] %s[%ld]: %s:%s %s: %s",
                logmsg->date,
                term_color(tmp1, logmsg->level_name, colors[logmsg->level], 0, sizeof(tmp1)),
                logmsg->process_id,
                term_color(tmp2, logmsg->file, COLOR_BRWHITE, 0, sizeof(tmp2)),
                term_color(tmp3, linestr, COLOR_BRWHITE, 0, sizeof(tmp3)),
                term_color(tmp4, logmsg->function, COLOR_BRWHITE, 0, sizeof(tmp4)),
                logmsg->message);
            /* Print out */
            ast_console_puts_mutable(buf, logmsg->level);
         /* File channels */
         } else if (chan->type == LOGTYPE_FILE && (chan->logmask & (1 << logmsg->level))) {
            int res = 0;

            /* If no file pointer exists, skip it */
            if (!chan->fileptr) {
               continue;
            }

            /* Print out to the file */
            res = fprintf(chan->fileptr, "[%s] %s[%ld] %s: %s",
                     logmsg->date, logmsg->level_name, logmsg->process_id, logmsg->file, term_strip(buf, logmsg->message, BUFSIZ));
            if (res <= 0 && !ast_strlen_zero(logmsg->message)) {
               fprintf(stderr, "**** Asterisk Logging Error: ***********\n");
               if (errno == ENOMEM || errno == ENOSPC)
                  fprintf(stderr, "Asterisk logging error: Out of disk space, can't log to log file %s\n", chan->filename);
               else
                  fprintf(stderr, "Logger Warning: Unable to write to log file '%s': %s (disabled)\n", chan->filename, strerror(errno));
               manager_event(EVENT_FLAG_SYSTEM, "LogChannel", "Channel: %s\r\nEnabled: No\r\nReason: %d - %s\r\n", chan->filename, errno, strerror(errno));
               chan->disabled = 1;
            } else if (res > 0) {
               fflush(chan->fileptr);
            }
         }
      }
   } else if (logmsg->level != __LOG_VERBOSE) {
      fputs(logmsg->message, stdout);
   }

   AST_RWLIST_UNLOCK(&logchannels);

   /* If we need to reload because of the file size, then do so */
   if (filesize_reload_needed) {
      reload_logger(-1);
      ast_verb(1, "Rotated Logs Per SIGXFSZ (Exceeded file size limit)\n");
   }

   return;
}

static void logger_queue_init ( void ) [static]

Definition at line 1099 of file logger.c.

References ast_unload_realtime(), logfiles, logger_queue_rt_start(), ast_config_AST_LOG_DIR, qlog, ast_log(), LOG_ERROR, and errno.

Referenced by ast_queue_log().

{
   ast_unload_realtime("queue_log");
   if (logfiles.queue_log) {
      char qfname[PATH_MAX];

      if (logger_queue_rt_start()) {
         return;
      }

      /* Open the log file. */
      snprintf(qfname, sizeof(qfname), "%s/%s", ast_config_AST_LOG_DIR,
         queue_log_name);
      if (qlog) {
         /* Just in case it was already open. */
         fclose(qlog);
      }
      qlog = fopen(qfname, "a");
      if (!qlog) {
         ast_log(LOG_ERROR, "Unable to create queue log: %s\n", strerror(errno));
      }
   }
}

static int logger_queue_restart ( int queue_rotate ) [static]

Definition at line 700 of file logger.c.

References logger_queue_rt_start(), ast_config_AST_LOG_DIR, qlog, rotate_file(), ast_log(), LOG_ERROR, and errno.

Referenced by reload_logger().

{
   int res = 0;
   char qfname[PATH_MAX];

   if (logger_queue_rt_start()) {
      return res;
   }

   snprintf(qfname, sizeof(qfname), "%s/%s", ast_config_AST_LOG_DIR, queue_log_name);
   if (qlog) {
      /* Just in case it was still open. */
      fclose(qlog);
      qlog = NULL;
   }
   if (queue_rotate) {
      rotate_file(qfname);
   }

   /* Open the log file. */
   qlog = fopen(qfname, "a");
   if (!qlog) {
      ast_log(LOG_ERROR, "Unable to create queue log: %s\n", strerror(errno));
      res = -1;
   }
   return res;
}

static int logger_queue_rt_start ( void ) [static]

Definition at line 665 of file logger.c.

References ast_check_realtime(), ast_realtime_require_field(), RQ_DATETIME, RQ_CHAR, SENTINEL, and logfiles.

Referenced by logger_queue_restart(), and logger_queue_init().

{
   if (ast_check_realtime("queue_log")) {
      if (!ast_realtime_require_field("queue_log",
         "time", RQ_DATETIME, 26,
         "data1", RQ_CHAR, 20,
         "data2", RQ_CHAR, 20,
         "data3", RQ_CHAR, 20,
         "data4", RQ_CHAR, 20,
         "data5", RQ_CHAR, 20,
         SENTINEL)) {
         logfiles.queue_adaptive_realtime = 1;
      } else {
         logfiles.queue_adaptive_realtime = 0;
      }

      if (!logfiles.queue_log_to_file) {
         /* Don't open the log file. */
         return 1;
      }
   }
   return 0;
}

int logger_reload ( void )

Reload the logger module without rotating log files (also used from loader.c during a full Asterisk reload)

Reload logger without rotating log files.

Definition at line 793 of file logger.c.

References reload_logger(), RESULT_FAILURE, and RESULT_SUCCESS.

{
   if (reload_logger(0)) {
      return RESULT_FAILURE;
   }
   return RESULT_SUCCESS;
}

static void* logger_thread ( void * data ) [static]

Actual logging thread.

Definition at line 1053 of file logger.c.

References logchannel::next, AST_LIST_LOCK, AST_LIST_EMPTY, close_logger_thread, ast_cond_wait, logcond, logmsgs::lock, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_UNLOCK, AST_LIST_NEXT, logchannel::list, logger_print_normal(), and ast_free.

Referenced by init_logger().

{
   struct logmsg *next = NULL, *msg = NULL;

   for (;;) {
      /* We lock the message list, and see if any message exists... if not we wait on the condition to be signalled */
      AST_LIST_LOCK(&logmsgs);
      if (AST_LIST_EMPTY(&logmsgs)) {
         if (close_logger_thread) {
            break;
         } else {
            ast_cond_wait(&logcond, &logmsgs.lock);
         }
      }
      next = AST_LIST_FIRST(&logmsgs);
      AST_LIST_HEAD_INIT_NOLOCK(&logmsgs);
      AST_LIST_UNLOCK(&logmsgs);

      /* Otherwise go through and process each message in the order added */
      while ((msg = next)) {
         /* Get the next entry now so that we can free our current structure later */
         next = AST_LIST_NEXT(msg, list);

         /* Depending on the type, send it to the proper function */
         logger_print_normal(msg);

         /* Free the data since we are done */
         ast_free(msg);
      }

      /* If we should stop, then stop */
      if (close_logger_thread)
         break;
   }

   return NULL;
}

static unsigned int make_components	(	const char *	s,
		int	lineno
	)		`[static]`

Definition at line 219 of file logger.c.

References ast_strdupa, strsep(), ast_skip_blanks(), ARRAY_LEN, and levels.

Referenced by make_logchannel(), and update_logchannels().

{
   char *w;
   unsigned int res = 0;
   char *stringp = ast_strdupa(s);
   unsigned int x;

   while ((w = strsep(&stringp, ","))) {
      w = ast_skip_blanks(w);

      if (!strcmp(w, "*")) {
         res = 0xFFFFFFFF;
         break;
      } else for (x = 0; x < ARRAY_LEN(levels); x++) {
         if (levels[x] && !strcasecmp(w, levels[x])) {
            res |= (1 << x);
            break;
         }
      }
   }

   return res;
}

static struct logchannel* make_logchannel	(	const char *	channel,
		const char *	components,
		int	lineno
	)		`[static, read]`

Definition at line 243 of file logger.c.

References logchannel::facility, ast_strlen_zero(), ast_calloc, logchannel::components, logchannel::lineno, logchannel::type, LOGTYPE_CONSOLE, ast_syslog_facility(), ast_free, LOGTYPE_SYSLOG, ast_copy_string(), logchannel::filename, ast_config_AST_LOG_DIR, logchannel::fileptr, ast_console_puts_mutable(), __LOG_ERROR, errno, LOGTYPE_FILE, logchannel::logmask, and make_components().

Referenced by init_logger_chain().

{
   struct logchannel *chan;
   char *facility;

   if (ast_strlen_zero(channel) || !(chan = ast_calloc(1, sizeof(*chan) + strlen(components) + 1)))
      return NULL;

   strcpy(chan->components, components);
   chan->lineno = lineno;

   if (!strcasecmp(channel, "console")) {
      chan->type = LOGTYPE_CONSOLE;
   } else if (!strncasecmp(channel, "syslog", 6)) {
      /*
      * syntax is:
      *  syslog.facility => level,level,level
      */
      facility = strchr(channel, '.');
      if (!facility++ || !facility) {
         facility = "local0";
      }

      chan->facility = ast_syslog_facility(facility);

      if (chan->facility < 0) {
         fprintf(stderr, "Logger Warning: bad syslog facility in logger.conf\n");
         ast_free(chan);
         return NULL;
      }

      chan->type = LOGTYPE_SYSLOG;
      ast_copy_string(chan->filename, channel, sizeof(chan->filename));
      openlog("asterisk", LOG_PID, chan->facility);
   } else {
      if (!ast_strlen_zero(hostname)) {
         snprintf(chan->filename, sizeof(chan->filename), "%s/%s.%s",
             channel[0] != '/' ? ast_config_AST_LOG_DIR : "", channel, hostname);
      } else {
         snprintf(chan->filename, sizeof(chan->filename), "%s/%s",
             channel[0] != '/' ? ast_config_AST_LOG_DIR : "", channel);
      }
      if (!(chan->fileptr = fopen(chan->filename, "a"))) {
         /* Can't do real logging here since we're called with a lock
          * so log to any attached consoles */
         ast_console_puts_mutable("ERROR: Unable to open log file '", __LOG_ERROR);
         ast_console_puts_mutable(chan->filename, __LOG_ERROR);
         ast_console_puts_mutable("': ", __LOG_ERROR);
         ast_console_puts_mutable(strerror(errno), __LOG_ERROR);
         ast_console_puts_mutable("'\n", __LOG_ERROR);
         ast_free(chan);
         return NULL;
      }
      chan->type = LOGTYPE_FILE;
   }
   chan->logmask = make_components(chan->components, lineno);

   return chan;
}

static int reload_logger ( int rotate ) [static]

Definition at line 728 of file logger.c.

References f, AST_RWLIST_WRLOCK, qlog, ast_mkdir(), ast_config_AST_LOG_DIR, AST_RWLIST_TRAVERSE, logchannel::list, logchannel::disabled, manager_event, EVENT_FLAG_SYSTEM, logchannel::filename, logchannel::fileptr, rotate_file(), init_logger_chain(), ast_unload_realtime(), logfiles, logger_queue_restart(), AST_RWLIST_UNLOCK, ast_queue_log(), and ast_verb.

Referenced by logger_reload(), handle_logger_reload(), handle_logger_rotate(), and logger_print_normal().

{
   int queue_rotate = rotate;
   struct logchannel *f;
   int res = 0;

   AST_RWLIST_WRLOCK(&logchannels);

   if (qlog) {
      if (rotate < 0) {
         /* Check filesize - this one typically doesn't need an auto-rotate */
         if (ftello(qlog) > 0x40000000) { /* Arbitrarily, 1 GB */
            fclose(qlog);
            qlog = NULL;
         } else {
            queue_rotate = 0;
         }
      } else {
         fclose(qlog);
         qlog = NULL;
      }
   } else {
      queue_rotate = 0;
   }

   ast_mkdir(ast_config_AST_LOG_DIR, 0777);

   AST_RWLIST_TRAVERSE(&logchannels, f, list) {
      if (f->disabled) {
         f->disabled = 0;  /* Re-enable logging at reload */
         manager_event(EVENT_FLAG_SYSTEM, "LogChannel", "Channel: %s\r\nEnabled: Yes\r\n", f->filename);
      }
      if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
         int rotate_this = 0;
         if (ftello(f->fileptr) > 0x40000000) { /* Arbitrarily, 1 GB */
            /* Be more proactive about rotating massive log files */
            rotate_this = 1;
         }
         fclose(f->fileptr);  /* Close file */
         f->fileptr = NULL;
         if (rotate || rotate_this) {
            rotate_file(f->filename);
         }
      }
   }

   filesize_reload_needed = 0;

   init_logger_chain(1 /* locked */);

   ast_unload_realtime("queue_log");
   if (logfiles.queue_log) {
      res = logger_queue_restart(queue_rotate);
      AST_RWLIST_UNLOCK(&logchannels);
      ast_queue_log("NONE", "NONE", "NONE", "CONFIGRELOAD", "%s", "");
      ast_verb(1, "Asterisk Queue Logger restarted\n");
   } else {
      AST_RWLIST_UNLOCK(&logchannels);
   }

   return res;
}

static int rotate_file ( const char * filename ) [static]

Definition at line 567 of file logger.c.

References SEQUENTIAL, TIMESTAMP, ROTATE, ARRAY_LEN, ast_strlen_zero(), ast_dummy_channel_alloc(), pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), ast_safe_system(), ast_log(), LOG_WARNING, and ast_channel_release().

Referenced by logger_queue_restart(), and reload_logger().

{
   char old[PATH_MAX];
   char new[PATH_MAX];
   int x, y, which, found, res = 0, fd;
   char *suffixes[4] = { "", ".gz", ".bz2", ".Z" };

   switch (rotatestrategy) {
   case SEQUENTIAL:
      for (x = 0; ; x++) {
         snprintf(new, sizeof(new), "%s.%d", filename, x);
         fd = open(new, O_RDONLY);
         if (fd > -1)
            close(fd);
         else
            break;
      }
      if (rename(filename, new)) {
         fprintf(stderr, "Unable to rename file '%s' to '%s'\n", filename, new);
         res = -1;
      } else {
         filename = new;
      }
      break;
   case TIMESTAMP:
      snprintf(new, sizeof(new), "%s.%ld", filename, (long)time(NULL));
      if (rename(filename, new)) {
         fprintf(stderr, "Unable to rename file '%s' to '%s'\n", filename, new);
         res = -1;
      } else {
         filename = new;
      }
      break;
   case ROTATE:
      /* Find the next empty slot, including a possible suffix */
      for (x = 0; ; x++) {
         found = 0;
         for (which = 0; which < ARRAY_LEN(suffixes); which++) {
            snprintf(new, sizeof(new), "%s.%d%s", filename, x, suffixes[which]);
            fd = open(new, O_RDONLY);
            if (fd > -1) {
               close(fd);
               found = 1;
               break;
            }
         }
         if (!found) {
            break;
         }
      }

      /* Found an empty slot */
      for (y = x; y > 0; y--) {
         for (which = 0; which < ARRAY_LEN(suffixes); which++) {
            snprintf(old, sizeof(old), "%s.%d%s", filename, y - 1, suffixes[which]);
            fd = open(old, O_RDONLY);
            if (fd > -1) {
               /* Found the right suffix */
               close(fd);
               snprintf(new, sizeof(new), "%s.%d%s", filename, y, suffixes[which]);
               if (rename(old, new)) {
                  fprintf(stderr, "Unable to rename file '%s' to '%s'\n", old, new);
                  res = -1;
               }
               break;
            }
         }
      }

      /* Finally, rename the current file */
      snprintf(new, sizeof(new), "%s.0", filename);
      if (rename(filename, new)) {
         fprintf(stderr, "Unable to rename file '%s' to '%s'\n", filename, new);
         res = -1;
      } else {
         filename = new;
      }
   }

   if (!ast_strlen_zero(exec_after_rotate)) {
      struct ast_channel *c = ast_dummy_channel_alloc();
      char buf[512];
      pbx_builtin_setvar_helper(c, "filename", filename);
      pbx_substitute_variables_helper(c, exec_after_rotate, buf, sizeof(buf));
      if (ast_safe_system(buf) == -1) {
         ast_log(LOG_WARNING, "error executing '%s'\n", buf);
      }
      c = ast_channel_release(c);
   }
   return res;
}

static void update_logchannels ( void ) [static]

Definition at line 1578 of file logger.c.

References AST_RWLIST_WRLOCK, AST_RWLIST_TRAVERSE, logchannel::list, logchannel::logmask, make_components(), logchannel::components, logchannel::lineno, and AST_RWLIST_UNLOCK.

Referenced by ast_logger_register_level(), and ast_logger_unregister_level().

{
   struct logchannel *cur;

   AST_RWLIST_WRLOCK(&logchannels);

   global_logmask = 0;

   AST_RWLIST_TRAVERSE(&logchannels, cur, list) {
      cur->logmask = make_components(cur->components, cur->lineno);
      global_logmask |= cur->logmask;
   }

   AST_RWLIST_UNLOCK(&logchannels);
}

Variable Documentation

struct ast_cli_entry cli_logger[] [static]

Definition at line 927 of file logger.c.

Referenced by init_logger().

int close_logger_thread = 0 [static]

Definition at line 150 of file logger.c.

Referenced by logger_thread(), and close_logger().

const int colors[32] [static]

Colors used in the console for logging.

Definition at line 176 of file logger.c.

Referenced by logger_print_normal().

char dateformat[256] = "%b %e %T" [static]

Definition at line 74 of file logger.c.

Referenced by build_device().

char exec_after_rotate[256] = "" [static]

Definition at line 77 of file logger.c.

int filesize_reload_needed [static]

Definition at line 79 of file logger.c.

unsigned int global_logmask = 0xFFFF [static]

Definition at line 80 of file logger.c.

struct sigaction handle_SIGXFSZ [static]

Initial value:

 {
   .sa_handler = _handle_SIGXFSZ,
   .sa_flags = SA_RESTART,
}

Definition at line 940 of file logger.c.

Referenced by init_logger().

char hostname[MAXHOSTNAMELEN] [static]

Definition at line 96 of file logger.c.

Referenced by app_exec(), netconsole(), cli_prompt(), ast_remotecontrol(), ast_readconfig(), main(), tds_load_module(), iax2_register(), sip_subscribe_mwi(), and set_destination().

char* levels[32] [static]

Logging channels used in the Asterisk logging system.

The first 16 levels are reserved for system usage, and the remaining levels are reserved for usage by dynamic levels registered via ast_logger_register_level.

Definition at line 165 of file logger.c.

Referenced by ast_network_puts_mutable(), make_components(), handle_logger_set_level(), handle_logger_show_channels(), ast_log_vsyslog(), ast_log(), ast_logger_register_level(), and ast_logger_unregister_level().