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/astobj2.h"
#include "asterisk/threadstorage.h"
#include "asterisk/strings.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/buildinfo.h"
#include "asterisk/ast_version.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	ast_callid
struct	logchannel
struct	logchannels
struct	logmsg
struct	logmsgs
struct	verb
struct	verb_console
struct	verb_consoles
struct	verbosers
Defines
#define	FORMATL "%-35.35s %-8.8s %-9.9s "
#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, int level, const char *fmt,...)
	Send a verbose message (based on verbose level)
void	__ast_verbose_ap (const char file, int line, const char func, int level, struct ast_callid callid, const char fmt, va_list ap)
void	__ast_verbose_callid (const char file, int line, const char func, int level, struct ast_callid callid, const char fmt,...)
	Send a verbose message (based on verbose level) with deliberately specified callid.
static void	__init_log_buf (void)
static void	__init_my_verb_console (void)
static void	__init_unique_callid (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_callid_strnprint (char buffer, size_t buffer_size, struct ast_callid callid)
	copy a string representation of the callid into a target string
int	ast_callid_threadassoc_add (struct ast_callid *callid)
	Adds a known callid to thread storage of the calling thread.
int	ast_callid_threadassoc_change (struct ast_callid *callid)
	Sets what is stored in the thread storage to the given callid if it does not match what is already there.
int	ast_callid_threadassoc_remove (void)
	Removes callid from thread storage of the calling thread.
int	ast_callid_threadstorage_auto (struct ast_callid **callid)
	Checks thread storage for a callid and stores a reference if it exists. If not, then a new one will be created, bound to the thread, and a reference to it will be stored.
void	ast_callid_threadstorage_auto_clean (struct ast_callid *callid, int callid_created)
	Use in conjunction with ast_callid_threadstorage_auto. Cleans up the references and if the callid was created by threadstorage_auto, unbinds the callid from the threadstorage.
void	ast_child_verbose (int level, const char *fmt,...)
struct ast_callid *	ast_create_callid (void)
	factory function to create a new uniquely identifying callid.
void	ast_log (int level, const char file, int line, const char function, const char *fmt,...)
	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.
void	ast_log_callid (int level, const char file, int line, const char function, struct ast_callid callid, const char fmt,...)
	Used for sending a log message with a known call_id This is a modified logger function which is functionally identical to the above logger function, it just include a call_id argument as well. If NULL is specified here, no attempt will be made to join the log message with a call_id.
static void	ast_log_full (int level, const char file, int line, const char function, struct ast_callid callid, const char fmt, va_list ap)
	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,...)
struct ast_callid *	ast_read_threadstorage_callid (void)
	extracts the callerid from the thread
int	ast_register_verbose (void(v)(const char string))
int	ast_unregister_verbose (void(v)(const char string))
int	ast_verb_console_get (void)
	Get this thread's console verbosity level.
void	ast_verb_console_register (int *level)
	Register this thread's console verbosity level pointer.
void	ast_verb_console_set (int verb_level)
	Set this thread's console verbosity level.
void	ast_verb_console_unregister (void)
	Unregister this thread's console verbosity level.
void	ast_verb_update (void)
	Re-evaluate the system max verbosity level (ast_verb_sys_level).
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, const char *altconf)
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 void	logmsg_free (struct logmsg *msg)
static void	make_components (struct logchannel *chan)
static struct logchannel *	make_logchannel (const char channel, const char components, int lineno)
static int	reload_logger (int rotate, const char *altconf)
static int	rotate_file (const char *filename)
static void	unique_callid_cleanup (void *data)
static void	update_logchannels (void)
static void	verb_console_free (void *v_console)
static void	verb_console_unregister (struct verb_console *console)
Variables
static struct ast_cli_entry	cli_logger []
static int	close_logger_thread = 0
static const int	colors [NUMLOGLEVELS]
	Colors used in the console for logging.
static char	dateformat [256] = "%b %e %T"
static int	display_callids
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 [NUMLOGLEVELS]
	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 struct ast_threadstorage	my_verb_console = { .once = PTHREAD_ONCE_INIT , .key_init = __init_my_verb_console , .custom_init = NULL , }
static volatile int	next_unique_callid
static FILE *	qlog
static char	queue_log_name [256] = QUEUELOG
static int	queuelog_init
static enum rotatestrategy	rotatestrategy
static struct ast_threadstorage	unique_callid = { .once = PTHREAD_ONCE_INIT , .key_init = __init_unique_callid , .custom_init = NULL , }
static struct verb_consoles	verb_consoles
static ast_mutex_t	verb_update_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
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 LOG_BUF_INIT_SIZE 256

Definition at line 236 of file logger.c.

Referenced by ast_log_full().

#define MAX_BACKTRACE_FRAMES 20

Definition at line 65 of file logger.c.

#define VERBOSE_BUF_INIT_SIZE 256

Definition at line 233 of file logger.c.

Referenced by __ast_verbose_ap().

Enumeration Type Documentation

enum logmsgtypes

Enumerator:

LOGMSG_NORMAL
LOGMSG_VERBOSE

Definition at line 139 of file logger.c.

                 {
   LOGMSG_NORMAL = 0,
   LOGMSG_VERBOSE,
};

enum logtypes

Enumerator:

LOGTYPE_SYSLOG
LOGTYPE_FILE
LOGTYPE_CONSOLE

Definition at line 108 of file logger.c.

              {
   LOGTYPE_SYSLOG,
   LOGTYPE_FILE,
   LOGTYPE_CONSOLE,
};

enum rotatestrategy

Enumerator:

SEQUENTIAL
ROTATE
TIMESTAMP

Definition at line 94 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,
		int	level,
		const char *	fmt,
			...
	)

Send a verbose message (based on verbose level)

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 absence of a comma after the VERBOSE_PREFIX_3. This is important. VERBOSE_PREFIX_1 through VERBOSE_PREFIX_4 are defined.

Version:: 11 added level parameter

Definition at line 1871 of file logger.c.

