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 "asterisk/dlinkedlists.h"

Include dependency graph for logger.c:

Go to the source code of this file.

Data Structures
struct	chan_group_lock
	map call ID to group More...
struct	chan_group_lock_list
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	FORMATL2   "%5s %s\n"
#define	LOG_BUF_INIT_SIZE   256
#define	LOGMSG_SIZE   MAX(BUFSIZ, 8192)
#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_verbose (const char *file, int line, const char *func, int level, const char *fmt,...)
	Send a verbose message (based on verbose level)
void	__ast_verbose_ap (const char *file, int line, const char *func, int level, 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.
static void	__reg_module (void)
static void	__unreg_module (void)
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
int	ast_callid_threadassoc_add (ast_callid callid)
	Adds a known callid to thread storage of the calling thread.
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.
int	ast_callid_threadassoc_remove (void)
	Removes callid from thread storage of the calling thread.
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.
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.
void	ast_child_verbose (int level, const char *fmt,...)
ast_callid	ast_create_callid (void)
	factory function to create a new uniquely identifying callid.
void	ast_init_logger_for_socket_console (void)
	load logger.conf configuration for console socket connections
int	ast_is_logger_initialized (void)
	Test if logger is initialized.
void	ast_log (int level, const char *file, int line, const char *function, const char *fmt,...)
	Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments.
void	ast_log_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.
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.
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
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.
int	ast_logger_create_channel (const char *log_channel, const char *components)
	Create a log channel.
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.
const char *	ast_logger_get_dateformat (void)
	Get the logger configured date format.
int	ast_logger_get_dynamic_level (const char *name)
	Retrieve dynamic logging level id.
int	ast_logger_get_over_threshold_queue_limit (void)
	Get the over threshold maximum number of messages allowed in the processing queue.
int	ast_logger_get_queue_limit (void)
	Get the maximum number of messages allowed in the processing queue.
int	ast_logger_register_level (const char *name)
	Register a new logger level.
int	ast_logger_remove_channel (const char *log_channel)
	Delete the specified log channel.
int	ast_logger_rotate ()
	Reload logger while rotating log files.
int	ast_logger_rotate_channel (const char *log_channel)
	Rotate the specified log channel.
void	ast_logger_set_over_threshold_queue_limit (int limit)
	Set the threshold for the maximum number of WARNING/ERROR messages allowed in the processing queue that can exceed the logger queue's threshold. This acts as a buffer for WARNING/ERROR messages so that we can continue to queue them while discarding other message types. This threshold sits on top of the logger queue's message threshold, so the actual queue size will be the logger queue threshold PLUS this threshold.
void	ast_logger_set_queue_limit (int queue_limit)
	Set the maximum number of messages allowed in the processing queue.
void	ast_logger_unregister_level (const char *name)
	Unregister a previously registered logger level.
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 callid from the thread
	AST_THREADSTORAGE_CUSTOM_SCOPE (callid_group_name, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (log_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (my_verb_console, NULL, verb_console_free, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (unique_callid, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (verbose_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (verbose_build_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_RAW (in_safe_log)
int	ast_verb_console_get (void)
	Get this thread's console verbosity level.
void	ast_verb_console_register (int *level)
	Register this thread's console verbosity level pointer.
void	ast_verb_console_set (int verb_level)
	Set this thread's console verbosity level.
void	ast_verb_console_unregister (void)
	Unregister this thread's console verbosity level.
void	ast_verb_update (void)
	Re-evaluate the system max verbosity level (ast_verb_sys_level).
static int	callid_group_remove_filters (void)
static int	callid_group_set_filter (const char *group, int enabled)
static int	callid_logging_enabled (void)
static int	callid_set_chanloggroup (const char *group)
void	close_logger (void)
static int	custom_level_still_exists (char **levels, char *level, size_t len)
	Checks if level exists in array of level names.
static struct logchannel *	find_logchannel (const char *channel)
	Find a particular logger channel by name.
static struct logmsg *	flush_logger_queue_messages (struct logmsg *start, int amount)
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 const char *	get_callid_group (void)
static char *	handle_logger_add_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_chanloggroup_filter (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_filter_reset (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_filter_show (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.
static char *	handle_logger_show_levels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command to show logging levels.
int	init_logger (void)
static int	init_logger_chain (const char *altconf)
	Read config, setup channels.
static int	load_module (void)
static int	log_group_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
static int	logger_add_verbose_magic (struct logmsg *logmsg, char *buf, size_t size)
static int	logger_get_dynamic_level (const char *name)
static void	logger_print_normal (struct logmsg *logmsg)
	Print a normal log message to the channels.
static void	logger_queue_init (void)
static int	logger_queue_restart (int queue_rotate)
static int	logger_queue_rt_start (void)
void	logger_queue_start (void)
	Start the ast_queue_log() logger.
static int	logger_register_level (const char *name)
static void *	logger_thread (void *data)
	Actual logging thread.
static int	logger_unregister_level (const char *name)
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.
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 = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .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 int	callid_filtering = 0
struct chan_group_lock_list	chan_group_lock_list = AST_RWLIST_HEAD_INIT_VALUE
static struct ast_cli_entry	cli_logger []
static int	close_logger_thread = 0
static const int	colors [NUMLOGLEVELS]
	Colors used in the console for logging.
static char *	custom_dynamic_levels [NUMLOGLEVELS]
	Custom dynamic logging levels added by the user.
static char	dateformat [256] = "%b %e %T"
static unsigned int	discard_all_new_msgs
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 struct logmsg *	last_logmsg_checked_for_discard = NULL
static char *	levels [NUMLOGLEVELS]
	Logging channels used in the Asterisk logging system.
static struct ast_custom_function	log_group_function
static struct logchannels	logchannels = AST_RWLIST_HEAD_INIT_VALUE
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_over_threshold_limit = 200
static int	logger_queue_size
static struct logmsgs	logmsgs = AST_DLLIST_HEAD_INIT_VALUE
static pthread_t	logthread = AST_PTHREADT_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 verb_consoles	verb_consoles = AST_RWLIST_HEAD_INIT_VALUE
static ast_mutex_t	verb_update_lock = AST_MUTEX_INIT_VALUE

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 "

FORMATL2

#define FORMATL2   "%5s %s\n"

LOG_BUF_INIT_SIZE

#define LOG_BUF_INIT_SIZE   256

Definition at line 287 of file logger.c.

LOGMSG_SIZE

#define LOGMSG_SIZE   MAX(BUFSIZ, 8192)

Definition at line 108 of file logger.c.

VERBOSE_BUF_INIT_SIZE

#define VERBOSE_BUF_INIT_SIZE   256

Definition at line 284 of file logger.c.

Enumeration Type Documentation

logmsgtypes

enum logmsgtypes

Enumerator
LOGMSG_NORMAL
LOGMSG_VERBOSE

Definition at line 172 of file logger.c.

                 {
    LOGMSG_NORMAL = 0,
    LOGMSG_VERBOSE,
};

logtypes

enum logtypes

Enumerator
LOGTYPE_SYSLOG
LOGTYPE_FILE
LOGTYPE_CONSOLE

Definition at line 137 of file logger.c.

              {
    LOGTYPE_SYSLOG,
    LOGTYPE_FILE,
    LOGTYPE_CONSOLE,
};

rotatestrategy

enum rotatestrategy

Enumerator
NONE
SEQUENTIAL
ROTATE
TIMESTAMP

Definition at line 110 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_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_10 are defined.

Version

11 added level parameter

Definition at line 2617 of file logger.c.

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

References __ast_verbose_ap(), and ast_read_threadstorage_callid().

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

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

References __LOG_VERBOSE, and ast_log_full().

Referenced by __ast_verbose(), __ast_verbose_callid(), and ast_log_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 2629 of file logger.c.

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

References __ast_verbose_ap().

__reg_module()

static void __reg_module ( void  )

static

Definition at line 3042 of file logger.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 3042 of file logger.c.

_handle_SIGXFSZ()

static void _handle_SIGXFSZ ( int  sig )

static

Definition at line 1900 of file logger.c.

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

References filesize_reload_needed.

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

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

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

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

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

References ast_log, ast_threadstorage_get(), and LOG_ERROR.

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(), jingle_action_hook(), jingle_outgoing_hook(), mixmonitor_thread(), socket_process_helper(), and softmix_mixing_thread().

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

{
    ast_callid *id = ast_threadstorage_get(&unique_callid, sizeof(*id));
 
    if (!id) {
        return -1;
    }
 
    *id = callid;
 
    return 0;
}

References ast_threadstorage_get().

Referenced by autoservice_run(), and bridge_manager_service().

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

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

References ast_threadstorage_get().

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

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

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

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

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

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

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

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_init_event(), and mwi_thread().

ast_child_verbose()

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

Definition at line 929 of file logger.c.

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

References ast_free, ast_malloc, and NULL.

Referenced by launch_script().

ast_create_callid()

ast_callid ast_create_callid

(

void

)

factory function to create a new uniquely identifying callid.

Returns

The call id

Definition at line 2282 of file logger.c.

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

References ast_atomic_fetchadd_int(), and next_unique_callid.

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

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

{
    return logger_initialized;
}

References logger_initialized.

Referenced by check_init().

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

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

References ast_log_ap(), logmsg::file, logmsg::function, logmsg::level, and logmsg::line.

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

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

References __ast_verbose_ap(), __LOG_VERBOSE, ast_log_full(), ast_read_threadstorage_callid(), logmsg::callid, logmsg::file, logmsg::function, logmsg::level, and logmsg::line.

Referenced by ast_log(), and module_load_error().

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

{
#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) */
}

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_nonrunning(), and AST_TEST_DEFINE().

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

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

References ast_log_full(), logmsg::callid, logmsg::file, logmsg::function, logmsg::level, and logmsg::line.

Referenced by ast_channel_destructor().

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

{
    int hidecli = 0;
    struct logmsg *logmsg = NULL;
 
    if (level == __LOG_VERBOSE && ast_opt_remote && ast_opt_exec) {
        return;
    }
 
    if (callid_filtering && !callid_logging_enabled()) {
        switch (level) {
        case __LOG_VERBOSE:
        case __LOG_DEBUG:
        case __LOG_TRACE:
        case __LOG_DTMF:
            hidecli = 1; /* Hide the message from the CLI, but still log to any log files */
        default: /* Always show NOTICE, WARNING, ERROR, etc. */
            break;
        }
        return;
    }
 
    AST_DLLIST_LOCK(&logmsgs);
    if (logger_queue_size >= logger_queue_limit && !close_logger_thread) {
        if (!high_water_alert && !close_logger_thread) {
            logmsg = format_log_message(__LOG_WARNING, 0, "logger", 0, "***", 0,
                "Log queue threshold (%d) exceeded.  Discarding non-warning/error messages.\n", logger_queue_limit);
            AST_DLLIST_INSERT_TAIL(&logmsgs, logmsg, list);
            high_water_alert = 1;
            ast_cond_signal(&logcond);
        }
 
        if (discard_all_new_msgs || (level != __LOG_WARNING && level != __LOG_ERROR)) {
            logger_messages_discarded++;
            AST_DLLIST_UNLOCK(&logmsgs);
            return;
        }
 
        if (logger_queue_size >= logger_queue_limit + logger_queue_over_threshold_limit) {
            int size_before = logger_queue_size;
            struct logmsg *msg_ptr;
 
            msg_ptr = last_logmsg_checked_for_discard ?
                AST_DLLIST_NEXT(last_logmsg_checked_for_discard, list) : AST_DLLIST_FIRST(&logmsgs);
 
            msg_ptr = flush_logger_queue_messages(msg_ptr, logger_queue_over_threshold_limit);
            last_logmsg_checked_for_discard = msg_ptr ? msg_ptr : last_logmsg_checked_for_discard;
 
            if (size_before == logger_queue_size) {
                /* We didn't flush anything, so we have to discard the message */
                discard_all_new_msgs = 1;
                logger_messages_discarded++;
                logmsg = format_log_message(__LOG_WARNING, 0, "logger", 0, "***", 0,
                    "Log queue does not have any non-WARNING/ERROR messages left to discard. "
                    "Discarding all new messages.");
                AST_DLLIST_INSERT_TAIL(&logmsgs, logmsg, list);
                ast_cond_signal(&logcond);
                AST_DLLIST_UNLOCK(&logmsgs);
                return;
            }
            else {
                /* We flushed some non-WARNING/ERROR messages */
                logmsg = format_log_message(__LOG_WARNING, 0, "logger", 0, "***", 0,
                    "Log queue WARNING / ERROR threshold (%d) exceeded. Discarded %d oldest non-"
                    "WARNING/ERROR messages.\n", logger_queue_over_threshold_limit, size_before - logger_queue_size);
                AST_DLLIST_INSERT_TAIL(&logmsgs, logmsg, list);
                ast_cond_signal(&logcond);
            }
        }
    }
    AST_DLLIST_UNLOCK(&logmsgs);
 
    logmsg = format_log_message_ap(level, sublevel, file, line, function, callid, fmt, ap);
    if (!logmsg) {
        return;
    }
 
    logmsg->hidecli = hidecli;
 
    /* 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_DLLIST_LOCK(&logmsgs);
        if (close_logger_thread) {
            /* Logger is either closing or closed.  We cannot log this message. */
            logmsg_free(logmsg);
        } else {
            AST_DLLIST_INSERT_TAIL(&logmsgs, logmsg, list);
            logger_queue_size++;
            ast_cond_signal(&logcond);
        }
        AST_DLLIST_UNLOCK(&logmsgs);
    } else {
        logger_print_normal(logmsg);
        logmsg_free(logmsg);
    }
}

References __LOG_DEBUG, __LOG_DTMF, __LOG_ERROR, __LOG_TRACE, __LOG_VERBOSE, __LOG_WARNING, ast_cond_signal, AST_DLLIST_FIRST, AST_DLLIST_INSERT_TAIL, AST_DLLIST_LOCK, AST_DLLIST_NEXT, AST_DLLIST_UNLOCK, ast_opt_exec, ast_opt_remote, AST_PTHREADT_NULL, logmsg::callid, callid_filtering, callid_logging_enabled(), close_logger_thread, discard_all_new_msgs, logmsg::file, flush_logger_queue_messages(), format_log_message(), format_log_message_ap(), logmsg::function, logmsg::hidecli, high_water_alert, last_logmsg_checked_for_discard, logmsg::level, logmsg::line, logmsg::list, logcond, logger_messages_discarded, logger_print_normal(), logger_queue_limit, logger_queue_over_threshold_limit, logger_queue_size, logmsg_free(), logthread, NULL, and logmsg::sublevel.

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

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

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

References ast_log_full(), ast_read_threadstorage_callid(), ast_threadstorage_get_ptr(), ast_threadstorage_set_ptr(), logmsg::callid, logmsg::file, logmsg::function, logmsg::level, logmsg::line, and NULL.

Referenced by __ast_str_helper(), and ast_log_backtrace().

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

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

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(), logchannel::components, find_logchannel(), global_logmask, logchannel::list, logchannel::logmask, and make_logchannel().

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

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

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

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, levels, logchannel::logmask, LOGTYPE_CONSOLE, LOGTYPE_SYSLOG, NULL, and logchannel::type.

Referenced by ast_ari_asterisk_list_log_channels().

ast_logger_get_dateformat()

const char * ast_logger_get_dateformat

(

void

)

Get the logger configured date format.

Returns

The date format string

Since

13.0.0

Definition at line 2994 of file logger.c.

{
    return dateformat;
}

References dateformat.

Referenced by set_header().

ast_logger_get_dynamic_level()

int ast_logger_get_dynamic_level

(

const char *

name

)

Retrieve dynamic logging level id.

Parameters

name	The name of the level

Returns

The unique integer id for the given level

Return values

-1	if level name not found

Definition at line 2947 of file logger.c.

{
    int level = -1;
 
    AST_RWLIST_RDLOCK(&logchannels);
 
    level = logger_get_dynamic_level(name);
 
    AST_RWLIST_UNLOCK(&logchannels);
 
    return level;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, logger_get_dynamic_level(), and name.

Referenced by log_exec().

ast_logger_get_over_threshold_queue_limit()

int ast_logger_get_over_threshold_queue_limit

(

void

)

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

Returns

Over threshold queue limit

Definition at line 3014 of file logger.c.

{
    return logger_queue_over_threshold_limit;
}

References logger_queue_over_threshold_limit.

Referenced by handle_cli_queue_over_threshold_test().

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

{
    return logger_queue_limit;
}

References logger_queue_limit.

Referenced by handle_cli_queue_over_threshold_test(), and handle_cli_queue_test().

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

{
    int available = 0;
 
    AST_RWLIST_WRLOCK(&logchannels);
    available = logger_register_level(name);
    AST_RWLIST_UNLOCK(&logchannels);
 
    return available;
}

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

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

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

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

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_over_threshold_test(), handle_cli_queue_test(), and handle_logger_remove_channel().

ast_logger_rotate()

int ast_logger_rotate

(

void

)

Reload logger while rotating log files.

Definition at line 1323 of file logger.c.

{
    return reload_logger(1, NULL);
}

References NULL, and reload_logger().

Referenced by action_loggerrotate().

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

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

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

ast_logger_set_over_threshold_queue_limit()

void ast_logger_set_over_threshold_queue_limit

(

int

limit

)

Set the threshold for the maximum number of WARNING/ERROR messages allowed in the processing queue that can exceed the logger queue's threshold. This acts as a buffer for WARNING/ERROR messages so that we can continue to queue them while discarding other message types. This threshold sits on top of the logger queue's message threshold, so the actual queue size will be the logger queue threshold PLUS this threshold.

Parameters

limit

Definition at line 3009 of file logger.c.

{
    logger_queue_over_threshold_limit = limit;
}

References logger_queue_over_threshold_limit.

Referenced by handle_cli_queue_over_threshold_test().

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

Definition at line 2999 of file logger.c.

{
    logger_queue_limit = queue_limit;
}

References logger_queue_limit.

Referenced by handle_cli_queue_over_threshold_test(), and handle_cli_queue_test().

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

Since

1.8

Definition at line 2976 of file logger.c.

{
    int x;
 
    AST_RWLIST_WRLOCK(&logchannels);
    x = logger_unregister_level(name);
 
    if (x) {
        update_logchannels();
    }
 
    AST_RWLIST_UNLOCK(&logchannels);
 
    if (x) {
        ast_debug(1, "Unregistered dynamic logger level '%s' with index %u.\n", name, x);
    }
}

References ast_debug, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, logger_unregister_level(), name, and update_logchannels().

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

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 3042 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 973 of file logger.c.

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

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, qlog, 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().

ast_read_threadstorage_callid()

ast_callid ast_read_threadstorage_callid

(

void

)

extracts the callid 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 2287 of file logger.c.

{
    ast_callid *callid;
 
    callid = ast_threadstorage_get(&unique_callid, sizeof(*callid));
 
    return callid ? *callid : 0;
}

References ast_threadstorage_get().

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(), callid_set_chanloggroup(), common_recall_channel_setup(), iax2_request(), jingle_alloc(), launch_monitor_thread(), local_request_with_stream_topology(), media_request_helper(), and socket_process().

AST_THREADSTORAGE_CUSTOM_SCOPE() [1/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	callid_group_name	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [2/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	log_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [3/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	my_verb_console	,
		NULL	,
		verb_console_free	,
		static
	)

Thread specific console verbosity level node.

AST_THREADSTORAGE_CUSTOM_SCOPE() [4/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	unique_callid	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [5/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	verbose_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [6/6]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	verbose_build_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_RAW()

AST_THREADSTORAGE_RAW

(

in_safe_log

)

ast_verb_console_get()

int ast_verb_console_get

(

void

)

Get this thread's console verbosity level.

Returns

verbosity level of the console.

Definition at line 2740 of file logger.c.

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

References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_threadstorage_get(), and option_verbose.

Referenced by handle_show_settings(), and handle_verbose().

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.

Definition at line 2713 of file logger.c.

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

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

Referenced by netconsole().

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.

Definition at line 2758 of file logger.c.

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

References AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_threadstorage_get(), ast_verb_update(), and option_verbose.

Referenced by handle_verbose().

ast_verb_console_unregister()

void ast_verb_console_unregister

(

void

)

Unregister this thread's console verbosity level.

Definition at line 2729 of file logger.c.

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

References ast_threadstorage_get(), and verb_console_unregister().

Referenced by netconsole().

ast_verb_update()

void ast_verb_update

(

void

)

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

Definition at line 2651 of file logger.c.

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

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

callid_group_remove_filters()

static int callid_group_remove_filters ( void  )

static

Definition at line 1710 of file logger.c.

{
    int i = 0;
    struct chan_group_lock *cgl;
 
    AST_RWLIST_WRLOCK(&chan_group_lock_list);
    while ((cgl = AST_RWLIST_REMOVE_HEAD(&chan_group_lock_list, entry))) {
        ast_free(cgl);
        i++;
    }
    callid_filtering = 0;
    AST_RWLIST_UNLOCK(&chan_group_lock_list);
    return i;
}

References ast_free, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, callid_filtering, and chan_group_lock::entry.

Referenced by close_logger(), and handle_logger_filter_reset().

callid_group_set_filter()

static int callid_group_set_filter ( const char *  group, int  enabled  )

static

Definition at line 1725 of file logger.c.

{
    struct chan_group_lock *cgl;
 
    AST_RWLIST_WRLOCK(&chan_group_lock_list);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&chan_group_lock_list, cgl, entry) {
        if (!strcmp(group, cgl->name)) {
            if (!enabled) {
                AST_RWLIST_REMOVE_CURRENT(entry);
                ast_free(cgl);
            }
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    if (!enabled) {
        if (AST_LIST_EMPTY(&chan_group_lock_list)) {
            callid_filtering = 0;
        }
        AST_RWLIST_UNLOCK(&chan_group_lock_list);
        return 0;
    }
 
    if (!cgl) {
        cgl = ast_calloc(1, sizeof(*cgl) + strlen(group) + 1);
        if (!cgl) {
            AST_RWLIST_UNLOCK(&chan_group_lock_list);
            return -1;
        }
        strcpy(cgl->name, group); /* Safe */
        AST_RWLIST_INSERT_HEAD(&chan_group_lock_list, cgl, entry);
    } /* else, already existed, and was already enabled, no change */
    callid_filtering = 1;
    AST_RWLIST_UNLOCK(&chan_group_lock_list);
    return 0;
}

References ast_calloc, ast_free, AST_LIST_EMPTY, AST_RWLIST_INSERT_HEAD, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, callid_filtering, enabled, chan_group_lock::entry, and chan_group_lock::name.

Referenced by handle_logger_chanloggroup_filter().

callid_logging_enabled()

static int callid_logging_enabled ( void  )

static

Definition at line 1763 of file logger.c.

{
    struct chan_group_lock *cgl;
    const char *callidgroup;
 
    if (!callid_filtering) {
        return 1; /* Everything enabled by default, if no filtering */
    }
 
    callidgroup = get_callid_group();
    if (!callidgroup) {
        return 0; /* Filtering, but no call group, not enabled */
    }
 
    AST_RWLIST_RDLOCK(&chan_group_lock_list);
    AST_RWLIST_TRAVERSE(&chan_group_lock_list, cgl, entry) {
        if (!strcmp(callidgroup, cgl->name)) {
            break;
        }
    }
    AST_RWLIST_UNLOCK(&chan_group_lock_list);
    return cgl ? 1 : 0; /* If found, enabled, otherwise not */
}

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, callid_filtering, chan_group_lock::entry, get_callid_group(), and chan_group_lock::name.

Referenced by ast_log_full().

callid_set_chanloggroup()

static int callid_set_chanloggroup ( const char *  group )

static

Definition at line 1678 of file logger.c.

{
    /* Use threadstorage for constant time access, rather than a linked list */
    ast_callid callid;
    char **callid_group;
 
    callid = ast_read_threadstorage_callid();
    if (!callid) {
        /* Should never be called on non-PBX threads */
        ast_assert(0);
        return -1;
    }
 
    callid_group = ast_threadstorage_get(&callid_group_name, sizeof(*callid_group));
 
    if (!group) {
        /* Remove from list */
        if (!*callid_group) {
            return 0; /* Wasn't in any group to begin with */
        }
        ast_free(*callid_group);
        return 0; /* Set Call ID group for the first time */
    }
    /* Existing group */
    ast_free(*callid_group);
    *callid_group = ast_strdup(group);
    if (!*callid_group) {
        return -1;
    }
    return 0; /* Set Call ID group for the first time */
}

References ast_assert, ast_free, ast_read_threadstorage_callid(), ast_strdup, and ast_threadstorage_get().

Referenced by log_group_write().

close_logger()

void close_logger

(

void

)

Provided by logger.c

Definition at line 2234 of file logger.c.

{
    struct logchannel *f = NULL;
 
    ast_logger_category_unload();
 
    ast_custom_function_unregister(&log_group_function);
    ast_cli_unregister_multiple(cli_logger, ARRAY_LEN(cli_logger));
 
    logger_initialized = 0;
 
    /* Stop logger thread */
    AST_DLLIST_LOCK(&logmsgs);
    close_logger_thread = 1;
    ast_cond_signal(&logcond);
    AST_DLLIST_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);
    }
 
    callid_group_remove_filters();
 
    closelog(); /* syslog */
 
    AST_RWLIST_UNLOCK(&logchannels);
}

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_cond_signal, ast_custom_function_unregister(), AST_DLLIST_LOCK, AST_DLLIST_UNLOCK, ast_free, AST_LIST_REMOVE_HEAD, ast_logger_category_unload(), AST_PTHREADT_NULL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, callid_group_remove_filters(), cli_logger, close_logger_thread, logchannel::fileptr, logchannel::list, log_group_function, logcond, logger_initialized, logthread, NULL, and qlog.

Referenced by really_quit().

custom_level_still_exists()

static int custom_level_still_exists ( char **  levels, char *  level, size_t  len  )

static

Checks if level exists in array of level names.

Parameters

levels	Array of level names
level	Name to search for
len	Size of levels

Return values

1	Found
0	Not Found

Definition at line 752 of file logger.c.

{
    int i;
    for (i = 0; i < len; i++) {
        if (!strcmp(levels[i], level)) {
            return 1;
        }
    }
    return 0;
}

References len(), and levels.

Referenced by init_logger_chain().

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

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

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

flush_logger_queue_messages()

static struct logmsg * flush_logger_queue_messages ( struct logmsg *  start, int  amount  )

static

Definition at line 2386 of file logger.c.

{
    struct logmsg *current, *previous;
    int flushed = 0;
 
    previous = NULL;
    current = start;
 
    while (current) {
        struct logmsg *next;
 
        if (current->level == __LOG_WARNING || current->level == __LOG_ERROR) {
            previous = current;
            current = AST_DLLIST_NEXT(current, list);
            continue;
        }
 
        next = AST_DLLIST_NEXT(current, list);
        AST_DLLIST_REMOVE(&logmsgs, current, list);
        logmsg_free(current);
        current = next;
        logger_queue_size--;
        flushed++;
 
        if (flushed >= amount) {
            break;
        }
    }
 
    return previous;
}

References __LOG_ERROR, __LOG_WARNING, AST_DLLIST_NEXT, AST_DLLIST_REMOVE, current, logmsg::list, logger_queue_size, logmsg_free(), and NULL.

Referenced by ast_log_full().

format_log_default()

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

static

Definition at line 407 of file logger.c.

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

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

format_log_json()

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

static

Definition at line 289 of file logger.c.

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

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

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

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

References logmsg::callid, logmsg::file, format_log_message_ap(), logmsg::function, logmsg::level, logmsg::line, and logmsg::sublevel.

Referenced by ast_log_full(), and logger_thread().

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

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

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, levels, logmsg::line, LOG_BUF_INIT_SIZE, LOGMSG_NORMAL, LOGMSG_SIZE, LOGMSG_VERBOSE, logmsg::lwp, NULL, logmsg::sublevel, and logmsg::type.

Referenced by ast_log_full(), and format_log_message().

format_log_plain()

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

static

Definition at line 471 of file logger.c.

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

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

get_callid_group()

static const char * get_callid_group ( void  )

static

Definition at line 1671 of file logger.c.

{
    char **callid_group;
    callid_group = ast_threadstorage_get(&callid_group_name, sizeof(*callid_group));
    return callid_group ? *callid_group : NULL;
}

References ast_threadstorage_get(), and NULL.

Referenced by callid_logging_enabled().

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

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

References a, 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, NULL, and ast_cli_entry::usage.

handle_logger_chanloggroup_filter()

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

static

Definition at line 1802 of file logger.c.

{
    int enabled;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "logger filter changroup";
        e->usage =
            "Usage: logger filter changroup <group> {on|off}\n"
            "       Add or remove channel groups from log filtering.\n"
            "       If filtering is active, only channels assigned\n"
            "       to a group that has been enabled using this command\n"
            "       will have execution shown in the CLI.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc < 5) {
        return CLI_SHOWUSAGE;
    }
 
    enabled = ast_true(a->argv[4]) ? 1 : 0;
    if (callid_group_set_filter(a->argv[3], enabled)) {
        ast_cli(a->fd, "Failed to set channel group filter for group %s\n", a->argv[3]);
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, "Logging of channel group '%s' is now %s\n", a->argv[3], enabled ? "enabled" : "disabled");
    return CLI_SUCCESS;
}

References a, ast_cli(), ast_true(), callid_group_set_filter(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, enabled, NULL, and ast_cli_entry::usage.

handle_logger_filter_reset()

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

static

Definition at line 1864 of file logger.c.

{
    int removed;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "logger filter reset";
        e->usage =
            "Usage: logger filter reset\n"
            "       Reset the logger filter.\n"
            "       This removes any channel groups from filtering\n"
            "       (all channel execution will be shown)\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    removed = callid_group_remove_filters();
 
    ast_cli(a->fd, "Log filtering has been reset (%d filter%s removed)\n", removed, ESS(removed));
    return CLI_SUCCESS;
}

References a, ast_cli(), callid_group_remove_filters(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ESS, NULL, and ast_cli_entry::usage.

handle_logger_filter_show()

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

static

Definition at line 1834 of file logger.c.

{
    int i = 0;
    struct chan_group_lock *cgl;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "logger filter show";
        e->usage =
            "Usage: logger filter show\n"
            "       Show current logger filtering settings.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    AST_RWLIST_RDLOCK(&chan_group_lock_list);
    AST_RWLIST_TRAVERSE(&chan_group_lock_list, cgl, entry) {
        ast_cli(a->fd, "%3d %-32s\n", ++i, cgl->name);
    }
    AST_RWLIST_UNLOCK(&chan_group_lock_list);
 
    if (i) {
        ast_cli(a->fd, "%d channel group%s currently enabled\n", i, ESS(i));
    } else {
        ast_cli(a->fd, "No filtering currently active\n");
    }
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, chan_group_lock::entry, ESS, chan_group_lock::name, NULL, and ast_cli_entry::usage.

handle_logger_reload()

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

static

Definition at line 1285 of file logger.c.

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

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

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

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

References a, 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, logchannel::filename, logchannel::list, NULL, and ast_cli_entry::usage.

handle_logger_rotate()

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

static

Definition at line 1304 of file logger.c.

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

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

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

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

References a, 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, levels, NULL, and ast_cli_entry::usage.

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

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

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

handle_logger_show_levels()

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

static

CLI command to show logging levels.

Definition at line 1489 of file logger.c.

{
#define FORMATL2    "%5s %s\n"
    unsigned int level;
    switch (cmd) {
    case CLI_INIT:
        e->command = "logger show levels";
        e->usage =
            "Usage: logger show levels\n"
            "       List configured logger levels.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    ast_cli(a->fd, FORMATL2, "Level", "Name");
    ast_cli(a->fd, FORMATL2, "-----", "----");
    AST_RWLIST_RDLOCK(&logchannels);
    for (level = 0; level < ARRAY_LEN(levels); level++) {
        if (levels[level]) {
            ast_cli(a->fd, "%5d %s\n", level, levels[level]);
        }
    }
    AST_RWLIST_UNLOCK(&logchannels);
    ast_cli(a->fd, "\n");
 
    return CLI_SUCCESS;
}

References a, ARRAY_LEN, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, FORMATL2, levels, NULL, and ast_cli_entry::usage.

init_logger()

int init_logger

(

void

)

Provided by logger.c

Definition at line 2191 of file logger.c.

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

References ARRAY_LEN, ast_cli_register_multiple, ast_cond_destroy, ast_cond_init, ast_config_AST_LOG_DIR, ast_custom_function_register, 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(), cli_logger, handle_SIGXFSZ, init_logger_chain(), logmsgs::lock, LOG_ERROR, log_group_function, logcond, logger_initialized, logger_thread(), logthread, and NULL.

Referenced by asterisk_daemon().

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

{
    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);
        }
    }
    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_levels"))) {
        char *customlogs = ast_strdupa(s);
        char *logfile;
        char *new_custom_levels[16] = { };
        unsigned int level, new_level = 0;
 
        /* get the custom levels we need to register or reload */
        while ((logfile = strsep(&customlogs, ","))) {
            new_custom_levels[new_level++] = logfile;
        }
 
        /* unregister existing custom levels, if they're not still
            specified in customlogs, to make room for new levels */
        for (level = 16; level < ARRAY_LEN(levels); level++) {
            if (levels[level] && custom_dynamic_levels[level] &&
                !custom_level_still_exists(new_custom_levels, levels[level], ARRAY_LEN(new_custom_levels))) {
                logger_unregister_level(levels[level]);
                custom_dynamic_levels[level] = 0;
            }
        }
 
        new_level = 0;
        while ((logfile = new_custom_levels[new_level++])) {
            /* Lock already held, so directly register the level,
                unless it's already registered (as during reload) */
            if (logger_get_dynamic_level(logfile) == -1) {
                int custom_level = logger_register_level(logfile);
                custom_dynamic_levels[custom_level] = logfile;
            }
        }
    }
 
    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;
}

References __LOG_ERROR, ARRAY_LEN, ast_config_destroy(), ast_config_load2(), ast_console_puts_mutable(), ast_copy_string(), ast_free, AST_RWLIST_INSERT_HEAD, AST_RWLIST_REMOVE_HEAD, ast_strdupa, ast_true(), ast_variable_browse(), ast_variable_retrieve(), CONFIG_STATUS_FILEINVALID, custom_dynamic_levels, custom_level_still_exists(), dateformat, display_callids, errno, exec_after_rotate, global_logmask, hostname, levels, logfiles, logger_get_dynamic_level(), logger_queue_limit, logger_register_level(), logger_unregister_level(), logchannel::logmask, make_logchannel(), NONE, NULL, qlog, queue_log_name, QUEUELOG, ROTATE, S_OR, SEQUENTIAL, strsep(), TIMESTAMP, and var.

Referenced by ast_logger_rotate_channel(), init_logger(), and reload_logger().

load_module()

static int load_module ( void  )

static

Definition at line 3029 of file logger.c.

{
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS.

log_group_write()

static int log_group_write ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Definition at line 1787 of file logger.c.

{
    int res = callid_set_chanloggroup(value);
    if (res) {
        ast_log(LOG_ERROR, "Failed to set channel log group for %s\n", ast_channel_name(chan));
        return -1;
    }
    return 0;
}

References ast_channel_name(), ast_log, callid_set_chanloggroup(), LOG_ERROR, and value.

logger_add_verbose_magic()

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

static

Definition at line 349 of file logger.c.

{
    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_10, strlen(VERBOSE_PREFIX_10))) {
            magic = -11;
        } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_9, strlen(VERBOSE_PREFIX_9))) {
            magic = -10;
        } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_8, strlen(VERBOSE_PREFIX_8))) {
            magic = -9;
        } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_7, strlen(VERBOSE_PREFIX_7))) {
            magic = -8;
        } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_6, strlen(VERBOSE_PREFIX_6))) {
            magic = -7;
        } else if (!strncmp(logmsg->message, VERBOSE_PREFIX_5, strlen(VERBOSE_PREFIX_5))) {
            magic = -6;
        } else 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;
}

References ast_str_append(), ast_str_append_substr(), ast_str_buffer(), ast_str_reset(), ast_str_thread_get(), buf, logmsg::message, logmsg::sublevel, VERBOSE_BUF_INIT_SIZE, VERBOSE_PREFIX_1, VERBOSE_PREFIX_10, VERBOSE_PREFIX_2, VERBOSE_PREFIX_3, VERBOSE_PREFIX_4, VERBOSE_PREFIX_5, VERBOSE_PREFIX_6, VERBOSE_PREFIX_7, VERBOSE_PREFIX_8, and VERBOSE_PREFIX_9.

Referenced by format_log_default().

logger_get_dynamic_level()

static int logger_get_dynamic_level ( const char *  name )

static

Definition at line 2929 of file logger.c.

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

References ARRAY_LEN, levels, and name.

Referenced by ast_logger_get_dynamic_level(), init_logger_chain(), and logger_unregister_level().

logger_print_normal()

static void logger_print_normal ( struct logmsg *  logmsg )

static

Print a normal log message to the channels.

Definition at line 1912 of file logger.c.

{
    struct logchannel *chan = NULL;
    char buf[LOGMSG_SIZE];
    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, sizeof(buf))) {
                        syslog(syslog_level, "%s", buf);
                    }
                }
                break;
            case LOGTYPE_CONSOLE:
                if (!logmsg->hidecli && !chan->formatter.format_log(chan, logmsg, buf, sizeof(buf))) {
                    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, sizeof(buf))) {
                        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));
                        }
 
                        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;
}

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::hidecli, logmsg::level, logchannel::list, logchannel::logmask, LOGMSG_SIZE, 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().

