logger.c File Reference

Asterisk Logger. More...

#include "asterisk.h"
#include <syslog.h>
#include <signal.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "asterisk/_private.h"
#include "asterisk/module.h"
#include "asterisk/paths.h"
#include "asterisk/logger.h"
#include "asterisk/logger_category.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 "asterisk/backtrace.h"
#include "asterisk/json.h"

Include dependency graph for logger.c:

Go to the source code of this file.

Data Structures
struct	logchannel
struct	logchannels
struct	logformatter
struct	logmsg
struct	logmsgs
struct	verb_console
struct	verb_consoles

Macros
#define	FORMATL   "%-35.35s %-8.8s %-10.10s %-9.9s "
#define	LOG_BUF_INIT_SIZE   256
#define	LOTS_O_SPACES   " "
#define	VERBOSE_BUF_INIT_SIZE   256

Enumerations
enum	logmsgtypes { LOGMSG_NORMAL = 0, LOGMSG_VERBOSE }
enum	logtypes { LOGTYPE_SYSLOG, LOGTYPE_FILE, LOGTYPE_CONSOLE }
enum	rotatestrategy { NONE = 0, SEQUENTIAL = 1 << 0, ROTATE = 1 << 1, TIMESTAMP = 1 << 2 }

Functions
void	__ast_trace (const char *file, int line, const char *func, enum ast_trace_indent_type indent_type, unsigned long new_indent, const char *format,...)
void	__ast_verbose (const char *file, int line, const char *func, int level, const char *fmt,...)
	Send a verbose message (based on verbose level) More...
void	__ast_verbose_ap (const char *file, int line, const char *func, int level, ast_callid callid, const char *fmt, va_list ap)
void	__ast_verbose_callid (const char *file, int line, const char *func, int level, ast_callid callid, const char *fmt,...)
	Send a verbose message (based on verbose level) with deliberately specified callid. More...
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	__init_verbose_build_buf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
unsigned long	_ast_trace_dec_indent (void)
	Decrement the indent level. More...
unsigned long	_ast_trace_get_indent (void)
	Get the current indent level. More...
unsigned long	_ast_trace_inc_indent (void)
	Increment the indent level. More...
void	_ast_trace_set_indent (unsigned long indent)
	Set the current indent level. More...
static void	_handle_SIGXFSZ (int sig)
void	ast_callid_strnprint (char *buffer, size_t buffer_size, ast_callid callid)
	copy a string representation of the callid into a target string More...
int	ast_callid_threadassoc_add (ast_callid callid)
	Adds a known callid to thread storage of the calling thread. More...
int	ast_callid_threadassoc_change (ast_callid callid)
	Sets what is stored in the thread storage to the given callid if it does not match what is already there. More...
int	ast_callid_threadassoc_remove (void)
	Removes callid from thread storage of the calling thread. More...