References __ast_verbose_ap(), ast_callid_unref, and ast_read_threadstorage_callid().

{
   struct ast_callid *callid;
   va_list ap;

   callid = ast_read_threadstorage_callid();

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

   if (callid) {
      ast_callid_unref(callid);
   }
}

void __ast_verbose_ap	(	const char *	file,
		int	line,
		const char *	func,
		int	level,
		struct ast_callid *	callid,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1809 of file logger.c.

References __LOG_VERBOSE, AST_DYNSTR_BUILD_FAILED, ast_free, ast_localtime(), ast_log_callid(), ast_opt_timestamp, ast_str_append(), ast_str_append_substr(), ast_str_buffer(), ast_str_create(), ast_str_reset(), ast_str_set_va(), ast_str_thread_get(), ast_strftime(), ast_tvnow(), prefix, verbose_buf, VERBOSE_BUF_INIT_SIZE, VERBOSE_PREFIX_1, VERBOSE_PREFIX_2, VERBOSE_PREFIX_3, and VERBOSE_PREFIX_4.

Referenced by __ast_verbose(), __ast_verbose_callid(), ast_log(), and ast_verbose().

{
   const char *p;
   struct ast_str *prefixed, *buf = NULL;
   int res = 0;
   const char *prefix = level >= 4 ? VERBOSE_PREFIX_4 : level == 3 ? VERBOSE_PREFIX_3 : level == 2 ? VERBOSE_PREFIX_2 : level == 1 ? VERBOSE_PREFIX_1 : "";
   signed char magic = level > 9 ? -10 : -level - 1; /* 0 => -1, 1 => -2, etc.  Can't pass NUL, as it is EOS-delimiter */

   /* For compatibility with modules still calling ast_verbose() directly instead of using ast_verb() */
   if (level < 0) {
      if (!strncmp(fmt, VERBOSE_PREFIX_4, strlen(VERBOSE_PREFIX_4))) {
         magic = -5;
      } else if (!strncmp(fmt, VERBOSE_PREFIX_3, strlen(VERBOSE_PREFIX_3))) {
         magic = -4;
      } else if (!strncmp(fmt, VERBOSE_PREFIX_2, strlen(VERBOSE_PREFIX_2))) {
         magic = -3;
      } else if (!strncmp(fmt, VERBOSE_PREFIX_1, strlen(VERBOSE_PREFIX_1))) {
         magic = -2;
      } else {
         magic = -1;
      }
   }

   if (!(prefixed = ast_str_thread_get(&verbose_buf, VERBOSE_BUF_INIT_SIZE)) ||
       !(buf = ast_str_create(VERBOSE_BUF_INIT_SIZE))) {
      return;
   }

   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) {
      ast_free(buf);
      return;
   }

   ast_str_reset(prefixed);
   /* for every newline found in the buffer add verbose prefix data */
   fmt = ast_str_buffer(buf);
   do {
      if (!(p = strchr(fmt, '\n'))) {
         p = strchr(fmt, '\0') - 1;
      }
      ++p;

      if (ast_opt_timestamp) {
         struct ast_tm tm;
         char date[40];
         struct timeval now = ast_tvnow();
         ast_localtime(&now, &tm, NULL);
         ast_strftime(date, sizeof(date), dateformat, &tm);
         ast_str_append(&prefixed, 0, "%c[%s] %s", (char) magic, date, prefix);
      } else {
         ast_str_append(&prefixed, 0, "%c%s", (char) magic, prefix);
      }
      ast_str_append_substr(&prefixed, 0, fmt, p - fmt);
      fmt = p;
   } while (p && *p);

   ast_log_callid(__LOG_VERBOSE, file, line, func, callid, "%s", ast_str_buffer(prefixed));
   ast_free(buf);
}

void __ast_verbose_callid	(	const char *	file,
		int	line,
		const char *	func,
		int	level,
		struct ast_callid *	callid,
		const char *	fmt,
			...
	)

Send a verbose message (based on verbose level) with deliberately specified callid.

just like __ast_verbose, only __ast_verbose_callid allows you to specify which callid is being used for the log without needing to bind it to a thread. NULL is a valid argument for this function and will allow you to specify that a log will never display a call id even when there is a call id bound to the thread.

Definition at line 1887 of file logger.c.

References __ast_verbose_ap().

{
   va_list ap;
   va_start(ap, fmt);
   __ast_verbose_ap(file, line, func, level, callid, fmt, ap);
   va_end(ap);
}

static void __init_log_buf ( void ) [static]

Definition at line 235 of file logger.c.

static void __init_my_verb_console ( void ) [static]

Thread specific console verbosity level node.

Definition at line 1990 of file logger.c.

static void __init_unique_callid ( void ) [static]

Definition at line 92 of file logger.c.

static void __init_verbose_buf ( void ) [static]

Definition at line 232 of file logger.c.

static void _handle_SIGXFSZ ( int sig ) [static]

Definition at line 1011 of file logger.c.

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

void ast_backtrace ( void )

Definition at line 1781 of file logger.c.

References ast_bt_create(), ast_bt_destroy(), ast_bt_get_symbols(), ast_debug, ast_log(), ast_std_free(), and LOG_WARNING.

{
#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_debug(1, "#%d: [%p] %s\n", i - 3, bt->addresses[i], strings[i]);
      }

      ast_std_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 1593 of file logger.c.

References ast_bt_get_addresses(), ast_calloc, ast_log(), and LOG_ERROR.

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 1615 of file logger.c.

References 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 1608 of file logger.c.

Referenced by __ast_pthread_mutex_lock(), __ast_pthread_mutex_trylock(), __ast_rwlock_rdlock(), __ast_rwlock_timedrdlock(), __ast_rwlock_timedwrlock(), __ast_rwlock_tryrdlock(), __ast_rwlock_trywrlock(), __ast_rwlock_wrlock(), 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 1624 of file logger.c.