logger_queue_init()

static void logger_queue_init ( void  )

static

Definition at line 2140 of file logger.c.

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

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

Referenced by logger_queue_start().

logger_queue_restart()

static int logger_queue_restart ( int  queue_rotate )

static

Definition at line 1192 of file logger.c.

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

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

Referenced by reload_logger().

logger_queue_rt_start()

static int logger_queue_rt_start ( void  )

static

Definition at line 1157 of file logger.c.

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

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

Referenced by logger_queue_init(), and logger_queue_restart().

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.

Definition at line 2175 of file logger.c.

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

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

logger_register_level()

static int logger_register_level ( const char *  name )

static

Definition at line 2881 of file logger.c.

{
    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);
 
            return -1;
        }
    }
 
    if (!available) {
        ast_log(LOG_WARNING,
            "Unable to register dynamic logger level '%s'; maximum number of levels registered.\n",
            name);
 
        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;
}

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

Referenced by ast_logger_register_level(), and init_logger_chain().

logger_thread()

static void * logger_thread ( void *  data )

static

Actual logging thread.

Definition at line 2083 of file logger.c.

{
    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_DLLIST_LOCK(&logmsgs);
        if (AST_DLLIST_EMPTY(&logmsgs)) {
            if (close_logger_thread) {
                AST_DLLIST_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_DLLIST_INSERT_TAIL(&logmsgs, msg, list);
            }
            high_water_alert = 0;
            logger_messages_discarded = 0;
        }
 
        discard_all_new_msgs = 0;
        last_logmsg_checked_for_discard = NULL;
 
        next = AST_DLLIST_FIRST(&logmsgs);
        AST_DLLIST_HEAD_INIT_NOLOCK(&logmsgs);
        logger_queue_size = 0;
        AST_DLLIST_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_DLLIST_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;
}