int	ast_callid_threadstorage_auto (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. More...
void	ast_callid_threadstorage_auto_clean (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. More...
void	ast_child_verbose (int level, const char *fmt,...)
ast_callid	ast_create_callid (void)
	factory function to create a new uniquely identifying callid. More...
int	ast_dynamic_logger_level (const char *name)
	Checks if a dynamic logger level exists. More...
void	ast_init_logger_for_socket_console (void)
	load logger.conf configuration for console socket connections More...
int	ast_is_logger_initialized (void)
	Test if logger is initialized. More...
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. More...
void	ast_log_ap (int level, const char *file, int line, const char *function, const char *fmt, va_list ap)
void	ast_log_backtrace (void)
	Log a backtrace of the current thread's execution stack to the Asterisk log. More...
void	ast_log_callid (int level, const char *file, int line, const char *function, 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. More...
static void	ast_log_full (int level, int sublevel, const char *file, int line, const char *function, ast_callid callid, const char *fmt, va_list ap)
	send log messages to syslog and/or the console More...
void	ast_log_safe (int level, const char *file, int line, const char *function, const char *fmt,...)
	Used for sending a log message with protection against recursion. More...
int	ast_logger_create_channel (const char *log_channel, const char *components)
	Create a log channel. More...
int	ast_logger_get_channels (int(*logentry)(const char *channel, const char *type, const char *status, const char *configuration, void *data), void *data)
	Retrieve the existing log channels. More...
const char *	ast_logger_get_dateformat (void)
	Get the logger configured date format. More...
int	ast_logger_get_queue_limit (void)
	Get the maximum number of messages allowed in the processing queue. More...
int	ast_logger_register_level (const char *name)
	Register a new logger level. More...
int	ast_logger_remove_channel (const char *log_channel)
	Delete the specified log channel. More...
int	ast_logger_rotate ()
	Reload logger while rotating log files. More...
int	ast_logger_rotate_channel (const char *log_channel)
	Rotate the specified log channel. More...
void	ast_logger_set_queue_limit (int queue_limit)
	Set the maximum number of messages allowed in the processing queue. More...
void	ast_logger_unregister_level (const char *name)
	Unregister a previously registered logger level. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
void	ast_queue_log (const char *queuename, const char *callid, const char *agent, const char *event, const char *fmt,...)
ast_callid	ast_read_threadstorage_callid (void)
	extracts the callerid from the thread More...
	AST_THREADSTORAGE_RAW (in_safe_log)
	AST_THREADSTORAGE_RAW (trace_indent)
int	ast_verb_console_get (void)
	Get this thread's console verbosity level. More...
void	ast_verb_console_register (int *level)
	Register this thread's console verbosity level pointer. More...
void	ast_verb_console_set (int verb_level)
	Set this thread's console verbosity level. More...
void	ast_verb_console_unregister (void)
	Unregister this thread's console verbosity level. More...
void	ast_verb_update (void)
	Re-evaluate the system max verbosity level (ast_verb_sys_level). More...
void	close_logger (void)
static struct logchannel *	find_logchannel (const char *channel)
	Find a particular logger channel by name. More...
static int	format_log_default (struct logchannel *chan, struct logmsg *msg, char *buf, size_t size)
static int	format_log_json (struct logchannel *channel, struct logmsg *msg, char *buf, size_t size)
static struct logmsg *	format_log_message (int level, int sublevel, const char *file, int line, const char *function, ast_callid callid, const char *fmt,...)
static struct logmsg *	format_log_message_ap (int level, int sublevel, const char *file, int line, const char *function, ast_callid callid, const char *fmt, va_list ap)
static int	format_log_plain (struct logchannel *chan, struct logmsg *msg, char *buf, size_t size)
static char *	handle_logger_add_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_remove_channel (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. More...
int	init_logger (void)
static int	init_logger_chain (const char *altconf)
	Read config, setup channels. More...
static int	load_module (void)
static int	logger_add_verbose_magic (struct logmsg *logmsg, char *buf, size_t size)
static void	logger_print_normal (struct logmsg *logmsg)
	Print a normal log message to the channels. More...
static void	logger_queue_init (void)
static int	logger_queue_restart (int queue_rotate)
static int	logger_queue_rt_start (void)
void	logger_queue_start (void)
	Start the ast_queue_log() logger. More...
static int	logger_register_level (const char *name)
static void *	logger_thread (void *data)
	Actual logging thread. More...
static void	logmsg_free (struct logmsg *msg)
static void	make_components (struct logchannel *chan)
static void	make_filename (const char *channel, char *filename, size_t size)
	create the filename that will be used for a logger channel. More...
static struct logchannel *	make_logchannel (const char *channel, const char *components, int lineno, int dynamic)
static int	reload_logger (int rotate, const char *altconf)
static int	reload_module (void)
static int	rotate_file (const char *filename)
static int	unload_module (void)
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_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Logger" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = 0, }
static const struct ast_module_info *	ast_module_info = &__mod_info
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. More...
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 unsigned int	high_water_alert
static char	hostname [MAXHOSTNAMELEN]
static char *	levels [NUMLOGLEVELS]
	Logging channels used in the Asterisk logging system. More...
static struct ast_threadstorage	log_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_log_buf , .custom_init = NULL , }
static struct logchannels	logchannels = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static ast_cond_t	logcond
struct {
unsigned int   queue_adaptive_realtime:1
unsigned int   queue_log:1
unsigned int   queue_log_realtime_use_gmt:1
unsigned int   queue_log_to_file:1
}	logfiles = { 1 }
static struct logformatter	logformatter_default
static struct logformatter	logformatter_json
static struct logformatter	logformatter_plain
static int	logger_initialized
static int	logger_messages_discarded
static int	logger_queue_limit = 1000
static int	logger_queue_size
static struct logmsgs	logmsgs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
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 = 1
static FILE *	qlog
static char	queue_log_name [256] = QUEUELOG
static int	queuelog_init
static enum rotatestrategy	rotatestrategy = SEQUENTIAL
static struct ast_threadstorage	unique_callid = { .once = PTHREAD_ONCE_INIT , .key_init = __init_unique_callid , .custom_init = NULL , }
static struct verb_consoles	verb_consoles = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static ast_mutex_t	verb_update_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static struct ast_threadstorage	verbose_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_verbose_buf , .custom_init = NULL , }
static struct ast_threadstorage	verbose_build_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_verbose_build_buf , .custom_init = NULL , }

Detailed Description

Asterisk Logger.

Logging routines

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file logger.c.

Macro Definition Documentation

FORMATL

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

Referenced by handle_logger_show_channels().

LOG_BUF_INIT_SIZE

#define LOG_BUF_INIT_SIZE   256

Definition at line 257 of file logger.c.

Referenced by format_log_message_ap().

LOTS_O_SPACES

#define LOTS_O_SPACES   " "

Definition at line 2375 of file logger.c.

Referenced by __ast_trace().

VERBOSE_BUF_INIT_SIZE

#define VERBOSE_BUF_INIT_SIZE   256

Definition at line 254 of file logger.c.

Referenced by logger_add_verbose_magic().

Enumeration Type Documentation

logmsgtypes

enum logmsgtypes

Enumerator
LOGMSG_NORMAL
LOGMSG_VERBOSE

Definition at line 160 of file logger.c.

                 {
   LOGMSG_NORMAL = 0,
   LOGMSG_VERBOSE,
};

logtypes

enum logtypes

Enumerator
LOGTYPE_SYSLOG
LOGTYPE_FILE
LOGTYPE_CONSOLE

Definition at line 125 of file logger.c.

              {
   LOGTYPE_SYSLOG,
   LOGTYPE_FILE,
   LOGTYPE_CONSOLE,
};

rotatestrategy

enum rotatestrategy

Enumerator
NONE
SEQUENTIAL
ROTATE
TIMESTAMP

Definition at line 98 of file logger.c.

                           {
   NONE = 0,                /* Do not rotate log files at all, instead rely on external mechanisms */
   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

__ast_trace()

void __ast_trace	(	const char *	file,
		int	line,
		const char *	func,
		enum ast_trace_indent_type	indent_type,
		unsigned long	new_indent,
		const char *	format,
			...
	)

Definition at line 2405 of file logger.c.

References __LOG_TRACE, ast_free, ast_log_full(), ast_skip_blanks(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_threadstorage_get_ptr(), ast_threadstorage_set_ptr(), AST_TRACE_INDENT_DEC_AFTER, AST_TRACE_INDENT_DEC_BEFORE, AST_TRACE_INDENT_INC_AFTER, AST_TRACE_INDENT_INC_BEFORE, AST_TRACE_INDENT_NONE, AST_TRACE_INDENT_PROVIDED, AST_TRACE_INDENT_SAME, LOTS_O_SPACES, NULL, and S_OR.

{
   va_list ap;
   unsigned long indent = (unsigned long)ast_threadstorage_get_ptr(&trace_indent);
   struct ast_str *fmt = ast_str_create(128);
   const char *direction = "";

   if (!fmt) {
      return;
   }

   if (indent_type == AST_TRACE_INDENT_PROVIDED) {
      indent = new_indent;
      ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
   } else if (indent_type == AST_TRACE_INDENT_INC_BEFORE) {
      indent++;
      ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
   } else if (indent_type == AST_TRACE_INDENT_DEC_BEFORE) {
      indent--;
      ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
   }

   switch(indent_type) {
   case AST_TRACE_INDENT_NONE:
   case AST_TRACE_INDENT_SAME:
      direction = "";
      break;
   case AST_TRACE_INDENT_INC_BEFORE:
   case AST_TRACE_INDENT_INC_AFTER:
   case AST_TRACE_INDENT_PROVIDED:
      direction = "--> ";
      break;
   case AST_TRACE_INDENT_DEC_BEFORE:
   case AST_TRACE_INDENT_DEC_AFTER:
      direction = "<-- ";
      break;
   }

   ast_str_set(&fmt, 0, "%2d %-.*s%s%s:%d %s: %s", (int)indent, (indent_type == AST_TRACE_INDENT_NONE ? 0 : (int)(indent * 4)),
      LOTS_O_SPACES, direction, file, line, func, S_OR(ast_skip_blanks(format), "\n"));

   if (indent_type == AST_TRACE_INDENT_INC_AFTER || indent_type == AST_TRACE_INDENT_PROVIDED) {
      indent++;
      ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
   }
   if (indent_type == AST_TRACE_INDENT_DEC_AFTER) {
      indent--;
      ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
   }

   va_start(ap, format);
   ast_log_full(__LOG_TRACE, -1, NULL, 0, NULL, 0, ast_str_buffer(fmt), ap);
   va_end(ap);
   ast_free(fmt);
}

__ast_verbose()

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

References __ast_verbose_ap(), and ast_read_threadstorage_callid().

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

__ast_verbose_ap()

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

Definition at line 2193 of file logger.c.

References __LOG_VERBOSE, and ast_log_full().

Referenced by __ast_verbose(), __ast_verbose_callid(), and ast_log_ap().

{
   ast_log_full(__LOG_VERBOSE, level, file, line, func, callid, fmt, ap);
}

__ast_verbose_callid()

void __ast_verbose_callid	(	const char *	file,
		int	line,
		const char *	func,
		int	level,
		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 2210 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);
}

__init_log_buf()

static void __init_log_buf ( void  )

static

Definition at line 256 of file logger.c.

{

__init_my_verb_console()

static void __init_my_verb_console ( void  )

static

Thread specific console verbosity level node.

Definition at line 2294 of file logger.c.

{

__init_unique_callid()

static void __init_unique_callid ( void  )

static

Definition at line 91 of file logger.c.

{

__init_verbose_buf()

static void __init_verbose_buf ( void  )

static

Definition at line 252 of file logger.c.

{

__init_verbose_build_buf()

static void __init_verbose_build_buf ( void  )

static

Definition at line 253 of file logger.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2615 of file logger.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2615 of file logger.c.

_ast_trace_dec_indent()

unsigned long _ast_trace_dec_indent

(

void

)

Decrement the indent level.

Returns

The new indent level

Definition at line 2396 of file logger.c.

References ast_threadstorage_get_ptr(), and ast_threadstorage_set_ptr().

{
   unsigned long indent = (unsigned long)ast_threadstorage_get_ptr(&trace_indent);
   indent--;
   ast_threadstorage_set_ptr(&trace_indent, (void*)indent);

   return indent;
}

_ast_trace_get_indent()

unsigned long _ast_trace_get_indent

(

void

)

Get the current indent level.

Returns

The current indent level

Definition at line 2377 of file logger.c.

References ast_threadstorage_get_ptr().

{
   return (unsigned long)ast_threadstorage_get_ptr(&trace_indent);
}

_ast_trace_inc_indent()

unsigned long _ast_trace_inc_indent

(

void

)

Increment the indent level.

Returns

The new indent level

Definition at line 2387 of file logger.c.

References ast_threadstorage_get_ptr(), and ast_threadstorage_set_ptr().

{
   unsigned long indent = (unsigned long)ast_threadstorage_get_ptr(&trace_indent);
   indent++;
   ast_threadstorage_set_ptr(&trace_indent, (void*)indent);

   return indent;
}

_ast_trace_set_indent()

void _ast_trace_set_indent

(

unsigned long

indent

)

Set the current indent level.

Parameters

indent

The new indent level

Definition at line 2382 of file logger.c.

References ast_threadstorage_set_ptr().

{
   ast_threadstorage_set_ptr(&trace_indent, (void*)indent);
}

_handle_SIGXFSZ()

static void _handle_SIGXFSZ ( int  sig )

static

Definition at line 1568 of file logger.c.

References filesize_reload_needed.

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

ast_callid_strnprint()

void ast_callid_strnprint	(	char *	buffer,
		size_t	buffer_size,
		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 1952 of file logger.c.

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

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

ast_callid_threadassoc_add()

int ast_callid_threadassoc_add

(

ast_callid

callid

)

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

Return values

0	- success
non-zero	- failure

Definition at line 1984 of file logger.c.

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

Referenced by __analog_ss_thread(), __ast_pbx_run(), ast_callid_threadstorage_auto(), async_dial(), attended_transfer_monitor_thread(), bridge_channel_control_thread(), bridge_channel_depart_thread(), bridge_channel_ind_thread(), handle_request_do(), jingle_action_hook(), jingle_outgoing_hook(), mixmonitor_thread(), socket_process_helper(), and softmix_mixing_thread().

{
   ast_callid *pointing;

   pointing = ast_threadstorage_get(&unique_callid, sizeof(*pointing));
   if (!pointing) {
      return -1;
   }

   if (*pointing) {
      ast_log(LOG_ERROR, "ast_callid_threadassoc_add(C-%08x) on thread "
         "already associated with callid [C-%08x].\n", callid, *pointing);
      return 1;
   }

   *pointing = callid;
   return 0;
}

ast_callid_threadassoc_change()

int ast_callid_threadassoc_change

(

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

References ast_threadstorage_get(), and unique_callid.

Referenced by autoservice_run(), and bridge_manager_service().

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

   if (!id) {
      return -1;
   }

   *id = callid;

   return 0;
}

ast_callid_threadassoc_remove()

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

References ast_threadstorage_get(), and unique_callid.

Referenced by ast_callid_threadstorage_auto_clean(), attended_transfer_monitor_thread(), handle_request_do(), jingle_action_hook(), jingle_outgoing_hook(), and socket_process().

{
   ast_callid *pointing;

   pointing = ast_threadstorage_get(&unique_callid, sizeof(*pointing));
   if (!pointing) {
      return -1;
   }

   if (*pointing) {
      *pointing = 0;
      return 0;
   }

   return -1;
}

ast_callid_threadstorage_auto()

int ast_callid_threadstorage_auto

(

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 store the callid

Return values

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

Definition at line 2020 of file logger.c.

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

Referenced by __analog_handle_event(), analog_handle_init_event(), dahdi_handle_event(), dahdi_request(), do_monitor(), handle_clear_alarms(), handle_init_event(), mwi_thread(), my_new_analog_ast_channel(), and my_on_hook().

{
   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. */
   *callid = ast_create_callid();
   if (*callid) {
      ast_callid_threadassoc_add(*callid);
      return 1;
   }

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

ast_callid_threadstorage_auto_clean()

void ast_callid_threadstorage_auto_clean	(	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 2042 of file logger.c.

References ast_callid_threadassoc_remove().

Referenced by __analog_handle_event(), analog_handle_init_event(), dahdi_handle_event(), dahdi_new_callid_clean(), dahdi_request(), do_monitor(), handle_clear_alarms(), handle_init_event(), and mwi_thread().

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

ast_child_verbose()

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

Definition at line 850 of file logger.c.

References ast_free, ast_malloc, and NULL.

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

ast_create_callid()

ast_callid ast_create_callid

(

void

)

factory function to create a new uniquely identifying callid.

Return values

The

call id

Definition at line 1957 of file logger.c.

References ast_atomic_fetchadd_int(), and next_unique_callid.

Referenced by __ast_pbx_run(), __find_call(), ast_callid_threadstorage_auto(), iax_pvt_callid_new(), and jingle_alloc().

{
   return ast_atomic_fetchadd_int(&next_unique_callid, +1);
}

ast_dynamic_logger_level()

int ast_dynamic_logger_level

(

const char *

name

)

Checks if a dynamic logger level exists.

Parameters

name	The name of the dynamic level for which to check existence

Return values

-1	if no such dynamic level exists
non-zero	negative to be used with ast_log_dynamic_level for sending messages to this level

Definition at line 2514 of file logger.c.

References ARRAY_LEN, AST_RWLIST_UNLOCK, and AST_RWLIST_WRLOCK.

Referenced by log_exec().

{
   int level = -1;
   unsigned int x;

   AST_RWLIST_WRLOCK(&logchannels);

   for (x = 16; x < ARRAY_LEN(levels); x++) {
      if (!levels[x]) {
         continue;
      }
      if (!strcasecmp(levels[x], name)) {
         level = x;
         break;
      }
   }

   AST_RWLIST_UNLOCK(&logchannels);

   return level;
}

ast_init_logger_for_socket_console()

void ast_init_logger_for_socket_console

(

void

)

load logger.conf configuration for console socket connections

Definition at line 684 of file logger.c.

References ast_config_destroy(), ast_config_load2(), ast_copy_string(), ast_variable_retrieve(), CONFIG_STATUS_FILEINVALID, and dateformat.

Referenced by ast_remotecontrol().

{
   struct ast_config *cfg;
   const char *s;
   struct ast_flags config_flags = { 0 };

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

   if ((s = ast_variable_retrieve(cfg, "general", "dateformat"))) {
      ast_copy_string(dateformat, s, sizeof(dateformat));
   }

   ast_config_destroy(cfg);
}

ast_is_logger_initialized()

int ast_is_logger_initialized

(

void

)

Test if logger is initialized.

Return values

true	if the logger is initialized

Definition at line 1841 of file logger.c.

References logger_initialized.

Referenced by check_init().

{
   return logger_initialized;
}

ast_log()

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

References ast_log_ap().

Referenced by ast_callid_threadassoc_add(), ast_log_backtrace(), init_logger(), logger_queue_init(), logger_queue_restart(), logger_register_level(), and rotate_file().

{
   va_list ap;

   va_start(ap, fmt);
   ast_log_ap(level, file, line, function, fmt, ap);
   va_end(ap);
}

ast_log_ap()

void ast_log_ap	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		const char *	fmt,
		va_list	ap
	)

Definition at line 2110 of file logger.c.

References __ast_verbose_ap(), __LOG_VERBOSE, ast_log_full(), ast_read_threadstorage_callid(), and logmsg::callid.

Referenced by ast_log(), and module_load_error().

{
   ast_callid callid;

   callid = ast_read_threadstorage_callid();

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

ast_log_backtrace()

void ast_log_backtrace

(

void

)

Log a backtrace of the current thread's execution stack to the Asterisk log.

Definition at line 2158 of file logger.c.

References __LOG_ERROR, ast_bt::addresses, ast_bt_create, ast_bt_destroy, ast_bt_free_symbols, ast_bt_get_symbols, ast_free, ast_log(), ast_log_safe(), ast_str_append(), ast_str_buffer(), ast_str_create, AST_VECTOR_GET, AST_VECTOR_SIZE, buf, LOG_ERROR, LOG_WARNING, NULL, and ast_bt::num_frames.

Referenced by __ast_assert_failed(), ast_json_vpack(), ast_sched_del(), and AST_TEST_DEFINE().

{
#ifdef HAVE_BKTR
   struct ast_bt *bt;
   int i = 0;
   struct ast_vector_string *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))) {
      int count = AST_VECTOR_SIZE(strings);
      struct ast_str *buf = ast_str_create(bt->num_frames * 64);

      if (buf) {
         ast_str_append(&buf, 0, "Got %d backtrace record%c\n", count - 3, count - 3 != 1 ? 's' : ' ');
         for (i = 3; i < AST_VECTOR_SIZE(strings); i++) {
            ast_str_append(&buf, 0, "#%2d: %s\n", i - 3, AST_VECTOR_GET(strings, i));
         }
         ast_log_safe(__LOG_ERROR, NULL, 0, NULL, "%s\n", ast_str_buffer(buf));
         ast_free(buf);
      }

      ast_bt_free_symbols(strings);
   } else {
      ast_log(LOG_ERROR, "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) */
}

ast_log_callid()

void ast_log_callid	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		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 2149 of file logger.c.

References ast_log_full().

Referenced by ast_channel_destructor(), and dahdi_cc_callback().

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

ast_log_full()

static void ast_log_full ( int  level, int  sublevel, const char *  file, int  line, const char *  function, ast_callid  callid, const char *  fmt, va_list  ap  )

static

send log messages to syslog and/or the console

Definition at line 2053 of file logger.c.

References __LOG_VERBOSE, __LOG_WARNING, ast_cond_signal, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_opt_exec, ast_opt_remote, AST_PTHREADT_NULL, format_log_message(), format_log_message_ap(), high_water_alert, logmsg::list, logger_messages_discarded, logger_print_normal(), logger_queue_limit, logger_queue_size, logmsg_free(), and NULL.

Referenced by __ast_trace(), __ast_verbose_ap(), ast_log_ap(), ast_log_callid(), and ast_log_safe().

{
   struct logmsg *logmsg = NULL;

   if (level == __LOG_VERBOSE && ast_opt_remote && ast_opt_exec) {
      return;
   }

   AST_LIST_LOCK(&logmsgs);
   if (logger_queue_size >= logger_queue_limit && !close_logger_thread) {
      logger_messages_discarded++;
      if (!high_water_alert && !close_logger_thread) {
         logmsg = format_log_message(__LOG_WARNING, 0, "logger", 0, "***", 0,
            "Log queue threshold (%d) exceeded.  Discarding new messages.\n", logger_queue_limit);
         AST_LIST_INSERT_TAIL(&logmsgs, logmsg, list);
         high_water_alert = 1;
         ast_cond_signal(&logcond);
      }
      AST_LIST_UNLOCK(&logmsgs);
      return;
   }
   AST_LIST_UNLOCK(&logmsgs);

   logmsg = format_log_message_ap(level, sublevel, file, line, function, callid, fmt, ap);
   if (!logmsg) {
      return;
   }

   /* 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);
         logger_queue_size++;
         ast_cond_signal(&logcond);
      }
      AST_LIST_UNLOCK(&logmsgs);
   } else {
      logger_print_normal(logmsg);
      logmsg_free(logmsg);
   }
}

ast_log_safe()

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

Used for sending a log message with protection against recursion.

Note

This function should be used by all error messages that might be directly or indirectly caused by logging.

See also

ast_log for documentation on the parameters.

Definition at line 2123 of file logger.c.

References ast_log_full(), ast_read_threadstorage_callid(), ast_threadstorage_get_ptr(), ast_threadstorage_set_ptr(), logmsg::callid, and NULL.

Referenced by __ast_str_helper(), and ast_log_backtrace().

{
   va_list ap;
   void *recursed = ast_threadstorage_get_ptr(&in_safe_log);
   ast_callid callid;

   if (recursed) {
      return;
   }

   if (ast_threadstorage_set_ptr(&in_safe_log, (void*)1)) {
      /* We've failed to set the flag that protects against
       * recursion, so bail. */
      return;
   }

   callid = ast_read_threadstorage_callid();

   va_start(ap, fmt);
   ast_log_full(level, -1, file, line, function, callid, fmt, ap);
   va_end(ap);

   /* Clear flag so the next allocation failure can be logged. */
   ast_threadstorage_set_ptr(&in_safe_log, NULL);
}

ast_logger_create_channel()

int ast_logger_create_channel	(	const char *	log_channel,
		const char *	components
	)

Create a log channel.

Parameters

log_channel	Log channel to create
components	Logging config levels to add to the log channel

Definition at line 1419 of file logger.c.

References AST_LOGGER_ALLOC_ERROR, AST_LOGGER_DECLINE, AST_LOGGER_FAILURE, AST_LOGGER_SUCCESS, AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero, find_logchannel(), global_logmask, logchannel::list, logchannel::logmask, and make_logchannel().

Referenced by ast_ari_asterisk_add_log(), handle_cli_queue_test(), and handle_logger_add_channel().

{
   struct logchannel *chan;

   if (ast_strlen_zero(components)) {
      return AST_LOGGER_DECLINE;
   }

   AST_RWLIST_WRLOCK(&logchannels);

   chan = find_logchannel(log_channel);
   if (chan) {
      AST_RWLIST_UNLOCK(&logchannels);
      return AST_LOGGER_FAILURE;
   }

   chan = make_logchannel(log_channel, components, 0, 1);
   if (!chan) {
      AST_RWLIST_UNLOCK(&logchannels);
      return AST_LOGGER_ALLOC_ERROR;
   }

   AST_RWLIST_INSERT_HEAD(&logchannels, chan, list);
   global_logmask |= chan->logmask;

   AST_RWLIST_UNLOCK(&logchannels);

   return AST_LOGGER_SUCCESS;
}

ast_logger_get_channels()

int ast_logger_get_channels	(	int(*)(const char *channel, const char *type, const char *status, const char *configuration, void *data)	logentry,
		void *	data
	)

Retrieve the existing log channels.

Parameters

logentry	A callback to an updater function
data	Data passed into the callback for manipulation

For each of the logging channels, logentry will be executed with the channel file name, log type, status of the log, and configuration levels.

Return values

0	on success
1	on failure
-2	on allocation error

Definition at line 1336 of file logger.c.

References ARRAY_LEN, ast_free, AST_LOGGER_ALLOC_ERROR, AST_LOGGER_FAILURE, AST_LOGGER_SUCCESS, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_reset(), logchannel::disabled, logchannel::filename, logchannel::logmask, LOGTYPE_CONSOLE, LOGTYPE_SYSLOG, NULL, and logchannel::type.

Referenced by ast_ari_asterisk_list_log_channels().

{
   struct logchannel *chan;
   struct ast_str *configs = ast_str_create(64);
   int res = AST_LOGGER_SUCCESS;

   if (!configs) {
      return AST_LOGGER_ALLOC_ERROR;
   }

   AST_RWLIST_RDLOCK(&logchannels);
   AST_RWLIST_TRAVERSE(&logchannels, chan, list) {
      unsigned int level;

      ast_str_reset(configs);

      for (level = 0; level < ARRAY_LEN(levels); level++) {
         if ((chan->logmask & (1 << level)) && levels[level]) {
            ast_str_append(&configs, 0, "%s ", levels[level]);
         }
      }

      res = logentry(chan->filename, chan->type == LOGTYPE_CONSOLE ? "Console" :
         (chan->type == LOGTYPE_SYSLOG ? "Syslog" : "File"), chan->disabled ?
         "Disabled" : "Enabled", ast_str_buffer(configs), data);

      if (res) {
         AST_RWLIST_UNLOCK(&logchannels);
         ast_free(configs);
         configs = NULL;
         return AST_LOGGER_FAILURE;
      }
   }
   AST_RWLIST_UNLOCK(&logchannels);

   ast_free(configs);
   configs = NULL;

   return AST_LOGGER_SUCCESS;
}

ast_logger_get_dateformat()

const char* ast_logger_get_dateformat

(

void

)

Get the logger configured date format.

Return values

The	date format string

Since

13.0.0

Definition at line 2577 of file logger.c.

References dateformat.

Referenced by set_header().

{
   return dateformat;
}

ast_logger_get_queue_limit()

int ast_logger_get_queue_limit

(

void

)

Get the maximum number of messages allowed in the processing queue.

Returns

Queue limit

Definition at line 2587 of file logger.c.

References logger_queue_limit.

Referenced by handle_cli_queue_test().

{
   return logger_queue_limit;
}

ast_logger_register_level()

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

References AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, available(), and logger_register_level().

Referenced by handle_cli_dynamic_level_test(), handle_cli_performance_test(), handle_cli_queue_test(), and load_module().

{
   unsigned int available = 0;

   AST_RWLIST_WRLOCK(&logchannels);
   available = logger_register_level(name);
   AST_RWLIST_UNLOCK(&logchannels);

   return available;
}

ast_logger_remove_channel()

int ast_logger_remove_channel

(

const char *

log_channel

)

Delete the specified log channel.

Parameters

log_channel

The log channel to delete

Definition at line 1485 of file logger.c.

References ast_free, AST_LOGGER_FAILURE, AST_LOGGER_SUCCESS, AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, logchannel::dynamic, logchannel::fileptr, find_logchannel(), logchannel::list, and NULL.

Referenced by ast_ari_asterisk_delete_log(), handle_cli_queue_test(), and handle_logger_remove_channel().

{
   struct logchannel *chan;

   AST_RWLIST_WRLOCK(&logchannels);

   chan = find_logchannel(log_channel);
   if (chan && chan->dynamic) {
      AST_RWLIST_REMOVE(&logchannels, chan, list);
   } else {
      AST_RWLIST_UNLOCK(&logchannels);
      return AST_LOGGER_FAILURE;
   }
   AST_RWLIST_UNLOCK(&logchannels);

   if (chan->fileptr) {
      fclose(chan->fileptr);
      chan->fileptr = NULL;
   }
   ast_free(chan);
   chan = NULL;

   return AST_LOGGER_SUCCESS;
}

ast_logger_rotate()

int ast_logger_rotate

(

void

)

Reload logger while rotating log files.

Definition at line 1254 of file logger.c.

References NULL, and reload_logger().

Referenced by action_loggerrotate().

{
   return reload_logger(1, NULL);
}

ast_logger_rotate_channel()

int ast_logger_rotate_channel

(

const char *

log_channel

)

Rotate the specified log channel.

Parameters

log_channel

The log channel to rotate

Definition at line 1259 of file logger.c.

References ast_config_AST_LOG_DIR, AST_LOGGER_FAILURE, AST_LOGGER_SUCCESS, ast_mkdir(), AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, logchannel::disabled, EVENT_FLAG_SYSTEM, logchannel::filename, logchannel::fileptr, init_logger_chain(), logchannel::list, make_filename(), manager_event, NULL, PATH_MAX, and rotate_file().

Referenced by ast_ari_asterisk_rotate_log().

{
   struct logchannel *f;
   int success = AST_LOGGER_FAILURE;
   char filename[PATH_MAX];

   make_filename(log_channel, filename, sizeof(filename));

   AST_RWLIST_WRLOCK(&logchannels);

   ast_mkdir(ast_config_AST_LOG_DIR, 0644);

   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)) {
         fclose(f->fileptr);  /* Close file */
         f->fileptr = NULL;
         if (strcmp(filename, f->filename) == 0) {
            rotate_file(f->filename);
            success = AST_LOGGER_SUCCESS;
         }
      }
   }

   init_logger_chain(NULL);

   AST_RWLIST_UNLOCK(&logchannels);

   return success;
}

ast_logger_set_queue_limit()

void ast_logger_set_queue_limit

(

int

queue_limit

)

Set the maximum number of messages allowed in the processing queue.

Parameters

queue_limit

Returns

Nothing

Definition at line 2582 of file logger.c.

References logger_queue_limit.

Referenced by handle_cli_queue_test().

{
   logger_queue_limit = queue_limit;
}

ast_logger_unregister_level()

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

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

Referenced by handle_cli_dynamic_level_test(), handle_cli_performance_test(), handle_cli_queue_test(), 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 %u.\n", name, x);

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

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 2615 of file logger.c.

ast_queue_log()

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

Definition at line 894 of file logger.c.

References args, AST_APP_ARG, ast_check_realtime(), AST_DECLARE_APP_ARGS, ast_localtime(), AST_NONSTANDARD_APP_ARGS, ast_realtime_require_field(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_store_realtime(), ast_strftime(), ast_tvnow(), logfiles, logger_initialized, logger_queue_start(), NULL, queuelog_init, RQ_CHAR, S_OR, and SENTINEL.

Referenced by aqm_exec(), find_queue_by_name_rt(), handle_blind_transfer(), handle_hangup(), handle_queue_add_member(), handle_queue_remove_member(), log_attended_transfer(), logger_queue_start(), manager_add_queue_member(), manager_queue_log_custom(), manager_remove_queue_member(), ql_exec(), queue_agent_cb(), queue_exec(), qupd_exec(), reload_logger(), rna(), rqm_exec(), rt_handle_member_record(), set_member_paused(), set_member_penalty_help_members(), set_queue_member_pause(), set_queue_member_ringinuse(), try_calling(), update_realtime_members(), wait_for_answer(), 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) {
      /* We must initialize now since someone is trying to log something. */
      logger_queue_start();
   }

   if (ast_check_realtime("queue_log")) {
      tv = ast_tvnow();
      ast_localtime(&tv, &tm, logfiles.queue_log_realtime_use_gmt ? "GMT" : 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);
   }
}

ast_read_threadstorage_callid()

ast_callid ast_read_threadstorage_callid

(

void

)

extracts the callerid from the thread

Return values

Non-zero	Call id related to the thread
0	if no call_id is present in the thread

Definition at line 1962 of file logger.c.

References ast_threadstorage_get(), and unique_callid.

Referenced by __ast_pbx_run(), __ast_verbose(), ast_callid_threadstorage_auto(), ast_dial_run(), ast_log_ap(), ast_log_safe(), bridge_channel_internal_join(), bridge_impart_internal(), common_recall_channel_setup(), iax2_request(), jingle_alloc(), launch_monitor_thread(), local_request_with_stream_topology(), media_request_helper(), sip_request_call(), and socket_process().

{
   ast_callid *callid;

   callid = ast_threadstorage_get(&unique_callid, sizeof(*callid));

   return callid ? *callid : 0;
}

AST_THREADSTORAGE_RAW() [1/2]

AST_THREADSTORAGE_RAW

(

in_safe_log

)

Referenced by update_logchannels().

AST_THREADSTORAGE_RAW() [2/2]

AST_THREADSTORAGE_RAW

(

trace_indent

)

ast_verb_console_get()

int ast_verb_console_get

(

void

)

Get this thread's console verbosity level.

Return values

verbosity

level of the console.

Definition at line 2323 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(), and handle_verbose().

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

ast_verb_console_register()

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

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

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

ast_verb_console_set()

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 2341 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().

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

ast_verb_console_unregister()

void ast_verb_console_unregister

(

void

)

Unregister this thread's console verbosity level.

Returns

Nothing

Definition at line 2312 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);
}

ast_verb_update()

void ast_verb_update

(

void

)

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

Returns

Nothing

Definition at line 2232 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, option_verbose, verb_update_lock, 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);
}