References ast_calloc, ast_debug, ast_free, ast_malloc, ast_std_calloc(), ast_std_free(), ast_std_realloc(), ast_strlen_zero(), ast_utils_which(), and S_OR.

Referenced by ao2_bt(), and ast_backtrace().

{
   char **strings;
#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));
   strings = ast_std_calloc(num_frames, sizeof(*strings));
   if (!eachlen || !strings) {
      ast_free(eachlen);
      ast_std_free(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_debug(1, "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;
            }

            /* file can possibly be null even with a success result from bfd_find_nearest_line */
            file = file ? file : "";

            /* 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);
         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) + 1;
         if (!(tmp = ast_std_realloc(strings, strings_size + eachlen[stackfr]))) {
            ast_std_free(strings);
            strings = NULL;
            break; /* out of stack frame iteration */
         }
         strings = tmp;
         strings[stackfr] = (char *) strings + strings_size;
         strcpy(strings[stackfr], msg);/* Safe since we just allocated the room. */
         strings_size += eachlen[stackfr];
      }
   }

   if (strings) {
      /* Recalculate the offset pointers because of the reallocs. */
      strings[0] = (char *) strings + num_frames * sizeof(*strings);
      for (stackfr = 1; stackfr < num_frames; stackfr++) {
         strings[stackfr] = strings[stackfr - 1] + eachlen[stackfr - 1];
      }
   }
   ast_free(eachlen);

#else /* !defined(BETTER_BACKTRACES) */

   strings = backtrace_symbols(addresses, num_frames);
#endif /* defined(BETTER_BACKTRACES) */
   return strings;
}

void ast_callid_strnprint	(	char *	buffer,
		size_t	buffer_size,
		struct ast_callid *	callid
	)

copy a string representation of the callid into a target string

Parameters:

buffer	destination of callid string (should be able to store 13 characters or more)
buffer_size	maximum writable length of the string (Less than 13 will result in truncation)
callid	Callid for which string is being requested

Definition at line 1313 of file logger.c.

References ast_callid::call_identifier.

Referenced by ast_channel_callid_set(), handle_showchan(), and iax_pvt_callid_new().

{
   snprintf(buffer, buffer_size, "[C-%08x]", callid->call_identifier);
}

int ast_callid_threadassoc_add ( struct ast_callid * callid )

Adds a known callid to thread storage of the calling thread.

Return values:

0	- success
non-zero	- failure

Definition at line 1378 of file logger.c.

References ast_callid_ref, ast_debug, ast_log(), ast_threadstorage_get(), ast_callid::call_identifier, LOG_ERROR, LOG_WARNING, and unique_callid.

Referenced by __analog_ss_thread(), __ast_pbx_run(), ast_callid_threadstorage_auto(), async_dial(), async_wait(), bridge_call_thread(), bridge_channel_thread(), bridge_thread(), do_idle_thread(), func_pri_dchannel_chanpos_callid(), func_pri_dchannel_new_callid(), func_ss7_linkset_callid(), handle_request_do(), jingle_action_hook(), jingle_outgoing_hook(), mixmonitor_thread(), pri_ss_thread(), sig_pri_handle_hold(), and socket_process_helper().

{
   struct ast_callid **pointing;

   pointing = ast_threadstorage_get(&unique_callid, sizeof(*pointing));
   if (!(pointing)) {
      ast_log(LOG_ERROR, "Failed to allocate thread storage.\n");
      return -1;
   }

   if (!(*pointing)) {
      /* callid will be unreffed at thread destruction */
      ast_callid_ref(callid);
      *pointing = callid;
#ifdef TEST_FRAMEWORK
      ast_debug(3, "CALL_ID [C-%08x] bound to thread.\n", callid->call_identifier);
#endif
   } else {
      ast_log(LOG_WARNING, "Attempted to ast_callid_threadassoc_add on thread already associated with a callid.\n");
      return 1;
   }

   return 0;
}

int ast_callid_threadassoc_change ( struct ast_callid * callid )

Sets what is stored in the thread storage to the given callid if it does not match what is already there.

Return values:

0	- success
non-zero	- failure

Definition at line 1349 of file logger.c.

References ast_callid_ref, ast_callid_unref, ast_debug, ast_log(), ast_threadstorage_get(), ast_callid::call_identifier, LOG_ERROR, and unique_callid.

Referenced by autoservice_run().

{
   struct ast_callid **id = ast_threadstorage_get(&unique_callid, sizeof(*id));

   if (!id) {
      ast_log(LOG_ERROR, "Failed to allocate thread storage.\n");
      return -1;
   }

   if (*id && (*id != callid)) {
#ifdef TEST_FRAMEWORK
      ast_debug(3, "CALL_ID [C-%08x] being removed from thread.\n", (*id)->call_identifier);
#endif
      *id = ast_callid_unref(*id);
      *id = NULL;
   }

   if (!(*id) && callid) {
      /* callid will be unreffed at thread destruction */
      ast_callid_ref(callid);
      *id = callid;
#ifdef TEST_FRAMEWORK
      ast_debug(3, "CALL_ID [C-%08x] bound to thread.\n", callid->call_identifier);
#endif
   }

   return 0;
}

int ast_callid_threadassoc_remove ( void )

Removes callid from thread storage of the calling thread.

Return values:

0	- success
non-zero	- failure

Definition at line 1403 of file logger.c.

References ast_callid_unref, ast_debug, ast_log(), ast_threadstorage_get(), LOG_ERROR, and unique_callid.

Referenced by ast_callid_threadstorage_auto_clean(), handle_request_do(), jingle_action_hook(), jingle_outgoing_hook(), pri_dchannel(), sig_pri_handle_hold(), sig_pri_handle_hold_ack(), sig_pri_handle_hold_rej(), sig_pri_handle_retrieve(), sig_pri_handle_retrieve_ack(), sig_pri_handle_retrieve_rej(), socket_process(), and ss7_linkset().