References __LOG_WARNING, ast_cond_wait, AST_DLLIST_EMPTY, AST_DLLIST_FIRST, AST_DLLIST_HEAD_INIT_NOLOCK, AST_DLLIST_INSERT_TAIL, AST_DLLIST_LOCK, AST_DLLIST_NEXT, AST_DLLIST_UNLOCK, close_logger_thread, discard_all_new_msgs, format_log_message(), high_water_alert, last_logmsg_checked_for_discard, logmsg::list, logmsgs::lock, logcond, logger_messages_discarded, logger_print_normal(), logger_queue_size, logmsg_free(), and NULL.

Referenced by init_logger().

logger_unregister_level()

static int logger_unregister_level ( const char *  name )

static

Definition at line 2960 of file logger.c.

                                                     {
    unsigned int x;
 
    x = logger_get_dynamic_level(name);
    if (x == -1) {
        return 0;
    }
    /* 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;
    return x;
}

References ast_free, global_logmask, levels, logger_get_dynamic_level(), name, and NULL.

Referenced by ast_logger_unregister_level(), and init_logger_chain().

logmsg_free()

static void logmsg_free ( struct logmsg *  msg )

static

Definition at line 195 of file logger.c.

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

References ast_free, and ast_string_field_free_memory.

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

make_components()

static void make_components ( struct logchannel *  chan )

static

Definition at line 521 of file logger.c.

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

References __LOG_VERBOSE, ARRAY_LEN, ast_strdupa, ast_strip(), ast_strlen_zero(), logchannel::components, end, logchannel::filename, logchannel::formatter, levels, logformatter_default, logformatter_json, logformatter_plain, logchannel::logmask, LOGTYPE_CONSOLE, logformatter::name, strsep(), logchannel::type, and logchannel::verbosity.

Referenced by make_logchannel(), and update_logchannels().

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

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

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

make_logchannel()

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

static

Definition at line 659 of file logger.c.

{
    struct logchannel *chan;
    const 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;
}

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

reload_logger()

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

static

Definition at line 1220 of file logger.c.

{
    int queue_rotate = rotate;
    struct logchannel *f;
    int res = 0;
 
    AST_RWLIST_WRLOCK(&logchannels);
 
    if (qlog) {
        if (rotate < 0) {
            /* Check filesize - this one typically doesn't need an auto-rotate */
            if (ftello(qlog) > 0x40000000) { /* Arbitrarily, 1 GB */
                fclose(qlog);
                qlog = NULL;
            } else {
                queue_rotate = 0;
            }
        } else {
            fclose(qlog);
            qlog = NULL;
        }
    } else {
        queue_rotate = 0;
    }
 
    ast_mkdir(ast_config_AST_LOG_DIR, 0777);
 
    AST_RWLIST_TRAVERSE(&logchannels, f, list) {
        if (f->disabled) {
            f->disabled = 0;    /* Re-enable logging at reload */
            manager_event(EVENT_FLAG_SYSTEM, "LogChannel", "Channel: %s\r\nEnabled: Yes\r\n", f->filename);
        }
        if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
            int rotate_this = 0;
            if (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;
}

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, qlog, and rotate_file().

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

reload_module()

static int reload_module ( void  )

static

Definition at line 3019 of file logger.c.

{
    return reload_logger(0, NULL);
}

References NULL, and reload_logger().

rotate_file()

static int rotate_file ( const char *  filename )

static

Definition at line 1053 of file logger.c.

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

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

unload_module()

static int unload_module ( void  )

static

Definition at line 3024 of file logger.c.

{
    return 0;
}

update_logchannels()

static void update_logchannels ( void  )

static

Definition at line 2777 of file logger.c.

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

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

Referenced by ast_logger_unregister_level(), and logger_register_level().

verb_console_free()

static void verb_console_free ( void *  v_console )

static

Definition at line 2702 of file logger.c.

{
    struct verb_console *console = v_console;
 
    verb_console_unregister(console);
    ast_free(console);
}

References ast_free, and verb_console_unregister().

verb_console_unregister()

static void verb_console_unregister ( struct verb_console *  console )

static

Definition at line 2692 of file logger.c.

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

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

Referenced by ast_verb_console_unregister(), and verb_console_free().

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 = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = 0, }