close_logger()

void close_logger

(

void

)

Provided by logger.c

Definition at line 1912 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_logger_category_unload(), AST_PTHREADT_NULL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, logchannel::fileptr, logchannel::list, logger_initialized, and NULL.

Referenced by really_quit().

{
   struct logchannel *f = NULL;

   ast_logger_category_unload();

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

find_logchannel()

static struct logchannel* find_logchannel ( const char *  channel )

static

Find a particular logger channel by name.

Precondition

logchannels list is locked

Parameters

channel

The name of the logger channel to find

Return values

non-NULL	The corresponding logger channel
NULL	Unable to find a logger channel with that particular name

Definition at line 601 of file logger.c.

References AST_RWLIST_TRAVERSE, logchannel::filename, logchannel::list, make_filename(), NULL, and PATH_MAX.

Referenced by ast_logger_create_channel(), and ast_logger_remove_channel().

{
   char filename[PATH_MAX];
   struct logchannel *chan;

   make_filename(channel, filename, sizeof(filename));

   AST_RWLIST_TRAVERSE(&logchannels, chan, list) {
      if (!strcmp(chan->filename, filename)) {
         return chan;
      }
   }

   return NULL;
}

format_log_default()

static int format_log_default ( struct logchannel *  chan, struct logmsg *  msg, char *  buf, size_t  size  )

static

Definition at line 365 of file logger.c.

References __LOG_VERBOSE, ast_strlen_zero, logmsg::callid, COLOR_BRWHITE, COLORIZE, COLORIZE_FMT, logmsg::date, logmsg::file, logmsg::function, logmsg::level, logmsg::level_name, logmsg::line, logger_add_verbose_magic(), LOGTYPE_CONSOLE, LOGTYPE_FILE, LOGTYPE_SYSLOG, logmsg::lwp, logmsg::message, term_strip(), and logchannel::type.

{
   char call_identifier_str[13];

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

   switch (chan->type) {
   case LOGTYPE_SYSLOG:
      snprintf(buf, size, "%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, size);
      break;
   case LOGTYPE_FILE:
      snprintf(buf, size, "[%s] %s[%d]%s %s: %s",
            msg->date, msg->level_name, msg->lwp, call_identifier_str,
            msg->file, msg->message);
      term_strip(buf, buf, size);
      break;
   case LOGTYPE_CONSOLE:
      {
         char linestr[32];
         int has_file = !ast_strlen_zero(msg->file);
         int has_line = (msg->line > 0);
         int has_func = !ast_strlen_zero(msg->function);

         /*
          * Verbose messages are interpreted by console channels in their own
          * special way
          */
         if (msg->level == __LOG_VERBOSE) {
            return logger_add_verbose_magic(msg, buf, size);
         }

         /* Turn the numerical line number into a string */
         snprintf(linestr, sizeof(linestr), "%d", msg->line);
         /* Build string to print out */
         snprintf(buf, size, "[%s] " COLORIZE_FMT "[%d]%s: " COLORIZE_FMT "%s" COLORIZE_FMT " " COLORIZE_FMT "%s %s",
            msg->date,
            COLORIZE(colors[msg->level], 0, msg->level_name),
            msg->lwp,
            call_identifier_str,
            COLORIZE(COLOR_BRWHITE, 0, has_file ? msg->file : ""),
            has_file ? ":" : "",
            COLORIZE(COLOR_BRWHITE, 0, has_line ? linestr : ""),
            COLORIZE(COLOR_BRWHITE, 0, has_func ? msg->function : ""),
            has_func ? ":" : "",
            msg->message);
      }
      break;
   }

   return 0;
}

format_log_json()

static int format_log_json ( struct logchannel *  channel, struct logmsg *  msg, char *  buf, size_t  size  )

static

Definition at line 259 of file logger.c.

References ast_config_AST_SYSTEM_NAME, ast_copy_string(), ast_json_dump_string, ast_json_free(), ast_json_pack(), ast_json_unref(), logmsg::callid, logmsg::date, logmsg::file, logmsg::function, logmsg::level_name, logmsg::line, logmsg::lwp, logmsg::message, S_OR, str, and term_strip().

{
   struct ast_json *json;
   char *str;
   char call_identifier_str[13];
   size_t json_str_len;

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

   json = ast_json_pack("{s: s, s: s, "
      "s: {s: i, s: s} "
      "s: {s: {s: s, s: s, s: i}, "
      "s: s, s: s} }",
      "hostname", ast_config_AST_SYSTEM_NAME,
      "timestamp", msg->date,
      "identifiers",
      "lwp", msg->lwp,
      "callid", S_OR(call_identifier_str, ""),
      "logmsg",
      "location",
      "filename", msg->file,
      "function", msg->function,
      "line", msg->line,
      "level", msg->level_name,
      "message", msg->message);
   if (!json) {
      return -1;
   }

   str = ast_json_dump_string(json);
   if (!str) {
      ast_json_unref(json);
      return -1;
   }

   ast_copy_string(buf, str, size);
   json_str_len = strlen(str);
   if (json_str_len > size - 1) {
      json_str_len = size - 1;
   }
   buf[json_str_len] = '\n';
   buf[json_str_len + 1] = '\0';

   term_strip(buf, buf, size);

   ast_json_free(str);
   ast_json_unref(json);

   return 0;
}

format_log_message()

static struct logmsg* format_log_message ( int  level, int  sublevel, const char *  file, int  line, const char *  function, ast_callid  callid, const char *  fmt,   ...  )

static

Definition at line 1746 of file logger.c.

References format_log_message_ap().

Referenced by ast_log_full(), and logger_thread().

{
   struct logmsg *logmsg;
   va_list ap;

   va_start(ap, fmt);
   logmsg = format_log_message_ap(level, sublevel, file, line, function, callid, fmt, ap);
   va_end(ap);

   return logmsg;
}

format_log_message_ap()

static struct logmsg* format_log_message_ap ( int  level, int  sublevel, const char *  file, int  line, const char *  function, ast_callid  callid, const char *  fmt, va_list  ap  )

static

Definition at line 1682 of file logger.c.

References __LOG_VERBOSE, ast_calloc_with_stringfields, AST_DYNSTR_BUILD_FAILED, ast_ends_with(), ast_get_tid(), ast_localtime(), ast_str_append(), ast_str_buffer(), ast_str_set_va(), ast_str_thread_get(), ast_strftime(), ast_string_field_set, ast_tvnow(), buf, logmsg::callid, dateformat, display_callids, logmsg::level, logmsg::line, log_buf, LOG_BUF_INIT_SIZE, LOGMSG_NORMAL, LOGMSG_VERBOSE, logmsg::lwp, NULL, logmsg::sublevel, and logmsg::type.

Referenced by ast_log_full(), and format_log_message().

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

   /* 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 NULL;
   }

   /* Automatically add a newline to format strings that don't have one */
   if (!ast_ends_with(ast_str_buffer(buf), "\n")) {
      ast_str_append(&buf, 0, "\n");
   }

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

   /* 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 = callid;
   }

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

   return logmsg;
}

format_log_plain()

static int format_log_plain ( struct logchannel *  chan, struct logmsg *  msg, char *  buf, size_t  size  )

static

Definition at line 429 of file logger.c.

References ast_strlen_zero, logmsg::callid, logmsg::date, logmsg::file, logmsg::function, logmsg::level, logmsg::level_name, logmsg::line, LOGTYPE_CONSOLE, LOGTYPE_FILE, LOGTYPE_SYSLOG, logmsg::lwp, logmsg::message, term_strip(), and logchannel::type.

{
   char call_identifier_str[13];
   char linestr[32];
   int has_file = !ast_strlen_zero(msg->file);
   int has_line = (msg->line > 0);
   int has_func = !ast_strlen_zero(msg->function);

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

   switch (chan->type) {
   case LOGTYPE_SYSLOG:
      snprintf(buf, size, "%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, size);
      break;
   case LOGTYPE_FILE:
   case LOGTYPE_CONSOLE:
      /* Turn the numerical line number into a string */
      snprintf(linestr, sizeof(linestr), "%d", msg->line);
      /* Build string to print out */
      snprintf(buf, size, "[%s] %s[%d]%s: %s%s%s%s%s%s%s",
         msg->date,
         msg->level_name,
         msg->lwp,
         call_identifier_str,
         has_file ? msg->file : "",
         has_file ? ":" : "",
         has_line ? linestr : "",
         has_line ? " " : "",
         has_func ? msg->function : "",
         has_func ? ": " : "",
         msg->message);
      term_strip(buf, buf, size);
      break;
   }

   return 0;
}