{
   struct ast_callid **pointing;

   pointing = ast_threadstorage_get(&unique_callid, sizeof(*pointing));
   if (!(pointing)) {
      ast_log(LOG_ERROR, "Failed to allocate thread storage.\n");
      return -1;
   }

   if (!(*pointing)) {
      ast_log(LOG_ERROR, "Tried to clean callid thread storage with no callid in thread storage.\n");
      return -1;
   } else {
#ifdef TEST_FRAMEWORK
      ast_debug(3, "Call_ID [C-%08x] being removed from thread.\n", (*pointing)->call_identifier);
#endif
      *pointing = ast_callid_unref(*pointing);
      return 0;
   }
}

int ast_callid_threadstorage_auto ( struct ast_callid ** callid )

Checks thread storage for a callid and stores a reference if it exists. If not, then a new one will be created, bound to the thread, and a reference to it will be stored.

Parameters:

callid pointer to struct pointer used to store the referenced callid

Return values:

0	- callid was found
1	- callid was created
-1	- the function failed somehow (presumably memory problems)

Definition at line 1425 of file logger.c.

References ast_callid_threadassoc_add(), ast_create_callid(), and ast_read_threadstorage_callid().

Referenced by __analog_handle_event(), analog_handle_init_event(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), dahdi_handle_event(), dahdi_r2_on_call_accepted(), dahdi_r2_on_call_offered(), dahdi_request(), do_monitor(), handle_init_event(), mwi_thread(), my_new_analog_ast_channel(), my_new_pri_ast_channel(), my_new_ss7_ast_channel(), and ss7_start_call().

{
   struct ast_callid *tmp;

   /* Start by trying to see if a callid is available from thread storage */
   tmp = ast_read_threadstorage_callid();
   if (tmp) {
      *callid = tmp;
      return 0;
   }

   /* If that failed, try to create a new one and bind it. */
   tmp = ast_create_callid();
   if (tmp) {
      ast_callid_threadassoc_add(tmp);
      *callid = tmp;
      return 1;
   }

   /* If neither worked, then something must have gone wrong. */
   return -1;
}

void ast_callid_threadstorage_auto_clean	(	struct ast_callid *	callid,
		int	callid_created
	)

Use in conjunction with ast_callid_threadstorage_auto. Cleans up the references and if the callid was created by threadstorage_auto, unbinds the callid from the threadstorage.

Parameters:

callid	The callid set by ast_callid_threadstorage_auto
callid_created	The integer returned through ast_callid_threadstorage_auto

Definition at line 1448 of file logger.c.

References ast_callid_threadassoc_remove(), and ast_callid_unref.

Referenced by __analog_handle_event(), analog_handle_init_event(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), dahdi_handle_event(), dahdi_new_callid_clean(), dahdi_r2_on_call_accepted(), dahdi_r2_on_call_offered(), dahdi_request(), do_monitor(), handle_init_event(), mwi_thread(), and ss7_start_call().

{
   if (callid) {
      /* If the callid was created rather than simply grabbed from the thread storage, we need to unbind here. */
      if (callid_created == 1) {
         ast_callid_threadassoc_remove();
      }
      callid = ast_callid_unref(callid);
   }
}

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

Definition at line 493 of file logger.c.

References ast_free, and ast_malloc.

Referenced by launch_script().

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

   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);
}

struct ast_callid* ast_create_callid ( void ) [read]

factory function to create a new uniquely identifying callid.

Return values:

ast_callid struct pointer containing the call id

Note:: The newly created callid will be referenced upon creation and this function should be paired with a call to ast_callid_unref()

Definition at line 1318 of file logger.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_atomic_fetchadd_int(), ast_debug, ast_log(), ast_callid::call_identifier, and LOG_ERROR.

Referenced by __ast_pbx_run(), ast_callid_threadstorage_auto(), find_call(), func_pri_dchannel_new_callid(), iax_pvt_callid_new(), and jingle_alloc().

{
   struct ast_callid *call;

   call = ao2_alloc_options(sizeof(*call), NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
   if (!call) {
      ast_log(LOG_ERROR, "Could not allocate callid struct.\n");
      return NULL;
   }

   call->call_identifier = ast_atomic_fetchadd_int(&next_unique_callid, +1);
#ifdef TEST_FRAMEWORK
   ast_debug(3, "CALL_ID [C-%08x] created by thread.\n", call->call_identifier);
#endif
   return call;
}

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

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.

Parameters:

level	Type of log event
file	Will be provided by the AST_LOG_* macro
line	Will be provided by the AST_LOG_* macro
function	Will be provided by the AST_LOG_* macro
fmt	This is what is important. The format is the same as your favorite breed of printf. You know how that works, right? :-)

Definition at line 1563 of file logger.c.

References __ast_verbose_ap(), __LOG_VERBOSE, ast_callid_unref, ast_log_full(), and ast_read_threadstorage_callid().

{
   struct ast_callid *callid;
   va_list ap;

   callid = ast_read_threadstorage_callid();

   va_start(ap, fmt);
   if (level == __LOG_VERBOSE) {
      __ast_verbose_ap(file, line, function, 0, callid, fmt, ap);
   } else {
      ast_log_full(level, file, line, function, callid, fmt, ap);
   }
   va_end(ap);

   if (callid) {
      ast_callid_unref(callid);
   }
}

void ast_log_callid	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		struct ast_callid *	callid,
		const char *	fmt,
			...
	)

Used for sending a log message with a known call_id This is a modified logger function which is functionally identical to the above logger function, it just include a call_id argument as well. If NULL is specified here, no attempt will be made to join the log message with a call_id.

Parameters:

level	Type of log event
file	Will be provided by the AST_LOG_* macro
line	Will be provided by the AST_LOG_* macro
function	Will be provided by the AST_LOG_* macro
callid	This is the ast_callid that is associated with the log message. May be NULL.
fmt	This is what is important. The format is the same as your favorite breed of printf. You know how that works, right? :-)

Definition at line 1583 of file logger.c.

References ast_log_full().

Referenced by __ast_verbose_ap(), ast_channel_destructor(), dahdi_pri_error(), dahdi_pri_message(), and dahdi_ss7_error().