static

Definition at line 3042 of file logger.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 3042 of file logger.c.

callid_filtering

int callid_filtering = 0

static

Definition at line 1669 of file logger.c.

Referenced by ast_log_full(), callid_group_remove_filters(), callid_group_set_filter(), and callid_logging_enabled().

chan_group_lock_list

struct chan_group_lock_list chan_group_lock_list = AST_RWLIST_HEAD_INIT_VALUE

cli_logger

struct ast_cli_entry cli_logger[]

static

Definition at line 1887 of file logger.c.

                                           {
    AST_CLI_DEFINE(handle_logger_show_channels, "List configured log channels"),
    AST_CLI_DEFINE(handle_logger_show_levels, "List configured log levels"),
    AST_CLI_DEFINE(handle_logger_reload, "Reopens the log files"),
    AST_CLI_DEFINE(handle_logger_rotate, "Rotates and reopens the log files"),
    AST_CLI_DEFINE(handle_logger_set_level, "Enables/Disables a specific logging level for this console"),
    AST_CLI_DEFINE(handle_logger_add_channel, "Adds a new logging channel"),
    AST_CLI_DEFINE(handle_logger_remove_channel, "Removes a logging channel"),
    AST_CLI_DEFINE(handle_logger_chanloggroup_filter, "Filter PBX logs by channel log group"),
    AST_CLI_DEFINE(handle_logger_filter_show, "Show current PBX channel filtering"),
    AST_CLI_DEFINE(handle_logger_filter_reset, "Reset PBX channel filtering"),
};