handle_logger_add_channel()

static char* handle_logger_add_channel ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1449 of file logger.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), AST_LOGGER_ALLOC_ERROR, ast_logger_create_channel(), AST_LOGGER_DECLINE, AST_LOGGER_FAILURE, AST_LOGGER_SUCCESS, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger add channel";
      e->usage =
         "Usage: logger add channel <name> <levels>\n"
         "       Adds a temporary logger channel. This logger channel\n"
         "       will exist until removed or until Asterisk is restarted.\n"
         "       <levels> is a comma-separated list of desired logger\n"
         "       levels such as: verbose,warning,error\n"
         "       An optional formatter may be specified with the levels;\n"
         "       valid values are '[json]' and '[default]'.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

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

   switch (ast_logger_create_channel(a->argv[3], a->argv[4])) {
   case AST_LOGGER_SUCCESS:
      return CLI_SUCCESS;
   case AST_LOGGER_FAILURE:
      ast_cli(a->fd, "Logger channel '%s' already exists\n", a->argv[3]);
      return CLI_SUCCESS;
   case AST_LOGGER_DECLINE:
   case AST_LOGGER_ALLOC_ERROR:
   default:
      ast_cli(a->fd, "ERROR: Unable to create log channel '%s'\n", a->argv[3]);
      return CLI_FAILURE;
   }
}