{
   va_list ap;
   va_start(ap, fmt);
   ast_log_full(level, file, line, function, callid, fmt, ap);
   va_end(ap);
}

static void ast_log_full	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		struct ast_callid *	callid,
		const char *	fmt,
		va_list	ap
	)		`[static]`

send log messages to syslog and/or the console

Definition at line 1477 of file logger.c.

References __LOG_VERBOSE, ast_callid_ref, ast_calloc_with_stringfields, ast_cond_signal, AST_DYNSTR_BUILD_FAILED, ast_get_tid(), AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_localtime(), AST_PTHREADT_NULL, AST_RWLIST_EMPTY, ast_str_buffer(), ast_str_set_va(), ast_str_thread_get(), ast_strftime(), ast_string_field_set, ast_tvnow(), logmsg::callid, close_logger_thread, logmsg::level, levels, logmsg::line, logchannel::list, log_buf, LOG_BUF_INIT_SIZE, logcond, logger_print_normal(), logmsg_free(), LOGMSG_NORMAL, LOGMSG_VERBOSE, logthread, logmsg::lwp, term_filter_escapes(), and logmsg::type.

Referenced by ast_log(), and ast_log_callid().

{
   struct logmsg *logmsg = NULL;
   struct ast_str *buf = NULL;
   struct ast_tm tm;
   struct timeval now = ast_tvnow();
   int res = 0;
   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;
      result = ast_str_set_va(&buf, BUFSIZ, fmt, ap); /* XXX BUFSIZ ? */
      if (result != AST_DYNSTR_BUILD_FAILED) {
         term_filter_escapes(ast_str_buffer(buf));
         fputs(ast_str_buffer(buf), stdout);
      }
      return;
   }

   /* Ignore anything that never gets logged anywhere */
   if (level != __LOG_VERBOSE && !(global_logmask & (1 << level)))
      return;

   /* Build string */
   res = ast_str_set_va(&buf, BUFSIZ, fmt, 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;
   }

   if (display_callids && callid) {
      logmsg->callid = ast_callid_ref(callid);
      /* callid will be unreffed at logmsg destruction */
   }

   /* 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->lwp = ast_get_tid();

   /* 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);
      if (close_logger_thread) {
         /* Logger is either closing or closed.  We cannot log this message. */
         logmsg_free(logmsg);
      } else {
         AST_LIST_INSERT_TAIL(&logmsgs, logmsg, list);
         ast_cond_signal(&logcond);
      }
      AST_LIST_UNLOCK(&logmsgs);
   } else {
      logger_print_normal(logmsg);
      logmsg_free(logmsg);
   }
}

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

Definition at line 1022 of file logger.c.

References ast_syslog_priority_from_loglevel(), ast_callid::call_identifier, logmsg::callid, logmsg::file, logmsg::function, logmsg::level, levels, logmsg::line, logmsg::lwp, logmsg::message, and term_strip().

Referenced by logger_print_normal().

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

   if (msg->callid) {
      snprintf(call_identifier_str, sizeof(call_identifier_str), "[C-%08x]", msg->callid->call_identifier);
   } else {
      call_identifier_str[0] = '\0';
   }

   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[%d]%s: %s:%d in %s: %s",
       levels[msg->level], msg->lwp, call_identifier_str, 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 2106 of file logger.c.

References ARRAY_LEN, ast_debug, ast_log(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strdup, available(), levels, LOG_WARNING, 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 2149 of file logger.c.

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

Referenced by cc_shutdown(), load_module(), and unload_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);

      ast_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 537 of file logger.c.

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

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

{
   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);
   }
}

struct ast_callid* ast_read_threadstorage_callid ( void ) [read]

extracts the callerid from the thread

Return values:

ast_callid	reference to call_id related to the thread
NULL	if no call_id is present in the thread

This reference must be unreffed before it loses scope to prevent memory leaks.

Definition at line 1335 of file logger.c.

References ast_callid_ref, ast_threadstorage_get(), and unique_callid.

Referenced by __ast_pbx_run(), __ast_verbose(), agent_request(), ast_bridge_impart(), ast_callid_threadstorage_auto(), ast_dial_run(), ast_log(), ast_verbose(), bridge_call_thread_launch(), bridge_channel_join(), iax2_request(), jingle_alloc(), launch_monitor_thread(), local_request(), parked_call_exec(), sip_request_call(), and socket_process().

{
   struct ast_callid **callid;

   callid = ast_threadstorage_get(&unique_callid, sizeof(*callid));
   if (callid && *callid) {
      ast_callid_ref(*callid);
      return *callid;
   }

   return NULL;

}

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

Definition at line 2056 of file logger.c.

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

Referenced by ast_makesocket(), and print_intro_message().