Referenced by close_logger(), and init_logger().

close_logger_thread

int close_logger_thread = 0

static

Definition at line 212 of file logger.c.

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

colors

const int colors[NUMLOGLEVELS]

static

Colors used in the console for logging.

Definition at line 247 of file logger.c.

                                        {
    COLOR_BRGREEN,
    COLOR_BRBLUE,       /* no longer used */
    COLOR_YELLOW,
    COLOR_BRRED,
    COLOR_RED,
    COLOR_GREEN,
    COLOR_BRGREEN,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
    COLOR_BRBLUE,
};

Referenced by format_log_default().

custom_dynamic_levels

char* custom_dynamic_levels[NUMLOGLEVELS]

static

Custom dynamic logging levels added by the user.

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

Referenced by init_logger_chain().

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

discard_all_new_msgs

unsigned int discard_all_new_msgs

static

Definition at line 103 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

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(), init_logger_chain(), logger_unregister_level(), and update_logchannels().

handle_SIGXFSZ

struct sigaction handle_SIGXFSZ

static

Initial value:

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

Definition at line 1906 of file logger.c.

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

Referenced by init_logger().

high_water_alert

unsigned int high_water_alert

static

Definition at line 97 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

hostname

char hostname[MAXHOSTNAMELEN]

static

Definition at line 124 of file logger.c.