handle_logger_reload()

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

static

Definition at line 1216 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, NULL, 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;
}

handle_logger_remove_channel()

static char* handle_logger_remove_channel ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1510 of file logger.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), AST_LOGGER_FAILURE, ast_logger_remove_channel(), AST_LOGGER_SUCCESS, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_strlen_zero, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, logchannel::dynamic, ast_cli_args::fd, logchannel::filename, logchannel::list, ast_cli_args::n, NULL, ast_cli_args::pos, and ast_cli_entry::usage.

{
   struct logchannel *chan;
   int gen_count = 0;
   char *gen_ret = NULL;

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger remove channel";
      e->usage =
         "Usage: logger remove channel <name>\n"
         "       Removes a temporary logger channel.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->argc > 4 || (a->argc == 4 && a->pos > 3)) {
         return NULL;
      }
      AST_RWLIST_RDLOCK(&logchannels);
      AST_RWLIST_TRAVERSE(&logchannels, chan, list) {
         if (chan->dynamic && (ast_strlen_zero(a->argv[3])
            || !strncmp(a->argv[3], chan->filename, strlen(a->argv[3])))) {
            if (gen_count == a->n) {
               gen_ret = ast_strdup(chan->filename);
               break;
            }
            gen_count++;
         }
      }
      AST_RWLIST_UNLOCK(&logchannels);
      return gen_ret;
   }

   if (a->argc < 4) {
      return CLI_SHOWUSAGE;
   }

   switch (ast_logger_remove_channel(a->argv[3])) {
   case AST_LOGGER_SUCCESS:
      ast_cli(a->fd, "Removed dynamic logger channel '%s'\n", a->argv[3]);
      return CLI_SUCCESS;
   case AST_LOGGER_FAILURE:
      ast_cli(a->fd, "Unable to find dynamic logger channel '%s'\n", a->argv[3]);
      return CLI_SUCCESS;
   default:
      ast_cli(a->fd, "Internal failure attempting to delete dynamic logger channel '%s'\n", a->argv[3]);
      return CLI_FAILURE;
   }
}