{
   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 2072 of file logger.c.

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

{
   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;
}

int ast_verb_console_get ( void )

Get this thread's console verbosity level.

Return values:

verbosity level of the console.

Definition at line 2019 of file logger.c.

References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_threadstorage_get(), verb_console::level, my_verb_console, and option_verbose.

Referenced by handle_show_settings(), handle_verbose(), and remoteconsolehandler().

{
   struct verb_console *console;
   int verb_level;

   console = ast_threadstorage_get(&my_verb_console, sizeof(*console));
   AST_RWLIST_RDLOCK(&verb_consoles);
   if (!console) {
      verb_level = 0;
   } else if (console->level) {
      verb_level = *console->level;
   } else {
      verb_level = option_verbose;
   }
   AST_RWLIST_UNLOCK(&verb_consoles);
   return verb_level;
}

void ast_verb_console_register ( int * level )

Register this thread's console verbosity level pointer.

Parameters:

level Where the verbose level value is.

Returns:: Nothing

Definition at line 1992 of file logger.c.

References AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_threadstorage_get(), ast_verb_update(), verb_console::level, my_verb_console, and verb_console::node.

Referenced by netconsole().

{
   struct verb_console *console;

   console = ast_threadstorage_get(&my_verb_console, sizeof(*console));
   if (!console || !level) {
      return;
   }
   console->level = level;

   AST_RWLIST_WRLOCK(&verb_consoles);
   AST_RWLIST_INSERT_HEAD(&verb_consoles, console, node);
   AST_RWLIST_UNLOCK(&verb_consoles);
   ast_verb_update();
}

void ast_verb_console_set ( int verb_level )

Set this thread's console verbosity level.

Parameters:

verb_level New level to set.

Returns:: Nothing

Definition at line 2037 of file logger.c.

References AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_threadstorage_get(), ast_verb_update(), verb_console::level, my_verb_console, and option_verbose.

Referenced by handle_verbose(), and remoteconsolehandler().

{
   struct verb_console *console;

   console = ast_threadstorage_get(&my_verb_console, sizeof(*console));
   if (!console) {
      return;
   }

   AST_RWLIST_WRLOCK(&verb_consoles);
   if (console->level) {
      *console->level = verb_level;
   } else {
      option_verbose = verb_level;
   }
   AST_RWLIST_UNLOCK(&verb_consoles);
   ast_verb_update();
}

void ast_verb_console_unregister ( void )

Unregister this thread's console verbosity level.

Returns:: Nothing

Definition at line 2008 of file logger.c.

References ast_threadstorage_get(), my_verb_console, and verb_console_unregister().

Referenced by netconsole().

{
   struct verb_console *console;

   console = ast_threadstorage_get(&my_verb_console, sizeof(*console));
   if (!console) {
      return;
   }
   verb_console_unregister(console);
}

void ast_verb_update ( void )

Re-evaluate the system max verbosity level (ast_verb_sys_level).

Returns:: Nothing

Definition at line 1928 of file logger.c.

References AST_LIST_TRAVERSE, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_verb_sys_level, verb_console::level, logchannel::list, option_verbose, and logchannel::verbosity.

Referenced by ast_verb_console_register(), ast_verb_console_set(), init_logger(), reload_logger(), and verb_console_unregister().

{
   struct logchannel *log;
   struct verb_console *console;
   int verb_level;

   ast_mutex_lock(&verb_update_lock);

   AST_RWLIST_RDLOCK(&verb_consoles);

   /* Default to the root console verbosity. */
   verb_level = option_verbose;

   /* Determine max remote console level. */
   AST_LIST_TRAVERSE(&verb_consoles, console, node) {
      if (verb_level < *console->level) {
         verb_level = *console->level;
      }
   }
   AST_RWLIST_UNLOCK(&verb_consoles);

   /* Determine max logger channel level. */
   AST_RWLIST_RDLOCK(&logchannels);
   AST_RWLIST_TRAVERSE(&logchannels, log, list) {
      if (verb_level < log->verbosity) {
         verb_level = log->verbosity;
      }
   }
   AST_RWLIST_UNLOCK(&logchannels);

   ast_verb_sys_level = verb_level;

   ast_mutex_unlock(&verb_update_lock);
}

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

Definition at line 1898 of file logger.c.

References __ast_verbose_ap(), ast_callid_unref, and ast_read_threadstorage_callid().

Referenced by __agent_start_monitoring(), __ast_str_helper(), __sip_destroy(), acl_change_event_cb(), add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), add_tcodec_to_sdp(), add_vcodec_to_sdp(), aji_handle_presence(), aji_log_hook(), aji_receive_node_list(), alsa_answer(), alsa_call(), alsa_digit(), alsa_hangup(), alsa_indicate(), alsa_text(), ao2_bt(), ast_agi_send(), ast_module_reload(), ast_readconfig(), ast_remotecontrol(), ast_rtcp_read(), ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_continuation(), ast_rtp_dtmf_end_with_duration(), ast_rtp_raw_write(), ast_rtp_read(), ast_rtp_sendcng(), ast_stun_handle_packet(), astman_append(), bridge_p2p_rtp_write(), can_safely_quit(), chan_misdn_log(), check_peer_ok(), check_via(), conf_run(), console_answer(), dahdi_r2_on_billing_pulse_received(), dahdi_r2_on_call_accepted(), dahdi_r2_on_call_answered(), dahdi_r2_on_call_disconnect(), dahdi_r2_on_call_end(), dahdi_r2_on_call_init(), dahdi_r2_on_call_offered(), dahdi_r2_write_log(), dahdi_softhangup_all(), do_register_auth(), dundi_debug_output(), find_gtalk(), get_also_info(), get_destination(), get_rdnis(), get_refer_info(), gtalk_handle_dtmf(), h323_reload(), handle_cli_misdn_send_facility(), handle_incoming(), handle_request_do(), handle_request_info(), handle_request_invite(), handle_request_message(), handle_request_refer(), handle_request_subscribe(), handle_response(), handle_transfer_button(), hook_event_cb(), iax_debug_output(), initialize_initreq(), ivr_demo_func(), jb_debug_output(), jingle_handle_dtmf(), list_route(), load_module(), mgcp_reload(), oss_answer(), oss_call(), oss_digit_end(), oss_hangup(), oss_indicate(), oss_text(), phone_check_exception(), phone_exception(), pri_dchannel(), print_frame(), print_intro_message(), process_dtmf_rfc2833(), process_sdp(), process_sdp_a_audio(), process_sdp_a_text(), process_sdp_a_video(), receive_message(), retrans_pkt(), run_agi(), send_request(), send_response(), set_destination(), sip_auth_headers(), sip_reload(), sip_scheddestroy(), sip_sendtext(), ss7_linkset(), ss7_reset_linkset(), stun_process_attr(), timing_read(), transmit_register(), xmpp_log_hook(), and xmpp_pubsub_receive_node_list().

{
   struct ast_callid *callid;
   va_list ap;

   callid = ast_read_threadstorage_callid();

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

   if (callid) {
      ast_callid_unref(callid);
   }
}

void close_logger ( void )

Provided by logger.c