Referenced by ast_get_ip(), ast_get_ip_or_srv(), ast_get_ip_or_srv_with_preference(), ast_remotecontrol(), asterisk_daemon(), cli_prompt(), iax2_append_register(), iax2_register(), init_logger_chain(), load_asterisk_conf(), make_filename(), manager_login(), netconsole(), and tds_load_module().

last_logmsg_checked_for_discard

struct logmsg* last_logmsg_checked_for_discard = NULL

static

Definition at line 209 of file logger.c.

Referenced by ast_log_full(), and logger_thread().

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.

Examples

app_skel.c.

Definition at line 227 of file logger.c.

                                    {
    "DEBUG",
    "TRACE",
    "NOTICE",
    "WARNING",
    "ERROR",
    "VERBOSE",
    "DTMF",
};

Referenced by ast_logger_get_channels(), ast_network_puts_mutable(), custom_level_still_exists(), format_log_default(), format_log_message_ap(), format_log_plain(), handle_logger_set_level(), handle_logger_show_channels(), handle_logger_show_levels(), init_logger_chain(), logger_get_dynamic_level(), logger_register_level(), logger_unregister_level(), and make_components().

log_group_function

struct ast_custom_function log_group_function

static

Initial value:

= {
    .name = "LOG_GROUP",
    .write = log_group_write,
}