handle_logger_rotate()

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

static

Definition at line 1235 of file logger.c.

References ast_cli(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, 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;
}

handle_logger_set_level()

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

static

Definition at line 1294 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, NULL, state, and ast_cli_entry::usage.

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

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger set level {DEBUG|TRACE|NOTICE|WARNING|ERROR|VERBOSE|DTMF} {on|off}";
      e->usage =
         "Usage: logger set level {DEBUG|TRACE|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;
}

handle_logger_show_channels()

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 1379 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, logchannel::formatter, logchannel::list, logger_queue_limit, logchannel::logmask, LOGTYPE_CONSOLE, LOGTYPE_SYSLOG, logformatter::name, NULL, logchannel::type, and ast_cli_entry::usage.

{
#define FORMATL   "%-35.35s %-8.8s %-10.10s %-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, "Logger queue limit: %d\n\n", logger_queue_limit);
   ast_cli(a->fd, FORMATL, "Channel", "Type", "Formatter", "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->formatter.name,
         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;
}

init_logger()

int init_logger

(

void

)

Provided by logger.c

Definition at line 1870 of file logger.c.

References ARRAY_LEN, ast_cli_register_multiple, ast_cond_destroy, ast_cond_init, ast_config_AST_LOG_DIR, ast_log(), ast_logger_category_load(), ast_mkdir(), ast_mutex_destroy, ast_mutex_init, ast_pthread_create, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb_update(), init_logger_chain(), logmsgs::lock, LOG_ERROR, logger_initialized, logger_thread(), and NULL.

Referenced by asterisk_daemon().

{
   int res;
   /* 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 */
   AST_RWLIST_WRLOCK(&logchannels);
   res = init_logger_chain(NULL);
   AST_RWLIST_UNLOCK(&logchannels);
   ast_verb_update();
   logger_initialized = 1;
   if (res) {
      ast_log(LOG_ERROR, "Errors detected in logger.conf.  Default console logging is being used.\n");
   }

   ast_logger_category_load();

   return 0;
}

init_logger_chain()

static int init_logger_chain ( const char *  altconf )

static

Read config, setup channels.

Parameters

altconf

Alternate configuration file to read.

Precondition

logchannels list is write locked

Return values

0	Success
-1	No config found or Failed

Definition at line 710 of file logger.c.

References __LOG_ERROR, ast_config_destroy(), ast_config_load2(), ast_console_puts_mutable(), ast_copy_string(), ast_free, AST_RWLIST_INSERT_HEAD, AST_RWLIST_REMOVE_HEAD, ast_strdup, ast_strdupa, ast_true(), ast_variable_browse(), ast_variable_retrieve(), CONFIG_STATUS_FILEINVALID, dateformat, display_callids, errno, exec_after_rotate, global_logmask, hostname, ast_variable::lineno, logfiles, logger_queue_limit, logger_register_level(), logchannel::logmask, make_logchannel(), ast_variable::name, ast_variable::next, NONE, NULL, queue_log_name, QUEUELOG, ROTATE, S_OR, SEQUENTIAL, strsep(), TIMESTAMP, ast_variable::value, and var.

Referenced by ast_logger_rotate_channel(), 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 };

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

   /* Set defaults */
   hostname[0] = '\0';
   display_callids = 1;
   memset(&logfiles, 0, sizeof(logfiles));
   logfiles.queue_log = 1;
   ast_copy_string(dateformat, "%b %e %T", sizeof(dateformat));
   ast_copy_string(queue_log_name, QUEUELOG, sizeof(queue_log_name));
   exec_after_rotate[0] = '\0';
   rotatestrategy = SEQUENTIAL;

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

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

   /* If no config file, we're fine, set default options. */
   if (!cfg) {
      chan = make_logchannel("console", "error,warning,notice,verbose", 0, 0);
      if (!chan) {
         fprintf(stderr, "ERROR: Failed to initialize default logging\n");
         return -1;
      }

      AST_RWLIST_INSERT_HEAD(&logchannels, chan, list);
      global_logmask |= chan->logmask;

      return -1;
   }

   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");
         }
      }
   }
   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));
   }
   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", "queue_log_realtime_use_gmt"))) {
      logfiles.queue_log_realtime_use_gmt = ast_true(s);
   }
   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 if (strcasecmp(s, "none") == 0) {
         rotatestrategy = NONE;
      } 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 ((s = ast_variable_retrieve(cfg, "general", "logger_queue_limit"))) {
      if (sscanf(s, "%30d", &logger_queue_limit) != 1) {
         fprintf(stderr, "logger_queue_limit has an invalid value.  Leaving at default of %d.\n",
            logger_queue_limit);
      }
      if (logger_queue_limit < 10) {
         fprintf(stderr, "logger_queue_limit must be >= 10. Setting to 10.\n");
         logger_queue_limit = 10;
      }
   }

   /* Custom dynamic logging levels defined by user */
   if ((s = ast_variable_retrieve(cfg, "general", "custom_logs"))) {
      char *customlogs = ast_strdupa(s);
      char *logfile;
      while ((logfile = strsep(&customlogs, ","))) {
         char *customlog = ast_strdup(logfile);
         /* Lock already held, so directly register the level */
         logger_register_level(customlog);
      }
   }

   var = ast_variable_browse(cfg, "logfiles");
   for (; var; var = var->next) {
      chan = make_logchannel(var->name, var->value, var->lineno, 0);
      if (!chan) {
         /* 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;
   }

   ast_config_destroy(cfg);

   return 0;
}

load_module()

static int load_module ( void  )

static

Definition at line 2602 of file logger.c.

References AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODULE_INFO(), AST_MODULE_LOAD_SUCCESS, AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, reload(), reload_module(), and unload_module().

{
   return AST_MODULE_LOAD_SUCCESS;
}

logger_add_verbose_magic()

static int logger_add_verbose_magic ( struct logmsg *  logmsg, char *  buf, size_t  size  )

static

Definition at line 319 of file logger.c.

References ast_str_append(), ast_str_append_substr(), ast_str_buffer(), ast_str_reset(), ast_str_thread_get(), logmsg::message, logmsg::sublevel, verbose_buf, VERBOSE_BUF_INIT_SIZE, VERBOSE_PREFIX_1, VERBOSE_PREFIX_2, VERBOSE_PREFIX_3, and VERBOSE_PREFIX_4.

Referenced by format_log_default().

{
   const char *p;
   const char *fmt;
   struct ast_str *prefixed;
   signed char magic = logmsg->sublevel > 9 ? -10 : -logmsg->sublevel - 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 (logmsg->sublevel < 0) {
      if (!strncmp(logmsg->message, VERBOSE_PREFIX_4, strlen(VERBOSE_PREFIX_4))) {
         magic = -5;
      } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_3, strlen(VERBOSE_PREFIX_3))) {
         magic = -4;
      } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_2, strlen(VERBOSE_PREFIX_2))) {
         magic = -3;
      } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_1, strlen(VERBOSE_PREFIX_1))) {
         magic = -2;
      } else {
         magic = -1;
      }
   }

   if (!(prefixed = ast_str_thread_get(&verbose_buf, VERBOSE_BUF_INIT_SIZE))) {
      return -1;
   }

   ast_str_reset(prefixed);

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

      ast_str_append(&prefixed, 0, "%c", (char)magic);
      ast_str_append_substr(&prefixed, 0, fmt, p - fmt);
      fmt = p;
   } while (p && *p);

   snprintf(buf, size, "%s", ast_str_buffer(prefixed));

   return 0;
}

logger_print_normal()

static void logger_print_normal ( struct logmsg *  logmsg )

static

Print a normal log message to the channels.

Definition at line 1580 of file logger.c.

References __LOG_VERBOSE, ast_console_puts_mutable_full(), AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero, ast_syslog_priority_from_loglevel(), ast_verb, buf, logchannel::disabled, errno, EVENT_FLAG_SYSTEM, logchannel::facility, logchannel::filename, logchannel::fileptr, filesize_reload_needed, logformatter::format_log, logchannel::formatter, logmsg::level, logchannel::list, logchannel::logmask, LOGTYPE_CONSOLE, LOGTYPE_FILE, LOGTYPE_SYSLOG, manager_event, logmsg::message, NULL, option_verbose, reload_logger(), logmsg::sublevel, logchannel::type, and logchannel::verbosity.

Referenced by ast_log_full(), and logger_thread().

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

   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;
         }
         if (logmsg->level == __LOG_VERBOSE
            && (((chan->verbosity < 0) ? option_verbose : chan->verbosity)) < level) {
            continue;
         }

         if (!(chan->logmask & (1 << logmsg->level))) {
            continue;
         }

         switch (chan->type) {
         case LOGTYPE_SYSLOG:
            {
               int syslog_level = ast_syslog_priority_from_loglevel(logmsg->level);

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

               /* Don't use LOG_MAKEPRI because it's broken in glibc<2.17 */
               syslog_level = chan->facility | syslog_level; /* LOG_MAKEPRI(chan->facility, syslog_level); */
               if (!chan->formatter.format_log(chan, logmsg, buf, BUFSIZ)) {
                  syslog(syslog_level, "%s", buf);
               }
            }
            break;
         case LOGTYPE_CONSOLE:
            if (!chan->formatter.format_log(chan, logmsg, buf, BUFSIZ)) {
               ast_console_puts_mutable_full(buf, logmsg->level, logmsg->sublevel);
            }
            break;
         case LOGTYPE_FILE:
            {
               int res = 0;

               if (!chan->fileptr) {
                  continue;
               }

               if (chan->formatter.format_log(chan, logmsg, buf, BUFSIZ)) {
                  continue;
               }

               /* Print out to the file */
               res = fprintf(chan->fileptr, "%s", buf);
               if (res > 0) {
                  fflush(chan->fileptr);
               } else 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;
               }
            }
            break;
         }
      }
   } else if (logmsg->level != __LOG_VERBOSE || option_verbose >= logmsg->sublevel) {
      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;
}