Definition at line 1269 of file logger.c.

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_cond_signal, ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, AST_PTHREADT_NULL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, cli_logger, close_logger_thread, f, logchannel::fileptr, logchannel::list, logcond, logthread, and qlog.

Referenced by really_quit().

{
   struct logchannel *f = NULL;
   struct verb *cur = NULL;

   ast_cli_unregister_multiple(cli_logger, ARRAY_LEN(cli_logger));

   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(&verbosers);
   while ((cur = AST_LIST_REMOVE_HEAD(&verbosers, list))) {
      ast_free(cur);
   }
   AST_RWLIST_UNLOCK(&verbosers);

   AST_RWLIST_WRLOCK(&logchannels);

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

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

   closelog(); /* syslog */

   AST_RWLIST_UNLOCK(&logchannels);
}

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

Definition at line 878 of file logger.c.

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

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger reload";
      e->usage =
         "Usage: logger reload [<alt-conf>]\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, a->argc == 3 ? a->argv[2] : NULL)) {
      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 897 of file logger.c.

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

{
   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, NULL)) {
      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 916 of file logger.c.

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

{
   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 959 of file logger.c.

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

{
#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 1235 of file logger.c.

References ARRAY_LEN, ast_cli_register_multiple(), ast_cond_destroy, ast_cond_init, ast_config_AST_LOG_DIR, ast_mkdir(), ast_mutex_destroy, ast_mutex_init, ast_pthread_create, ast_verb_update(), cli_logger, handle_SIGXFSZ, init_logger_chain(), logmsgs::lock, logcond, logger_thread(), and logthread.

Referenced by main().

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

   /* Re-initialize the logmsgs mutex.  The recursive mutex can be accessed prior
    * to Asterisk being forked into the background, which can cause the thread
    * ID tracked by the underlying pthread mutex to be different than the ID of
    * the thread that unlocks the mutex.  Since init_logger is called after the
    * fork, it is safe to initialize the mutex here for future accesses.
    */
   ast_mutex_destroy(&logmsgs.lock);
   ast_mutex_init(&logmsgs.lock);
   ast_cond_init(&logcond, NULL);

   /* start logger thread */
   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 */, NULL);
   ast_verb_update();
   logger_initialized = 1;

   return 0;
}

static void init_logger_chain	(	int	locked,
		const char *	altconf
	)		`[static]`

Definition at line 365 of file logger.c.

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

Referenced by init_logger(), and reload_logger().

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

   display_callids = 1;

   if (!(cfg = ast_config_load2(S_OR(altconf, "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", "display_callids"))) {
      display_callids = ast_true(s);
   }
   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 1048 of file logger.c.

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

Referenced by ast_log_full(), and logger_thread().

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

   if (logmsg->level == __LOG_VERBOSE) {
      char *tmpmsg = ast_strdupa(logmsg->message + 1);

      level = VERBOSE_MAGIC2LEVEL(logmsg->message);

      /* 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) {
         char call_identifier_str[13];

         if (logmsg->callid) {
            snprintf(call_identifier_str, sizeof(call_identifier_str), "[C-%08x]", logmsg->callid->call_identifier);
         } else {
            call_identifier_str[0] = '\0';
         }


         /* If the channel is disabled, then move on to the next one */
         if (chan->disabled) {
            continue;
         }
         if (logmsg->level == __LOG_VERBOSE
            && (((chan->verbosity < 0) ? option_verbose : chan->verbosity)) < level) {
            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[%d]%s: %s:%s %s: %s",
                logmsg->date,
                term_color(tmp1, logmsg->level_name, colors[logmsg->level], 0, sizeof(tmp1)),
                logmsg->lwp,
                call_identifier_str,
                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[%d]%s %s: %s",
                     logmsg->date, logmsg->level_name, logmsg->lwp, call_identifier_str,
                     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));
               /*** DOCUMENTATION
                  <managerEventInstance>
                     <synopsis>Raised when a logging channel is disabled.</synopsis>
                     <syntax>
                        <parameter name="Channel">
                           <para>The name of the logging channel.</para>
                        </parameter>
                     </syntax>
                  </managerEventInstance>
               ***/
               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, NULL);
      ast_verb(1, "Rotated Logs Per SIGXFSZ (Exceeded file size limit)\n");
   }

   return;
}

static void logger_queue_init ( void ) [static]

Definition at line 1211 of file logger.c.

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

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 765 of file logger.c.

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

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 730 of file logger.c.

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

Referenced by logger_queue_init(), and logger_queue_restart().

{
   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 870 of file logger.c.

References reload_logger(), RESULT_FAILURE, and RESULT_SUCCESS.

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

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

Actual logging thread.

Definition at line 1168 of file logger.c.

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

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) {
            AST_LIST_UNLOCK(&logmsgs);
            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 */
         logmsg_free(msg);
      }
   }

   return NULL;
}

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

Definition at line 160 of file logger.c.

References ast_callid_unref, and ast_free.

Referenced by ast_log_full(), and logger_thread().

{
   if (msg->callid) {
      ast_callid_unref(msg->callid);
   }
   ast_free(msg);
}

static void make_components ( struct logchannel * chan ) [static]

Definition at line 240 of file logger.c.

References __LOG_VERBOSE, ARRAY_LEN, ast_strip(), ast_strlen_zero(), logchannel::components, levels, logchannel::logmask, LOGTYPE_CONSOLE, logchannel::type, and logchannel::verbosity.

Referenced by make_logchannel(), and update_logchannels().