Definition at line 1797 of file logger.c.

                                                       {
    .name = "LOG_GROUP",
    .write = log_group_write,
};

Referenced by close_logger(), and init_logger().

logchannels

struct logchannels logchannels = AST_RWLIST_HEAD_INIT_VALUE

static

logcond

ast_cond_t logcond

static

Definition at line 211 of file logger.c.

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

[struct]

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

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

Referenced by make_components().

logformatter_json

struct logformatter logformatter_json

static

Initial value:

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

Definition at line 344 of file logger.c.

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

Referenced by make_components().

logformatter_plain

struct logformatter logformatter_plain

static

Initial value:

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

Definition at line 516 of file logger.c.

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

Referenced by make_components().

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 96 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_over_threshold_limit

int logger_queue_over_threshold_limit = 200

static

Definition at line 95 of file logger.c.

Referenced by ast_log_full(), ast_logger_get_over_threshold_queue_limit(), and ast_logger_set_over_threshold_queue_limit().

logger_queue_size

int logger_queue_size

static

Definition at line 93 of file logger.c.

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

logmsgs

struct logmsgs logmsgs = AST_DLLIST_HEAD_INIT_VALUE

static

logthread

pthread_t logthread = AST_PTHREADT_NULL

static

Definition at line 210 of file logger.c.

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

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

Referenced by ast_queue_log(), close_logger(), init_logger_chain(), logger_queue_init(), logger_queue_restart(), and reload_logger().

queue_adaptive_realtime

unsigned int queue_adaptive_realtime

Definition at line 120 of file logger.c.

queue_log

unsigned int queue_log

Definition at line 118 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 121 of file logger.c.

queue_log_to_file

unsigned int queue_log_to_file

Definition at line 119 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

verb_consoles

struct verb_consoles verb_consoles = AST_RWLIST_HEAD_INIT_VALUE

static

verb_update_lock

ast_mutex_t verb_update_lock = AST_MUTEX_INIT_VALUE

static

ast_verb_update() reentrancy protection lock.

Definition at line 2649 of file logger.c.

Referenced by ast_verb_update().