logger_queue_init()

static void logger_queue_init ( void  )

static

Definition at line 1817 of file logger.c.

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

Referenced by logger_queue_start().

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

logger_queue_restart()

static int logger_queue_restart ( int  queue_rotate )

static

Definition at line 1113 of file logger.c.

References ast_config_AST_LOG_DIR, ast_log(), errno, LOG_ERROR, logger_queue_rt_start(), NULL, PATH_MAX, queue_log_name, 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;
}

logger_queue_rt_start()

static int logger_queue_rt_start ( void  )

static

Definition at line 1078 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;
}

logger_queue_start()

void logger_queue_start

(

void

)

Start the ast_queue_log() logger.

Note

Called when the system is fully booted after startup so preloaded realtime modules can get up.

Returns

Nothing

Definition at line 1854 of file logger.c.

References ast_assert, ast_queue_log(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, logger_initialized, logger_queue_init(), and queuelog_init.

Referenced by ast_queue_log(), and asterisk_daemon().

{
   /* Must not be called before the logger is initialized. */
   ast_assert(logger_initialized);

   AST_RWLIST_WRLOCK(&logchannels);
   if (!queuelog_init) {
      logger_queue_init();
      queuelog_init = 1;
      AST_RWLIST_UNLOCK(&logchannels);
      ast_queue_log("NONE", "NONE", "NONE", "QUEUESTART", "%s", "");
   } else {
      AST_RWLIST_UNLOCK(&logchannels);
   }
}

logger_register_level()

static int logger_register_level ( const char *  name )

static

Definition at line 2464 of file logger.c.

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

Referenced by ast_logger_register_level(), and init_logger_chain().

{
   unsigned int level;
   unsigned int available = 0;

   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_debug(1, "Registered dynamic logger level '%s' with index %u.\n", name, available);

   update_logchannels();

   return available;
}

logger_thread()

static void* logger_thread ( void *  data )

static

Actual logging thread.

Definition at line 1761 of file logger.c.

References __LOG_WARNING, ast_cond_wait, AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_NEXT, AST_LIST_UNLOCK, format_log_message(), high_water_alert, logmsg::list, logmsgs::lock, logger_messages_discarded, logger_print_normal(), logger_queue_size, logmsg_free(), logmsg::next, and NULL.

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

      if (high_water_alert) {
         msg = format_log_message(__LOG_WARNING, 0, "logger", 0, "***", 0,
            "Logging resumed.  %d message%s discarded.\n",
            logger_messages_discarded, logger_messages_discarded == 1 ? "" : "s");
         if (msg) {
            AST_LIST_INSERT_TAIL(&logmsgs, msg, list);
         }
         high_water_alert = 0;
         logger_messages_discarded = 0;
      }

      next = AST_LIST_FIRST(&logmsgs);
      AST_LIST_HEAD_INIT_NOLOCK(&logmsgs);
      logger_queue_size = 0;
      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;
}

logmsg_free()

static void logmsg_free ( struct logmsg *  msg )

static

Definition at line 182 of file logger.c.

References ast_free, and ast_string_field_free_memory.

Referenced by ast_log_full(), and logger_thread().

{
   ast_string_field_free_memory(msg);
   ast_free(msg);
}

make_components()

static void make_components ( struct logchannel *  chan )

static

Definition at line 479 of file logger.c.

References __LOG_VERBOSE, ARRAY_LEN, ast_strdupa, ast_strip(), ast_strlen_zero, logchannel::components, end, logchannel::filename, logchannel::formatter, logchannel::logmask, LOGTYPE_CONSOLE, logformatter::name, strsep(), 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;
   unsigned int verb_level;

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

   w = strchr(stringp, '[');
   if (w) {
      char *end = strchr(w + 1, ']');
      if (!end) {
         fprintf(stderr, "Logger Warning: bad formatter definition for %s in logger.conf\n", chan->filename);
      } else {
         char *formatter_name = w + 1;

         *end = '\0';
         stringp = end + 1;

         if (!strcasecmp(formatter_name, "json")) {
            memcpy(&chan->formatter, &logformatter_json, sizeof(chan->formatter));
         } else if (!strcasecmp(formatter_name, "default")) {
            memcpy(&chan->formatter, &logformatter_default, sizeof(chan->formatter));
         } else if (!strcasecmp(formatter_name, "plain")) {
            memcpy(&chan->formatter, &logformatter_plain, sizeof(chan->formatter));
         } else {
            fprintf(stderr, "Logger Warning: Unknown formatter definition %s for %s in logger.conf; using 'default'\n",
               formatter_name, chan->filename);
            memcpy(&chan->formatter, &logformatter_default, sizeof(chan->formatter));
         }
      }
   }

   if (!chan->formatter.name) {
      memcpy(&chan->formatter, &logformatter_default, sizeof(chan->formatter));
   }

   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;
      logmask |= (1 << __LOG_VERBOSE);
   } else {
      chan->verbosity = verb_level;
   }
   chan->logmask = logmask;
}

make_filename()

static void make_filename ( const char *  channel, char *  filename, size_t  size  )

static

create the filename that will be used for a logger channel.

Parameters

	channel	The name of the logger channel
[out]	filename	The filename for the logger channel
	size	The size of the filename buffer

Definition at line 560 of file logger.c.

References ast_config_AST_LOG_DIR, ast_copy_string(), ast_strlen_zero, and hostname.

Referenced by ast_logger_rotate_channel(), find_logchannel(), and make_logchannel().