{
   char *w;
   unsigned int logmask = 0;
   char *stringp = ast_strdupa(chan->components);
   unsigned int x;
   int verb_level;

   /* Default to using option_verbose as the verbosity level of the logging channel.  */
   verb_level = -1;

   while ((w = strsep(&stringp, ","))) {
      w = ast_strip(w);
      if (ast_strlen_zero(w)) {
         continue;
      }
      if (!strcmp(w, "*")) {
         logmask = 0xFFFFFFFF;
      } else if (!strncasecmp(w, "verbose(", 8)) {
         if (levels[__LOG_VERBOSE] && sscanf(w + 8, "%30u)", &verb_level) == 1) {
            logmask |= (1 << __LOG_VERBOSE);
         }
      } else {
         for (x = 0; x < ARRAY_LEN(levels); ++x) {
            if (levels[x] && !strcasecmp(w, levels[x])) {
               logmask |= (1 << x);
               break;
            }
         }
      }
   }
   if (chan->type == LOGTYPE_CONSOLE) {
      /*
       * Force to use the root console verbose level so if the
       * user specified any verbose level then it does not interfere
       * with calculating the ast_verb_sys_level value.
       */
      chan->verbosity = -1;
   } else {
      chan->verbosity = verb_level;
   }
   chan->logmask = logmask;
}

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

Definition at line 284 of file logger.c.

References __LOG_ERROR, ast_build_date, ast_build_hostname, ast_build_machine, ast_build_os, ast_build_user, ast_calloc, ast_config_AST_LOG_DIR, ast_console_puts_mutable(), ast_copy_string(), ast_free, ast_get_version(), ast_localtime(), ast_strftime(), ast_strlen_zero(), ast_syslog_facility(), ast_tvnow(), logchannel::components, errno, logchannel::facility, logchannel::filename, logchannel::fileptr, logchannel::lineno, LOGTYPE_CONSOLE, LOGTYPE_FILE, LOGTYPE_SYSLOG, make_components(), and logchannel::type.

Referenced by init_logger_chain().

{
   struct logchannel *chan;
   char *facility;
   struct ast_tm tm;
   struct timeval now = ast_tvnow();
   char datestring[256];

   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 {
      const char *log_dir_prefix = "";
      const char *log_dir_separator = "";

      if (channel[0] != '/') {
         log_dir_prefix = ast_config_AST_LOG_DIR;
         log_dir_separator = "/";
      }

      if (!ast_strlen_zero(hostname)) {
         snprintf(chan->filename, sizeof(chan->filename), "%s%s%s.%s",
            log_dir_prefix, log_dir_separator, channel, hostname);
      } else {
         snprintf(chan->filename, sizeof(chan->filename), "%s%s%s",
            log_dir_prefix, log_dir_separator, 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;
      } else {
         /* Create our date/time */
         ast_localtime(&now, &tm, NULL);
         ast_strftime(datestring, sizeof(datestring), dateformat, &tm);

         fprintf(chan->fileptr, "[%s] Asterisk %s built by %s @ %s on a %s running %s on %s\n",
            datestring, ast_get_version(), ast_build_user, ast_build_hostname,
            ast_build_machine, ast_build_os, ast_build_date);
         fflush(chan->fileptr);
      }
      chan->type = LOGTYPE_FILE;
   }
   make_components(chan);

   return chan;
}

static int reload_logger	(	int	rotate,
		const char *	altconf
	)		`[static]`

Definition at line 793 of file logger.c.

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

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

{
   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 */
         /*** DOCUMENTATION
            <managerEventInstance>
               <synopsis>Raised when a logging channel is re-enabled after a reload operation.</synopsis>
               <syntax>
                  <parameter name="Channel">
                     <para>The name of the logging channel.</para>
                  </parameter>
               </syntax>
            </managerEventInstance>
         ***/
         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 */, altconf);

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

   return res;
}

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

Definition at line 629 of file logger.c.

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

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 (c) {
         c = ast_channel_unref(c);
      }
      if (ast_safe_system(buf) == -1) {
         ast_log(LOG_WARNING, "error executing '%s'\n", buf);
      }
   }
   return res;
}

static void unique_callid_cleanup ( void * data ) [static]

Definition at line 1463 of file logger.c.

References ast_callid_unref, and ast_free.

{
   struct ast_callid **callid = data;

   if (*callid) {
      ast_callid_unref(*callid);
   }

   ast_free(data);
}

static void update_logchannels ( void ) [static]

Definition at line 2090 of file logger.c.

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

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) {
      make_components(cur);
      global_logmask |= cur->logmask;
   }

   AST_RWLIST_UNLOCK(&logchannels);
}

static void verb_console_free ( void * v_console ) [static]

Definition at line 1981 of file logger.c.

References ast_free, and verb_console_unregister().

{
   struct verb_console *console = v_console;

   verb_console_unregister(console);
   ast_free(console);
}

static void verb_console_unregister ( struct verb_console * console ) [static]

Definition at line 1971 of file logger.c.

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb_update(), and verb_console::node.

Referenced by ast_verb_console_unregister(), and verb_console_free().

{
   AST_RWLIST_WRLOCK(&verb_consoles);
   console = AST_RWLIST_REMOVE(&verb_consoles, console, node);
   AST_RWLIST_UNLOCK(&verb_consoles);
   if (console) {
      ast_verb_update();
   }
}

Variable Documentation

struct ast_cli_entry cli_logger[] [static]

Definition at line 1004 of file logger.c.

Referenced by close_logger(), and init_logger().

int close_logger_thread = 0 [static]

Definition at line 171 of file logger.c.

Referenced by ast_log_full(), close_logger(), and logger_thread().

const int colors[NUMLOGLEVELS] [static]

Colors used in the console for logging.

Definition at line 197 of file logger.c.

Referenced by logger_print_normal().

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

Definition at line 75 of file logger.c.

Referenced by build_device().

int display_callids [static]

Definition at line 85 of file logger.c.

char exec_after_rotate[256] = "" [static]

Definition at line 78 of file logger.c.

int filesize_reload_needed [static]

Definition at line 80 of file logger.c.

unsigned int global_logmask = 0xFFFF [static]

Definition at line 81 of file logger.c.

struct sigaction handle_SIGXFSZ [static]

Initial value:

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

Definition at line 1017 of file logger.c.

Referenced by init_logger().

char hostname[MAXHOSTNAMELEN] [static]

Definition at line 106 of file logger.c.

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

char* levels[NUMLOGLEVELS] [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 186 of file logger.c.

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