{
   const char *log_dir_prefix = "";
   const char *log_dir_separator = "";

   *filename = '\0';

   if (!strcasecmp(channel, "console")) {
      return;
   }

   if (!strncasecmp(channel, "syslog", 6)) {
      ast_copy_string(filename, channel, size);
      return;
   }

   /* It's a filename */

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

   if (!ast_strlen_zero(hostname)) {
      snprintf(filename, size, "%s%s%s.%s",
         log_dir_prefix, log_dir_separator, channel, hostname);
   } else {
      snprintf(filename, size, "%s%s%s",
         log_dir_prefix, log_dir_separator, channel);
   }
}

make_logchannel()

static struct logchannel* make_logchannel ( const char *  channel, const char *  components, int  lineno, int  dynamic  )

static

Definition at line 617 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_console_puts_mutable(), ast_free, ast_get_version(), ast_localtime(), ast_strftime(), ast_strlen_zero, ast_syslog_facility(), ast_tvnow(), logchannel::components, dateformat, logchannel::dynamic, errno, logchannel::facility, logchannel::filename, logchannel::fileptr, logchannel::lineno, LOGTYPE_CONSOLE, LOGTYPE_FILE, LOGTYPE_SYSLOG, make_components(), make_filename(), NULL, and logchannel::type.

Referenced by ast_logger_create_channel(), and 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;
   chan->dynamic = dynamic;

   make_filename(channel, chan->filename, sizeof(chan->filename));

   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;
      openlog("asterisk", LOG_PID, chan->facility);
   } else {
      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;
}

reload_logger()

static int reload_logger ( int  rotate, const char *  altconf  )

static

Definition at line 1141 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, logchannel::filename, logchannel::fileptr, filesize_reload_needed, init_logger_chain(), logchannel::list, logfiles, logger_queue_restart(), manager_event, NONE, NULL, and rotate_file().

Referenced by ast_logger_rotate(), handle_logger_reload(), handle_logger_rotate(), logger_print_normal(), and reload_module().

{
   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 (rotatestrategy != NONE && 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(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;
}

reload_module()

static int reload_module ( void  )

static

Definition at line 2592 of file logger.c.

References NULL, and reload_logger().

Referenced by load_module().

{
   return reload_logger(0, NULL);
}

rotate_file()

static int rotate_file ( const char *  filename )

static

Definition at line 974 of file logger.c.

References ARRAY_LEN, ast_channel_unref, ast_dummy_channel_alloc, ast_log(), ast_safe_system(), ast_strlen_zero, buf, c, exec_after_rotate, LOG_WARNING, NONE, NULL, PATH_MAX, pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), ROTATE, SEQUENTIAL, and TIMESTAMP.

Referenced by ast_logger_rotate_channel(), 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 NONE:
      /* No rotation */
      break;
   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;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 2597 of file logger.c.

Referenced by load_module().

{
   return 0;
}

update_logchannels()

static void update_logchannels ( void  )

static

Definition at line 2360 of file logger.c.

References AST_RWLIST_TRAVERSE, AST_THREADSTORAGE_RAW(), global_logmask, logchannel::list, logchannel::logmask, and make_components().

Referenced by ast_logger_unregister_level(), and logger_register_level().

{
   struct logchannel *cur;

   global_logmask = 0;

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

verb_console_free()

static void verb_console_free ( void *  v_console )

static

Definition at line 2285 of file logger.c.

References ast_free, and verb_console_unregister().

{
   struct verb_console *console = v_console;

   verb_console_unregister(console);
   ast_free(console);
}

verb_console_unregister()

static void verb_console_unregister ( struct verb_console *  console )

static

Definition at line 2275 of file logger.c.

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and ast_verb_update().

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

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Logger" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = 0, }

static

Definition at line 2615 of file logger.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2615 of file logger.c.

cli_logger

struct ast_cli_entry cli_logger[]

static

Definition at line 1559 of file logger.c.

close_logger_thread

int close_logger_thread = 0

static

Definition at line 191 of file logger.c.

colors

const int colors[NUMLOGLEVELS]

static

Colors used in the console for logging.

Definition at line 217 of file logger.c.

dateformat

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

static

Definition at line 79 of file logger.c.

Referenced by ast_init_logger_for_socket_console(), ast_logger_get_dateformat(), build_device(), format_log_message_ap(), init_logger_chain(), and make_logchannel().

display_callids

int display_callids

static

Definition at line 89 of file logger.c.

Referenced by format_log_message_ap(), and init_logger_chain().

exec_after_rotate

char exec_after_rotate[256] = ""

static

Definition at line 82 of file logger.c.

Referenced by init_logger_chain(), and rotate_file().

filesize_reload_needed

int filesize_reload_needed

static

Definition at line 84 of file logger.c.

Referenced by _handle_SIGXFSZ(), logger_print_normal(), and reload_logger().

global_logmask

unsigned int global_logmask = 0xFFFF

static

Definition at line 85 of file logger.c.

Referenced by ast_logger_create_channel(), ast_logger_unregister_level(), init_logger_chain(), and update_logchannels().

handle_SIGXFSZ

struct sigaction handle_SIGXFSZ

static

Initial value:

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

Definition at line 1574 of file logger.c.

high_water_alert

unsigned int high_water_alert

static

Definition at line 96 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

hostname

char hostname[MAXHOSTNAMELEN]

static

Definition at line 112 of file logger.c.

Referenced by init_logger_chain(), and make_filename().

levels

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

log_buf

struct ast_threadstorage log_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_log_buf , .custom_init = NULL , }

static

Definition at line 256 of file logger.c.

Referenced by format_log_message_ap().

logchannels

struct logchannels logchannels = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

logcond

ast_cond_t logcond

static

Definition at line 190 of file logger.c.

logfiles

struct { ... } logfiles

Referenced by ast_queue_log(), init_logger_chain(), logger_queue_init(), logger_queue_rt_start(), and reload_logger().

logformatter_default

struct logformatter logformatter_default

static

Initial value:

= {
   .name = "default",
   .format_log = format_log_default,
}

Definition at line 424 of file logger.c.

logformatter_json

struct logformatter logformatter_json

static

Initial value:

= {
   .name = "json",
   .format_log = format_log_json
}

Definition at line 314 of file logger.c.

logformatter_plain

struct logformatter logformatter_plain

static

Initial value:

= {
   .name = "plain",
   .format_log = format_log_plain,
}

Definition at line 474 of file logger.c.

logger_initialized

int logger_initialized

static

Definition at line 87 of file logger.c.

Referenced by ast_is_logger_initialized(), ast_queue_log(), close_logger(), init_logger(), and logger_queue_start().

logger_messages_discarded

int logger_messages_discarded

static

Definition at line 95 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

logger_queue_limit

int logger_queue_limit = 1000

static

Definition at line 94 of file logger.c.

Referenced by ast_log_full(), ast_logger_get_queue_limit(), ast_logger_set_queue_limit(), handle_logger_show_channels(), and init_logger_chain().

logger_queue_size

int logger_queue_size

static

Definition at line 91 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

logmsgs

struct logmsgs logmsgs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

logthread

pthread_t logthread = AST_PTHREADT_NULL

static

Definition at line 189 of file logger.c.

my_verb_console

struct ast_threadstorage my_verb_console = { .once = PTHREAD_ONCE_INIT , .key_init = __init_my_verb_console , .custom_init = NULL , }

static

Definition at line 2294 of file logger.c.

Referenced by ast_verb_console_get(), ast_verb_console_register(), ast_verb_console_set(), and ast_verb_console_unregister().

next_unique_callid

volatile int next_unique_callid = 1

static

Definition at line 88 of file logger.c.

Referenced by ast_create_callid().

qlog

FILE* qlog

static

Definition at line 193 of file logger.c.

queue_adaptive_realtime

unsigned int queue_adaptive_realtime

Definition at line 108 of file logger.c.

queue_log

unsigned int queue_log

Definition at line 106 of file logger.c.

queue_log_name

char queue_log_name[256] = QUEUELOG

static

Definition at line 81 of file logger.c.

Referenced by init_logger_chain(), logger_queue_init(), and logger_queue_restart().

queue_log_realtime_use_gmt

unsigned int queue_log_realtime_use_gmt

Definition at line 109 of file logger.c.

queue_log_to_file

unsigned int queue_log_to_file

Definition at line 107 of file logger.c.

queuelog_init

int queuelog_init

static

Definition at line 86 of file logger.c.

Referenced by ast_queue_log(), and logger_queue_start().

rotatestrategy

enum rotatestrategy rotatestrategy = SEQUENTIAL

static

unique_callid

struct ast_threadstorage unique_callid = { .once = PTHREAD_ONCE_INIT , .key_init = __init_unique_callid , .custom_init = NULL , }

static

Definition at line 91 of file logger.c.

Referenced by ast_callid_threadassoc_add(), ast_callid_threadassoc_change(), ast_callid_threadassoc_remove(), and ast_read_threadstorage_callid().

verb_consoles

struct verb_consoles verb_consoles = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

verb_update_lock

ast_mutex_t verb_update_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

ast_verb_update() reentrancy protection lock.

Definition at line 2230 of file logger.c.

Referenced by ast_verb_update().

verbose_buf

struct ast_threadstorage verbose_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_verbose_buf , .custom_init = NULL , }

static

Definition at line 252 of file logger.c.

Referenced by logger_add_verbose_magic().

verbose_build_buf

struct ast_threadstorage verbose_build_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_verbose_build_buf , .custom_init = NULL , }

static

Definition at line 253 of file logger.c.