asterisk.c File Reference

Top level source file for Asterisk - the Open Source PBX. Implementation of PBX core functions and CLI interface. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include <sys/time.h>
#include <fcntl.h>
#include <signal.h>
#include <sched.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <ctype.h>
#include <sys/resource.h>
#include <grp.h>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/sysinfo.h>
#include <regex.h>
#include <histedit.h>
#include "asterisk/paths.h"
#include "asterisk/network.h"
#include "asterisk/cli.h"
#include "asterisk/channel.h"
#include "asterisk/translate.h"
#include "asterisk/pickup.h"
#include "asterisk/acl.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/callerid.h"
#include "asterisk/image.h"
#include "asterisk/tdd.h"
#include "asterisk/term.h"
#include "asterisk/manager.h"
#include "asterisk/cdr.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/mwi.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/file.h"
#include "asterisk/io.h"
#include "asterisk/config.h"
#include "asterisk/ast_version.h"
#include "asterisk/linkedlists.h"
#include "asterisk/devicestate.h"
#include "asterisk/presencestate.h"
#include "asterisk/module.h"
#include "asterisk/buildinfo.h"
#include "asterisk/xmldoc.h"
#include "asterisk/poll-compat.h"
#include "asterisk/test.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/format.h"
#include "asterisk/aoc.h"
#include "asterisk/uuid.h"
#include "asterisk/sorcery.h"
#include "asterisk/bucket.h"
#include "asterisk/stasis.h"
#include "asterisk/json.h"
#include "asterisk/stasis_endpoints.h"
#include "asterisk/stasis_system.h"
#include "asterisk/security_events.h"
#include "asterisk/endpoints.h"
#include "asterisk/codec.h"
#include "asterisk/format_cache.h"
#include "asterisk/media_cache.h"
#include "asterisk/astdb.h"
#include "asterisk/options.h"
#include "asterisk/utf8.h"
#include "../defaults.h"
#include "channelstorage.h"
#include "editline_compat.h"

Go to the source code of this file.

Data Structures
struct	ast_atexit
struct	atexits
struct	console
struct	console_state_data
struct	profile_data
struct	profile_entry
struct	thread_list
struct	thread_list_t

Macros
#define	AF_LOCAL   AF_UNIX
#define	AST_MAX_CONNECTS   128
#define	ASTERISK_PROMPT   "*CLI> "
#define	CHAR_T_LIBEDIT   wchar_t
#define	CHAR_TO_LIBEDIT(c)   btowc(c)
#define	CMD_MATCHESARRAY   "_COMMAND MATCHESARRAY \"%s\" \"%s\""
#define	COPYRIGHT_TAG   "Copyright (C) 1999 - 2025, Sangoma Technologies Corporation and others."
#define	DEFINE_PROFILE_MIN_MAX_VALUES
#define	EL_BUF_SIZE   512
#define	MAX_HISTORY_COMMAND_LENGTH   256
#define	NUM_MSGS   64
#define	PF_LOCAL   PF_UNIX
#define	SHUTDOWN_TIMEOUT   15 /* Seconds */
#define	WELCOME_MESSAGE
	Welcome message when starting a CLI interface.

Enumerations
enum	shutdown_nice_t {   NOT_SHUTTING_DOWN , SHUTTING_DOWN_FINAL , SHUTTING_DOWN , SHUTDOWN_FAST ,   SHUTDOWN_NORMAL , SHUTDOWN_NICE , SHUTDOWN_REALLY_NICE }
enum	startup_commands_phase { STARTUP_COMMANDS_PRE_INIT = 0 , STARTUP_COMMANDS_PRE_MODULE , STARTUP_COMMANDS_FULLY_BOOTED }

Functions
static void	__ast_unregister_atexit (void(*func)(void))
static void	__quit_handler (int num)
static void	__remote_quit_handler (int num)
static void	_child_handler (int sig)
static void	_hup_handler (int num)
static void	_null_sig_handler (int sig)
	NULL handler so we can collect the child exit status.
static void	_urg_handler (int num)
	Urgent handler.
int	ast_add_profile (const char *name, uint64_t scale)
	allocates a counter with a given name and scale.
static int	ast_all_zeros (const char *s)
static void	ast_begin_shutdown (void)
int	ast_cancel_shutdown (void)
	Cancel an existing shutdown and return to normal operation.
static void	ast_cli_display_match_list (struct ast_vector_string *matches, int max)
void	ast_console_puts (const char *string)
	write the string to the root console, and all attached network console clients
void	ast_console_puts_mutable (const char *string, int level)
	log the string to the root console, and all attached network console clients
void	ast_console_puts_mutable_full (const char *message, int level, int sublevel)
	log the string to the console, and all attached console clients
void	ast_console_toggle_loglevel (int fd, int level, int state)
	enable or disable a logging level to a specified console
void	ast_console_toggle_mute (int fd, int silent)
	mute or unmute a console from logging
static int	ast_el_add_history (const char *)
static int	ast_el_initialize (void)
static int	ast_el_read_char (EditLine *editline, CHAR_T_LIBEDIT *cp)
static void	ast_el_read_default_histfile (void)
static int	ast_el_read_history (const char *)
static struct ast_vector_string *	ast_el_strtoarr (char *buf)
static void	ast_el_write_default_histfile (void)
static int	ast_el_write_history (const char *)
static int	ast_makesocket (void)
int64_t	ast_mark (int i, int startstop)
static void	ast_network_puts (const char *string)
	write the string to all attached console clients
static void	ast_network_puts_mutable (const char *string, int level, int sublevel)
	log the string to all attached network console clients
int	ast_pbx_uuid_get (char *pbx_uuid, int length)
	Retrieve the PBX UUID.
int64_t	ast_profile (int i, int64_t delta)
int	ast_register_atexit (void(*func)(void))
	Register a function to be executed before Asterisk exits.
int	ast_register_cleanup (void(*func)(void))
	Register a function to be executed before Asterisk gracefully exits.
void	ast_register_thread (char *name)
static void	ast_remotecontrol (char *data)
void	ast_replace_sigchld (void)
	Replace the SIGCHLD handler.
static void	ast_run_atexits (int run_cleanups)
int	ast_safe_execvp (int dualfork, const char *file, char *const argv[])
	Safely spawn an external program while closing file descriptors.
int	ast_safe_system (const char *s)
	Safely spawn an OS shell command while closing file descriptors.
int	ast_set_priority (int pri)
	We set ourselves to a high priority, that we might pre-empt everything else. If your PBX has heavy activity on it, this is a good thing.
int	ast_shutdown_final (void)
int	ast_shutting_down (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (console_state, console_state_init, ast_free_ptr, static)
static int	ast_tryconnect (void)
void	ast_unregister_atexit (void(*func)(void))
	Unregister a function registered with ast_register_atexit().
void	ast_unregister_thread (void *id)
void	ast_unreplace_sigchld (void)
	Restore the SIGCHLD handler.
static void	asterisk_daemon (int isroot, const char *runuser, const char *rungroup)
static int	can_safely_quit (shutdown_nice_t niceness, int restart)
static void	canary_exit (void)
static void *	canary_thread (void *unused)
static void	check_init (int init_result, const char *name)
static char *	cli_complete (EditLine *editline, int ch)
static char *	cli_prompt (EditLine *editline)
static int	console_print (const char *s)
static int	console_state_init (void *ptr)
static void	consolehandler (const char *s)
static void	env_init (void)
static int	fdprint (int fd, const char *s)
static int	fdsend (int fd, const char *s)
static char *	handle_abort_shutdown (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bang (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_clear_profile (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_restart_gracefully (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_restart_now (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_restart_when_convenient (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_show_profile (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_show_settings (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Give an overview of core settings.
static char *	handle_show_sysinfo (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Give an overview of system statistics.
static char *	handle_show_threads (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_stop_gracefully (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_stop_now (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_stop_when_convenient (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_version (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	has_priority (void)
	Check whether we were set to high(er) priority.
static void *	listener (void *unused)
int	main (int argc, char *argv[])
static void	main_atexit (void)
static void *	monitor_sig_flags (void *unused)
static void *	netconsole (void *vconsole)
static int	print_file (int fd, char *desc, const char *filename)
	Print the contents of a file.
static void	print_intro_message (const char *runuser, const char *rungroup)
static void	process_histfile (int(*readwrite)(const char *filename))
static void	publish_fully_booted (void)
static void	quit_handler (int num, shutdown_nice_t niceness, int restart)
static __inline uint64_t	rdtsc (void)
static int	read_credentials (int fd, char *buffer, size_t size, struct console *con)
	read() function supporting the reception of user credentials.
static void	read_pjproject_startup_options (void)
static void	really_quit (int num, shutdown_nice_t niceness, int restart)
static int	register_atexit (void(*func)(void), int is_cleanup)
static int	remoteconsolehandler (const char *s)
static void	run_startup_commands (enum startup_commands_phase phase)
static pid_t	safe_exec_prep (int dualfork)
	fork and perform other preparations for spawning applications
static int	safe_exec_wait (pid_t pid)
	wait for spawned application to complete and unreplace sigchld
static void	send_rasterisk_connect_commands (void)
static void	set_header (char *outbuf, int maxout, char level)
static void	set_icon (char *text)
static int	set_priority_all (int pri)
	Set priority on all known threads.
static void	set_title (char *text)
	Set an X-term or screen title.
static int	show_cli_help (void)
static char *	show_license (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	show_version (void)
static char *	show_warranty (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	wait_for_channels_to_die (shutdown_nice_t niceness, int seconds)

Variables
static char *	_argv [256]
static int	ast_consock = -1
struct timeval	ast_lastreloadtime
pid_t	ast_mainpid
static int	ast_socket = -1
static int	ast_socket_is_sd = 0
struct timeval	ast_startuptime
static struct atexits	atexits = AST_LIST_HEAD_INIT_VALUE
static char	canary_filename [128]
static int	canary_pid = 0
static struct sigaction	child_handler
static struct ast_cli_entry	cli_asterisk []
static struct ast_cli_entry	cli_asterisk_shutdown []
	Shutdown Asterisk CLI commands.
struct console	consoles [AST_MAX_CONNECTS]
static pthread_t	consolethread = AST_PTHREADT_NULL
static EditLine *	el
static History *	el_hist
static struct sigaction	hup_handler
static struct sigaction	ignore_sig_handler
static const char	license_lines []
static pthread_t	lthread
static pthread_t	mon_sig_flags
static int	multi_thread_safe
static struct sigaction	null_sig_handler
static struct profile_data *	prof_data
static struct ast_str *	prompt = NULL
static char	randompool [256]
static char *	remotehostname
static int	restartnow
static unsigned int	safe_system_level = 0
	Keep track of how many threads are currently trying to wait*() on a child process.
static ast_mutex_t	safe_system_lock = AST_MUTEX_INIT_VALUE
static struct sigaction	safe_system_prev_handler
static int	shutdown_pending
static shutdown_nice_t	shuttingdown = NOT_SHUTTING_DOWN
static int	sig_alert_pipe [2] = { -1, -1 }
struct {
unsigned int   need_el_end:1
unsigned int   need_quit:1
unsigned int   need_quit_handler:1
unsigned int   need_reload:1
}	sig_flags
static const char *	startup_commands_phase_str []
static struct thread_list	thread_list = AST_RWLIST_HEAD_INIT_VALUE
static struct sigaction	urg_handler
static const char	warranty_lines []

Detailed Description

Top level source file for Asterisk - the Open Source PBX. Implementation of PBX core functions and CLI interface.

Definition in file asterisk.c.

Macro Definition Documentation

AF_LOCAL

#define AF_LOCAL   AF_UNIX

Definition at line 300 of file asterisk.c.

AST_MAX_CONNECTS

#define AST_MAX_CONNECTS   128

Definition at line 304 of file asterisk.c.

ASTERISK_PROMPT

#define ASTERISK_PROMPT   "*CLI> "

Definition at line 2624 of file asterisk.c.

CHAR_T_LIBEDIT

#define CHAR_T_LIBEDIT   wchar_t

Definition at line 2689 of file asterisk.c.

CHAR_TO_LIBEDIT

#define CHAR_TO_LIBEDIT

(

c

)

btowc(c)

Definition at line 2690 of file asterisk.c.

CMD_MATCHESARRAY

#define CMD_MATCHESARRAY   "_COMMAND MATCHESARRAY \"%s\" \"%s\""

COPYRIGHT_TAG

#define COPYRIGHT_TAG   "Copyright (C) 1999 - 2025, Sangoma Technologies Corporation and others."

Displayed copyright tag

Definition at line 308 of file asterisk.c.

DEFINE_PROFILE_MIN_MAX_VALUES

#define DEFINE_PROFILE_MIN_MAX_VALUES

Definition at line 906 of file asterisk.c.

                      { /* specific entries */ \
        if (isdigit(a->argv[3][0])) { \
            min = atoi(a->argv[3]); \
            if (a->argc == 5 && strcmp(a->argv[4], "-")) \
                max = atoi(a->argv[4]); \
        } else \
            search = a->argv[3]; \
    } \
    if (max > prof_data->entries) \
        max = prof_data->entries;

EL_BUF_SIZE

#define EL_BUF_SIZE   512

MAX_HISTORY_COMMAND_LENGTH

#define MAX_HISTORY_COMMAND_LENGTH   256

Definition at line 3170 of file asterisk.c.

NUM_MSGS

#define NUM_MSGS   64

Definition at line 305 of file asterisk.c.

PF_LOCAL

#define PF_LOCAL   PF_UNIX

Definition at line 301 of file asterisk.c.

SHUTDOWN_TIMEOUT

#define SHUTDOWN_TIMEOUT   15 /* Seconds */

Definition at line 1932 of file asterisk.c.

WELCOME_MESSAGE

#define WELCOME_MESSAGE

Welcome message when starting a CLI interface.

Definition at line 311 of file asterisk.c.

Enumeration Type Documentation

shutdown_nice_t

enum shutdown_nice_t

Enumerator
NOT_SHUTTING_DOWN	Normal operation
SHUTTING_DOWN_FINAL	Committed to shutting down. Final phase
SHUTTING_DOWN	Committed to shutting down. Initial phase
SHUTDOWN_FAST	Valid values for quit_handler() niceness below. These shutdown/restart levels can be cancelled. Remote console exit right now
SHUTDOWN_NORMAL	core stop/restart now
SHUTDOWN_NICE	core stop/restart gracefully
SHUTDOWN_REALLY_NICE	core stop/restart when convenient

Definition at line 364 of file asterisk.c.

             {
    /*! Normal operation */
    NOT_SHUTTING_DOWN,
    /*! Committed to shutting down.  Final phase */
    SHUTTING_DOWN_FINAL,
    /*! Committed to shutting down.  Initial phase */
    SHUTTING_DOWN,
    /*!
     * Valid values for quit_handler() niceness below.
     * These shutdown/restart levels can be cancelled.
     *
     * Remote console exit right now
     */
    SHUTDOWN_FAST,
    /*! core stop/restart now */
    SHUTDOWN_NORMAL,
    /*! core stop/restart gracefully */
    SHUTDOWN_NICE,
    /*! core stop/restart when convenient */
    SHUTDOWN_REALLY_NICE
} shutdown_nice_t;

startup_commands_phase

enum startup_commands_phase

Enumerator
STARTUP_COMMANDS_PRE_INIT
STARTUP_COMMANDS_PRE_MODULE
STARTUP_COMMANDS_FULLY_BOOTED

Definition at line 3547 of file asterisk.c.

                            {
    STARTUP_COMMANDS_PRE_INIT = 0,
    STARTUP_COMMANDS_PRE_MODULE,
    STARTUP_COMMANDS_FULLY_BOOTED
};

Function Documentation

__ast_unregister_atexit()

static void __ast_unregister_atexit ( void(*)(void)  func )

static

Definition at line 1029 of file asterisk.c.

{
    struct ast_atexit *ae;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&atexits, ae, list) {
        if (ae->func == func) {
            AST_LIST_REMOVE_CURRENT(list);
            ast_free(ae);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
}

References ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_atexit::func, and ast_atexit::list.

Referenced by ast_unregister_atexit(), and register_atexit().

__quit_handler()

static void __quit_handler ( int  num )

static

Definition at line 2154 of file asterisk.c.

{
    sig_flags.need_quit = 1;
    if (ast_alertpipe_write(sig_alert_pipe)) {
        fprintf(stderr, "quit_handler: write() failed: %s\n", strerror(errno));
    }
    /* There is no need to restore the signal handler here, since the app
     * is going to exit */
}

References ast_alertpipe_write(), errno, sig_alert_pipe, and sig_flags.

Referenced by asterisk_daemon().

__remote_quit_handler()

static void __remote_quit_handler ( int  num )

static

Definition at line 2164 of file asterisk.c.

{
    sig_flags.need_quit = 1;
}

References sig_flags.

Referenced by ast_remotecontrol().

_child_handler()

static void _child_handler ( int  sig )

static

Definition at line 1756 of file asterisk.c.

{
    /* Must not ever ast_log or ast_verbose within signal handler */
    int n, status, save_errno = errno;
 
    /*
     * Reap all dead children -- not just one
     */
    for (n = 0; waitpid(-1, &status, WNOHANG) > 0; n++)
        ;
    if (n == 0 && option_debug)
        printf("Huh?  Child handler, but nobody there?\n");
    errno = save_errno;
}

References errno, option_debug, and status.

_hup_handler()

static void _hup_handler ( int  num )

static

Definition at line 1732 of file asterisk.c.

{
    int save_errno = errno;
 
    if (restartnow) {
        if (el) {
            el_end(el);
        }
        execvp(_argv[0], _argv);
    }
 
    printf("Received HUP signal -- Reloading configs\n");
    sig_flags.need_reload = 1;
    if (ast_alertpipe_write(sig_alert_pipe)) {
        fprintf(stderr, "hup_handler: write() failed: %s\n", strerror(errno));
    }
    errno = save_errno;
}

References _argv, ast_alertpipe_write(), el, errno, restartnow, sig_alert_pipe, and sig_flags.

_null_sig_handler()

static void _null_sig_handler ( int  sig )

static

NULL handler so we can collect the child exit status.

Definition at line 1092 of file asterisk.c.

{
}

_urg_handler()

static void _urg_handler ( int  num )

static

Urgent handler.

Called by soft_hangup to interrupt the poll, read, or other system call. We don't actually need to do anything though. Remember: Cannot EVER ast_log from within a signal handler

Definition at line 1723 of file asterisk.c.

{
    return;
}

ast_add_profile()

int ast_add_profile	(	const char *	name,
		uint64_t	scale
	)

allocates a counter with a given name and scale.

support for event profiling

Returns

Returns the identifier of the counter.

Definition at line 810 of file asterisk.c.

{
#if !defined(LOW_MEMORY)
    int l = sizeof(struct profile_data);
    int n = 10; /* default entries */
 
    if (prof_data == NULL) {
        prof_data = ast_calloc(1, l + n*sizeof(struct profile_entry));
        if (prof_data == NULL)
            return -1;
        prof_data->entries = 0;
        prof_data->max_size = n;
    }
    if (prof_data->entries >= prof_data->max_size) {
        void *p;
        n = prof_data->max_size + 20;
        p = ast_realloc(prof_data, l + n*sizeof(struct profile_entry));
        if (p == NULL)
            return -1;
        prof_data = p;
        prof_data->max_size = n;
    }
    n = prof_data->entries++;
    prof_data->e[n].name = ast_strdup(name);
    prof_data->e[n].value = 0;
    prof_data->e[n].events = 0;
    prof_data->e[n].mark = 0;
    prof_data->e[n].scale = scale;
    return n;
#else /* if defined(LOW_MEMORY) */
    return 0;
#endif
}

References ast_calloc, ast_realloc, ast_strdup, profile_data::e, profile_data::entries, profile_entry::events, profile_entry::mark, profile_data::max_size, name, profile_entry::name, NULL, prof_data, profile_entry::scale, and profile_entry::value.

ast_all_zeros()

static int ast_all_zeros ( const char *  s )

static

Definition at line 2299 of file asterisk.c.

{
    while (*s) {
        if (*s > 32)
            return 0;
        s++;
    }
    return 1;
}

Referenced by consolehandler(), and remoteconsolehandler().

ast_begin_shutdown()

static void ast_begin_shutdown ( void  )

static

Definition at line 1911 of file asterisk.c.

{
    ast_mutex_lock(&safe_system_lock);
    if (shuttingdown != NOT_SHUTTING_DOWN) {
        shutdown_pending = 1;
    }
    ast_mutex_unlock(&safe_system_lock);
}

References ast_mutex_lock, ast_mutex_unlock, NOT_SHUTTING_DOWN, safe_system_lock, shutdown_pending, and shuttingdown.

Referenced by can_safely_quit().

ast_cancel_shutdown()

int ast_cancel_shutdown

(

void

)

Cancel an existing shutdown and return to normal operation.

Note

Shutdown can be cancelled while the server is waiting for any existing channels to be destroyed before shutdown becomes irreversible.

Returns

non-zero if shutdown cancelled.

Definition at line 1893 of file asterisk.c.

{
    int shutdown_aborted = 0;
 
    ast_mutex_lock(&safe_system_lock);
    if (shuttingdown >= SHUTDOWN_FAST) {
        shuttingdown = NOT_SHUTTING_DOWN;
        shutdown_pending = 0;
        shutdown_aborted = 1;
    }
    ast_mutex_unlock(&safe_system_lock);
    return shutdown_aborted;
}

References ast_mutex_lock, ast_mutex_unlock, NOT_SHUTTING_DOWN, safe_system_lock, SHUTDOWN_FAST, shutdown_pending, and shuttingdown.

Referenced by handle_abort_shutdown().

ast_cli_display_match_list()

static void ast_cli_display_match_list ( struct ast_vector_string *  matches, int  max  )

static

Definition at line 2964 of file asterisk.c.

{
    int idx = 1;
    /* find out how many entries can be put on one line, with two spaces between strings */
    int limit = ast_get_termcols(STDOUT_FILENO) / (max + 2);
 
    if (limit == 0) {
        limit = 1;
    }
 
    for (;;) {
        int numoutputline;
 
        for (numoutputline = 0; numoutputline < limit && idx < AST_VECTOR_SIZE(matches); idx++) {
            numoutputline++;
            fprintf(stdout, "%-*s  ", max, AST_VECTOR_GET(matches, idx));
        }
 
        if (!numoutputline) {
            break;
        }
 
        fprintf(stdout, "\n");
    }
}

References ast_get_termcols(), AST_VECTOR_GET, AST_VECTOR_SIZE, and max.

Referenced by cli_complete().

ast_console_puts()

void ast_console_puts

(

const char *

string

)

write the string to the root console, and all attached network console clients

Definition at line 1368 of file asterisk.c.

{
    /* Send to the root console */
    fputs(string, stdout);
    fflush(stdout);
 
    /* Send to any network console clients */
    ast_network_puts(string);
}

References ast_network_puts().

ast_console_puts_mutable()

void ast_console_puts_mutable	(	const char *	string,
		int	level
	)

log the string to the root console, and all attached network console clients

log the string to the console, and all attached console clients

Definition at line 1328 of file asterisk.c.

{
    ast_console_puts_mutable_full(string, level, 0);
}

References ast_console_puts_mutable_full().

Referenced by init_logger_chain(), and make_logchannel().

ast_console_puts_mutable_full()

void ast_console_puts_mutable_full	(	const char *	message,
		int	level,
		int	sublevel
	)

log the string to the console, and all attached console clients

Since

14.0.0

Parameters

message	The message to write to the console
sublevel	If the log level supports it, the sub-level of the message
level	The log level of the message

Definition at line 1335 of file asterisk.c.

{
    /* Send to the root console */
    console_print(message);
 
    /* Wake up a poll()ing console */
    if (ast_opt_console && consolethread != AST_PTHREADT_NULL) {
        pthread_kill(consolethread, SIGURG);
    }
 
    /* Send to any network console clients */
    ast_network_puts_mutable(message, level, sublevel);
}

References ast_network_puts_mutable(), ast_opt_console, AST_PTHREADT_NULL, console_print(), and consolethread.

Referenced by ast_console_puts_mutable(), and logger_print_normal().

ast_console_toggle_loglevel()

void ast_console_toggle_loglevel	(	int	fd,
		int	level,
		int	state
	)

enable or disable a logging level to a specified console

enables or disables logging of a specified level to the console

Definition at line 1263 of file asterisk.c.

{
    int x;
 
    if (level >= NUMLOGLEVELS) {
        level = NUMLOGLEVELS - 1;
    }
 
    for (x = 0;x < AST_MAX_CONNECTS; x++) {
        if (fd == consoles[x].fd) {
            /*
             * Since the logging occurs when levels are false, set to
             * flipped iinput because this function accepts 0 as off and 1 as on
             */
            consoles[x].levels[level] = state ? 0 : 1;
            return;
        }
    }
}

References AST_MAX_CONNECTS, consoles, console::levels, and NUMLOGLEVELS.

Referenced by handle_logger_set_level().

ast_console_toggle_mute()

void ast_console_toggle_mute	(	int	fd,
		int	silent
	)

mute or unmute a console from logging

Definition at line 1286 of file asterisk.c.

{
    int x;
    for (x = 0;x < AST_MAX_CONNECTS; x++) {
        if (fd == consoles[x].fd) {
            if (consoles[x].mute) {
                consoles[x].mute = 0;
                if (!silent)
                    ast_cli(fd, "Console is not muted anymore.\n");
            } else {
                consoles[x].mute = 1;
                if (!silent)
                    ast_cli(fd, "Console is muted.\n");
            }
            return;
        }
    }
    ast_cli(fd, "Couldn't find remote console.\n");
}

References ast_cli(), AST_MAX_CONNECTS, consoles, and console::mute.

Referenced by handle_logger_mute().

ast_el_add_history()

static int ast_el_add_history ( const char *  buf )

static

Definition at line 3172 of file asterisk.c.

{
    HistEvent ev;
    char *stripped_buf;
 
    if (el_hist == NULL || el == NULL) {
        ast_el_initialize();
    }
    if (strlen(buf) > (MAX_HISTORY_COMMAND_LENGTH - 1)) {
        return 0;
    }
 
    stripped_buf = ast_strip(ast_strdupa(buf));
 
    /* HISTCONTROL=ignoredups */
    if (!history(el_hist, &ev, H_FIRST) && strcmp(ev.str, stripped_buf) == 0) {
        return 0;
    }
 
    return history(el_hist, &ev, H_ENTER, stripped_buf);
}

References ast_el_initialize(), ast_strdupa, ast_strip(), buf, el, el_hist, MAX_HISTORY_COMMAND_LENGTH, and NULL.

Referenced by consolehandler(), and remoteconsolehandler().

ast_el_initialize()

static int ast_el_initialize ( void  )

static

Definition at line 3117 of file asterisk.c.

{
    HistEvent ev;
    char *editor, *editrc = getenv("EDITRC");
 
    if (!(editor = getenv("AST_EDITMODE"))) {
        if (!(editor = getenv("AST_EDITOR"))) {
            editor = "emacs";
        }
    }
 
    if (el != NULL)
        el_end(el);
    if (el_hist != NULL)
        history_end(el_hist);
 
    el = el_init("asterisk", stdin, stdout, stderr);
    el_set(el, EL_PROMPT, cli_prompt);
 
    el_set(el, EL_EDITMODE, 1);
    el_set(el, EL_EDITOR, editor);
    el_hist = history_init();
    if (!el || !el_hist)
        return -1;
 
    /* setup history with 100 entries */
    history(el_hist, &ev, H_SETSIZE, 100);
 
    el_set(el, EL_HIST, history, el_hist);
 
    el_set(el, EL_ADDFN, "ed-complete", "Complete argument", cli_complete);
    /* Bind <tab> to command completion */
    el_set(el, EL_BIND, "^I", "ed-complete", NULL);
    /* Bind ? to command completion */
    el_set(el, EL_BIND, "?", "ed-complete", NULL);
    /* Bind ^D to redisplay */
    el_set(el, EL_BIND, "^D", "ed-redisplay", NULL);
    /* Bind Delete to delete char left */
    el_set(el, EL_BIND, "\\e[3~", "ed-delete-next-char", NULL);
    /* Bind Home and End to move to line start and end */
    el_set(el, EL_BIND, "\\e[1~", "ed-move-to-beg", NULL);
    el_set(el, EL_BIND, "\\e[4~", "ed-move-to-end", NULL);
    /* Bind C-left and C-right to move by word (not all terminals) */
    el_set(el, EL_BIND, "\\eOC", "vi-next-word", NULL);
    el_set(el, EL_BIND, "\\eOD", "vi-prev-word", NULL);
 
    if (editrc) {
        el_source(el, editrc);
    }
 
    return 0;
}

References cli_complete(), cli_prompt(), el, el_hist, and NULL.

Referenced by ast_el_add_history(), ast_el_read_history(), ast_el_write_history(), ast_remotecontrol(), and asterisk_daemon().

ast_el_read_char()

static int ast_el_read_char ( EditLine *  editline, CHAR_T_LIBEDIT *  cp  )

static

Definition at line 2696 of file asterisk.c.

{
    int num_read = 0;
    int lastpos = 0;
    struct pollfd fds[2];
    int res;
    int max;
#define EL_BUF_SIZE 512
    char buf[EL_BUF_SIZE];
 
    for (;;) {
        max = 1;
        fds[0].fd = ast_consock;
        fds[0].events = POLLIN;
        if (!ast_opt_exec) {
            fds[1].fd = STDIN_FILENO;
            fds[1].events = POLLIN;
            max++;
        }
        res = ast_poll(fds, max, -1);
        if (res < 0) {
            if (sig_flags.need_quit || sig_flags.need_quit_handler || sig_flags.need_el_end) {
                break;
            }
            if (errno == EINTR) {
                continue;
            }
            fprintf(stderr, "poll failed: %s\n", strerror(errno));
            break;
        }
 
        if (!ast_opt_exec && fds[1].revents) {
#ifdef HAVE_LIBEDIT_IS_UNICODE
            num_read = editline_read_char(editline, cp);
            if (num_read < 1) {
                break;
            }
#else
            char c = '\0';
 
            num_read = read(STDIN_FILENO, &c, 1);
            if (num_read < 1) {
                break;
            }
 
            *cp = CHAR_TO_LIBEDIT(c);
 
#endif
            return num_read;
        }
 
        if (fds[0].revents) {
            res = read(ast_consock, buf, sizeof(buf) - 1);
            /* if the remote side disappears exit */
            if (res < 1) {
                fprintf(stderr, "\nDisconnected from Asterisk server\n");
                if (!ast_opt_reconnect) {
                    quit_handler(0, SHUTDOWN_FAST, 0);
                } else {
                    int tries;
                    int reconnects_per_second = 20;
 
                    fprintf(stderr, "Attempting to reconnect for 30 seconds\n");
                    for (tries = 0; tries < 30 * reconnects_per_second; tries++) {
                        if (ast_tryconnect()) {
                            fprintf(stderr, "Reconnect succeeded after %.3f seconds\n", 1.0 / reconnects_per_second * tries);
                            printf("%s", term_quit());
                            WELCOME_MESSAGE;
                            send_rasterisk_connect_commands();
                            break;
                        }
 
                        usleep(1000000 / reconnects_per_second);
                    }
                    if (tries >= 30 * reconnects_per_second) {
                        fprintf(stderr, "Failed to reconnect for 30 seconds.  Quitting.\n");
                        quit_handler(0, SHUTDOWN_FAST, 0);
                    }
                }
                continue;
            }
 
            buf[res] = '\0';
 
            /* Write over the CLI prompt */
            if (!ast_opt_exec && !lastpos) {
                if (write(STDOUT_FILENO, "\r␛[0K", 5) < 0) {
                }
            }
 
            console_print(buf);
 
            if ((res < EL_BUF_SIZE - 1) && ((buf[res-1] == '\n') || (res >= 2 && buf[res-2] == '\n'))) {
                *cp = CHAR_TO_LIBEDIT(CC_REFRESH);
 
                return 1;
            }
            lastpos = 1;
        }
    }
 
    *cp = CHAR_TO_LIBEDIT('\0');
 
    return 0;
}

References ast_consock, ast_opt_exec, ast_opt_reconnect, ast_poll, ast_tryconnect(), buf, c, CHAR_TO_LIBEDIT, console_print(), editline_read_char(), EL_BUF_SIZE, errno, max, quit_handler(), send_rasterisk_connect_commands(), SHUTDOWN_FAST, sig_flags, term_quit(), and WELCOME_MESSAGE.

Referenced by ast_remotecontrol(), and asterisk_daemon().

ast_el_read_default_histfile()

static void ast_el_read_default_histfile ( void  )

static

Definition at line 3247 of file asterisk.c.

{
    process_histfile(ast_el_read_history);
}

References ast_el_read_history(), and process_histfile().

Referenced by ast_remotecontrol(), and asterisk_daemon().

ast_el_read_history()

static int ast_el_read_history ( const char *  filename )

static

Definition at line 3204 of file asterisk.c.

{
    HistEvent ev;
 
    if (el_hist == NULL || el == NULL) {
        ast_el_initialize();
    }
 
    if (access(filename, F_OK) == 0) {
        return history(el_hist, &ev, H_LOAD, filename);
    }
 
    /* If the history file doesn't exist, failing to read it is unremarkable. */
    return 0;
}

References ast_el_initialize(), el, el_hist, F_OK, and NULL.

Referenced by ast_el_read_default_histfile().

ast_el_strtoarr()

static struct ast_vector_string * ast_el_strtoarr ( char *  buf )

static

Definition at line 2930 of file asterisk.c.

{
    char *retstr;
    struct ast_vector_string *vec = ast_calloc(1, sizeof(*vec));
 
    if (!vec) {
        return NULL;
    }
 
    while ((retstr = strsep(&buf, " "))) {
        if (!strcmp(retstr, AST_CLI_COMPLETE_EOF)) {
            break;
        }
 
        retstr = ast_strdup(retstr);
        if (!retstr || AST_VECTOR_APPEND(vec, retstr)) {
            ast_free(retstr);
            goto vector_cleanup;
        }
    }
 
    if (!AST_VECTOR_SIZE(vec)) {
        goto vector_cleanup;
    }
 
    return vec;
 
vector_cleanup:
    AST_VECTOR_CALLBACK_VOID(vec, ast_free);
    AST_VECTOR_PTR_FREE(vec);
 
    return NULL;
}

References ast_calloc, AST_CLI_COMPLETE_EOF, ast_free, ast_strdup, AST_VECTOR_APPEND, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_PTR_FREE, AST_VECTOR_SIZE, buf, NULL, and strsep().

Referenced by cli_complete().

ast_el_write_default_histfile()

static void ast_el_write_default_histfile ( void  )

static

Definition at line 3252 of file asterisk.c.

{
    process_histfile(ast_el_write_history);
}

References ast_el_write_history(), and process_histfile().

Referenced by really_quit().

ast_el_write_history()

static int ast_el_write_history ( const char *  filename )

static

Definition at line 3194 of file asterisk.c.

{
    HistEvent ev;
 
    if (el_hist == NULL || el == NULL)
        ast_el_initialize();
 
    return (history(el_hist, &ev, H_SAVE, filename));
}

References ast_el_initialize(), el, el_hist, and NULL.

Referenced by ast_el_write_default_histfile().

ast_makesocket()

static int ast_makesocket ( void  )

static

Definition at line 1610 of file asterisk.c.

{
    struct sockaddr_un sunaddr;
    int res;
    int x;
    uid_t uid = -1;
    gid_t gid = -1;
 
    for (x = 0; x < AST_MAX_CONNECTS; x++) {
        consoles[x].fd = -1;
    }
 
    if (ast_socket_is_sd) {
        ast_socket = ast_sd_get_fd_un(SOCK_STREAM, ast_config_AST_SOCKET);
 
        goto start_lthread;
    }
 
    unlink(ast_config_AST_SOCKET);
    ast_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
    if (ast_socket < 0) {
        ast_log(LOG_WARNING, "Unable to create control socket: %s\n", strerror(errno));
        return -1;
    }
    memset(&sunaddr, 0, sizeof(sunaddr));
    sunaddr.sun_family = AF_LOCAL;
    ast_copy_string(sunaddr.sun_path, ast_config_AST_SOCKET, sizeof(sunaddr.sun_path));
    res = bind(ast_socket, (struct sockaddr *)&sunaddr, sizeof(sunaddr));
    if (res) {
        ast_log(LOG_WARNING, "Unable to bind socket to %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
        close(ast_socket);
        ast_socket = -1;
        return -1;
    }
    res = listen(ast_socket, 2);
    if (res < 0) {
        ast_log(LOG_WARNING, "Unable to listen on socket %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
        close(ast_socket);
        ast_socket = -1;
        return -1;
    }
 
start_lthread:
    if (ast_pthread_create_background(&lthread, NULL, listener, NULL)) {
        ast_log(LOG_WARNING, "Unable to create listener thread.\n");
        close(ast_socket);
        return -1;
    }
 
    if (ast_socket_is_sd) {
        /* owner/group/permissions are set by systemd, we might not even have access
         * to socket file so leave it alone */
        return 0;
    }
 
    if (!ast_strlen_zero(ast_config_AST_CTL_OWNER)) {
        struct passwd *pw;
        if ((pw = getpwnam(ast_config_AST_CTL_OWNER)) == NULL)
            ast_log(LOG_WARNING, "Unable to find uid of user %s\n", ast_config_AST_CTL_OWNER);
        else
            uid = pw->pw_uid;
    }
 
    if (!ast_strlen_zero(ast_config_AST_CTL_GROUP)) {
        struct group *grp;
        if ((grp = getgrnam(ast_config_AST_CTL_GROUP)) == NULL)
            ast_log(LOG_WARNING, "Unable to find gid of group %s\n", ast_config_AST_CTL_GROUP);
        else
            gid = grp->gr_gid;
    }
 
    if (chown(ast_config_AST_SOCKET, uid, gid) < 0)
        ast_log(LOG_WARNING, "Unable to change ownership of %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
 
    if (!ast_strlen_zero(ast_config_AST_CTL_PERMISSIONS)) {
        unsigned int p1;
        mode_t p;
        sscanf(ast_config_AST_CTL_PERMISSIONS, "%30o", &p1);
        p = p1;
        if ((chmod(ast_config_AST_SOCKET, p)) < 0)
            ast_log(LOG_WARNING, "Unable to change file permissions of %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
    }
 
    return 0;
}

References AF_LOCAL, ast_config_AST_CTL_GROUP, ast_config_AST_CTL_OWNER, ast_config_AST_CTL_PERMISSIONS, ast_config_AST_SOCKET, ast_copy_string(), ast_log, AST_MAX_CONNECTS, ast_pthread_create_background, ast_sd_get_fd_un(), ast_socket, ast_socket_is_sd, ast_strlen_zero(), consoles, errno, console::fd, listener(), LOG_WARNING, lthread, NULL, and PF_LOCAL.

Referenced by asterisk_daemon().

ast_mark()

int64_t ast_mark	(	int	i,
		int	startstop
	)

Definition at line 885 of file asterisk.c.

{
#if !defined(LOW_MEMORY)
    if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
        return 0;
    if (startstop == 1)
        prof_data->e[i].mark = rdtsc();
    else {
        prof_data->e[i].mark = (rdtsc() - prof_data->e[i].mark);
        if (prof_data->e[i].scale > 1)
            prof_data->e[i].mark /= prof_data->e[i].scale;
        prof_data->e[i].value += prof_data->e[i].mark;
        prof_data->e[i].events++;
    }
    return prof_data->e[i].mark;
#else /* if defined(LOW_MEMORY) */
    return 0;
#endif
}

References profile_data::e, profile_data::entries, profile_entry::events, profile_entry::mark, prof_data, rdtsc(), profile_entry::scale, and profile_entry::value.

ast_network_puts()

static void ast_network_puts ( const char *  string )

static

write the string to all attached console clients

Definition at line 1352 of file asterisk.c.

{
    int x;
 
    for (x = 0; x < AST_MAX_CONNECTS; ++x) {
        if (consoles[x].fd < 0) {
            continue;
        }
        fdprint(consoles[x].p[1], string);
    }
}

References AST_MAX_CONNECTS, consoles, and fdprint().

Referenced by ast_console_puts().

ast_network_puts_mutable()

static void ast_network_puts_mutable ( const char *  string, int  level, int  sublevel  )

static

log the string to all attached network console clients

Definition at line 1309 of file asterisk.c.

{
    int x;
 
    for (x = 0; x < AST_MAX_CONNECTS; ++x) {
        if (consoles[x].fd < 0
            || consoles[x].mute
            || consoles[x].levels[level]
            || (level == __LOG_VERBOSE && consoles[x].option_verbose < sublevel)) {
            continue;
        }
        fdprint(consoles[x].p[1], string);
    }
}

References __LOG_VERBOSE, AST_MAX_CONNECTS, consoles, fdprint(), levels, and option_verbose.

Referenced by ast_console_puts_mutable_full().

ast_pbx_uuid_get()

int ast_pbx_uuid_get	(	char *	pbx_uuid,
		int	length
	)

Retrieve the PBX UUID.

Parameters

pbx_uuid	A buffer of at least AST_UUID_STR_LEN (36 + 1) size to receive the UUID
length	The buffer length

Definition at line 984 of file asterisk.c.

{
    return ast_db_get("pbx", "UUID", pbx_uuid, length);
}

References ast_db_get().

Referenced by asterisk_daemon(), and handle_show_settings().

ast_profile()

int64_t ast_profile	(	int	i,
		int64_t	delta
	)

Definition at line 844 of file asterisk.c.

{
#if !defined(LOW_MEMORY)
    if (!prof_data || i < 0 || i > prof_data->entries)  /* invalid index */
        return 0;
    if (prof_data->e[i].scale > 1)
        delta /= prof_data->e[i].scale;
    prof_data->e[i].value += delta;
    prof_data->e[i].events++;
    return prof_data->e[i].value;
#else /* if defined(LOW_MEMORY) */
    return 0;
#endif
}

References profile_data::e, profile_data::entries, profile_entry::events, prof_data, profile_entry::scale, and profile_entry::value.

ast_register_atexit()

int ast_register_atexit

(

void(*)(void)

func

)

Register a function to be executed before Asterisk exits.

Parameters

func	The callback function to use.

Return values

0	on success.
-1	on error.

Note

This function should be rarely used in situations where something must be shutdown to avoid corruption, excessive data loss, or when external programs must be stopped. All other cleanup in the core should use ast_register_cleanup.

Definition at line 1062 of file asterisk.c.

{
    return register_atexit(func, 0);
}

References ast_atexit::func, and register_atexit().

Referenced by asterisk_daemon().

ast_register_cleanup()

int ast_register_cleanup

(

void(*)(void)

func

)

Register a function to be executed before Asterisk gracefully exits.

Since

11.9

If Asterisk is immediately shutdown (core stop now, or sending the TERM signal), the callback is not run. When the callbacks are run, they are run in sequence with ast_register_atexit() callbacks, in the reverse order of registration.

Parameters

func	The callback function to use.

Return values

0	on success.
-1	on error.

Definition at line 1067 of file asterisk.c.

{
    return register_atexit(func, 1);
}

References ast_atexit::func, and register_atexit().

Referenced by asterisk_daemon().

ast_register_thread()

void ast_register_thread

(

char *

name

)

Definition at line 422 of file asterisk.c.

{
    struct thread_list_t *new = ast_calloc(1, sizeof(*new));
 
    if (!new)
        return;
 
    ast_assert(multi_thread_safe);
    new->id = pthread_self();
    new->lwp = ast_get_tid();
    new->name = name; /* steal the allocated memory for the thread name */
    AST_RWLIST_WRLOCK(&thread_list);
    AST_RWLIST_INSERT_HEAD(&thread_list, new, list);
    AST_RWLIST_UNLOCK(&thread_list);
}

References ast_assert, ast_calloc, ast_get_tid(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, thread_list_t::list, multi_thread_safe, and name.

Referenced by dummy_start().

ast_remotecontrol()

static void ast_remotecontrol ( char *  data )

static

Definition at line 3257 of file asterisk.c.

{
    char buf[256] = "";
    int res;
    char *hostname;
    char *cpid;
    char *version;
    int pid;
    char *stringp = NULL;
 
    char *ebuf;
    int num = 0;
 
    ast_term_init();
    printf("%s", term_end());
    fflush(stdout);
 
    memset(&sig_flags, 0, sizeof(sig_flags));
    signal(SIGINT, __remote_quit_handler);
    signal(SIGTERM, __remote_quit_handler);
    signal(SIGHUP, __remote_quit_handler);
 
    if (read(ast_consock, buf, sizeof(buf) - 1) < 0) {
        ast_log(LOG_ERROR, "read() failed: %s\n", strerror(errno));
        return;
    }
    if (data) {
        char prefix[] = "cli quit after ";
        char *tmp = ast_alloca(strlen(data) + strlen(prefix) + 1);
        sprintf(tmp, "%s%s", prefix, data);
        if (write(ast_consock, tmp, strlen(tmp) + 1) < 0) {
            ast_log(LOG_ERROR, "write() failed: %s\n", strerror(errno));
            if (sig_flags.need_quit || sig_flags.need_quit_handler || sig_flags.need_el_end) {
                return;
            }
        }
    }
    stringp = buf;
    hostname = strsep(&stringp, "/");
    cpid = strsep(&stringp, "/");
    version = strsep(&stringp, "\n");
    if (!version)
        version = "<Version Unknown>";
    stringp = hostname;
    strsep(&stringp, ".");
    if (cpid)
        pid = atoi(cpid);
    else
        pid = -1;
    if (!data) {
        send_rasterisk_connect_commands();
    }
 
    if (ast_opt_exec && data) {  /* hack to print output then exit if asterisk -rx is used */
        int linefull = 1, prev_linefull = 1, prev_line_verbose = 0;
        struct pollfd fds;
        fds.fd = ast_consock;
        fds.events = POLLIN;
        fds.revents = 0;
 
        while (ast_poll(&fds, 1, 60000) > 0) {
            char buffer[512] = "", *curline = buffer, *nextline;
            int not_written = 1;
 
            if (sig_flags.need_quit || sig_flags.need_quit_handler || sig_flags.need_el_end) {
                break;
            }
 
            if (read(ast_consock, buffer, sizeof(buffer) - 1) <= 0) {
                break;
            }
 
            do {
                prev_linefull = linefull;
                if ((nextline = strchr(curline, '\n'))) {
                    linefull = 1;
                    nextline++;
                } else {
                    linefull = 0;
                    nextline = strchr(curline, '\0');
                }
 
                /* Skip verbose lines */
                /* Prev line full? | Line is verbose | Last line verbose? | Print
                 * TRUE            | TRUE*           | TRUE               | FALSE
                 * TRUE            | TRUE*           | FALSE              | FALSE
                 * TRUE            | FALSE*          | TRUE               | TRUE
                 * TRUE            | FALSE*          | FALSE              | TRUE
                 * FALSE           | TRUE            | TRUE*              | FALSE
                 * FALSE           | TRUE            | FALSE*             | TRUE
                 * FALSE           | FALSE           | TRUE*              | FALSE
                 * FALSE           | FALSE           | FALSE*             | TRUE
                 */
                if ((!prev_linefull && !prev_line_verbose) || (prev_linefull && *curline > 0)) {
                    prev_line_verbose = 0;
                    not_written = 0;
                    if (write(STDOUT_FILENO, curline, nextline - curline) < 0) {
                        ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
                    }
                } else {
                    prev_line_verbose = 1;
                }
                curline = nextline;
            } while (!ast_strlen_zero(curline));
 
            /* No non-verbose output in 60 seconds. */
            if (not_written) {
                break;
            }
        }
        return;
    }
 
    ast_verbose("Connected to Asterisk %s currently running on %s (pid = %d)\n", version, hostname, pid);
    ast_init_logger_for_socket_console();
 
    remotehostname = hostname;
    if (el_hist == NULL || el == NULL)
        ast_el_initialize();
    ast_el_read_default_histfile();
 
    el_set(el, EL_GETCFN, ast_el_read_char);
 
    for (;;) {
        ebuf = (char *)el_gets(el, &num);
 
        if (sig_flags.need_quit || sig_flags.need_quit_handler || sig_flags.need_el_end) {
            break;
        }
 
        if (!ebuf && write(1, "", 1) < 0)
            break;
 
        if (!ast_strlen_zero(ebuf)) {
            if (ebuf[strlen(ebuf)-1] == '\n')
                ebuf[strlen(ebuf)-1] = '\0';
            if (!remoteconsolehandler(ebuf)) {
                res = write(ast_consock, ebuf, strlen(ebuf) + 1);
                if (res < 1) {
                    ast_log(LOG_WARNING, "Unable to write: %s\n", strerror(errno));
                    break;
                }
            }
        }
    }
    printf("\nDisconnected from Asterisk server\n");
}

References __remote_quit_handler(), ast_alloca, ast_consock, ast_el_initialize(), ast_el_read_char(), ast_el_read_default_histfile(), ast_init_logger_for_socket_console(), ast_log, ast_opt_exec, ast_poll, ast_strlen_zero(), ast_term_init(), ast_verbose, buf, el, el_hist, errno, hostname, LOG_ERROR, LOG_WARNING, NULL, prefix, remoteconsolehandler(), remotehostname, send_rasterisk_connect_commands(), sig_flags, strsep(), term_end(), and version.

Referenced by main().

ast_replace_sigchld()

void ast_replace_sigchld

(

void

)

Replace the SIGCHLD handler.

Normally, Asterisk has a SIGCHLD handler that is cleaning up all zombie processes from forking elsewhere in Asterisk. However, if you want to wait*() on the process to retrieve information about it's exit status, then this signal handler needs to be temporarily replaced.

Code that executes this function must call ast_unreplace_sigchld() after it is finished doing the wait*().

Definition at line 1112 of file asterisk.c.

{
    unsigned int level;
 
    ast_mutex_lock(&safe_system_lock);
    level = safe_system_level++;
 
    /* only replace the handler if it has not already been done */
    if (level == 0) {
        sigaction(SIGCHLD, &null_sig_handler, &safe_system_prev_handler);
    }
 
    ast_mutex_unlock(&safe_system_lock);
}

References ast_mutex_lock, ast_mutex_unlock, null_sig_handler, safe_system_level, safe_system_lock, and safe_system_prev_handler.

Referenced by safe_exec_prep().

ast_run_atexits()

static void ast_run_atexits ( int  run_cleanups )

static

Definition at line 1015 of file asterisk.c.

{
    struct ast_atexit *ae;
 
    AST_LIST_LOCK(&atexits);
    while ((ae = AST_LIST_REMOVE_HEAD(&atexits, list))) {
        if (ae->func && (!ae->is_cleanup || run_cleanups)) {
            ae->func();
        }
        ast_free(ae);
    }
    AST_LIST_UNLOCK(&atexits);
}

References ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_atexit::func, ast_atexit::is_cleanup, and ast_atexit::list.

Referenced by check_init(), and really_quit().

ast_safe_execvp()

int ast_safe_execvp	(	int	dualfork,
		const char *	file,
		char *const	argv[]
	)

Safely spawn an external program while closing file descriptors.

Note

This replaces the execvp call in all Asterisk modules

Parameters

dualfork	Non-zero to simulate running the program in the background by forking twice. The option provides similar functionality to the '&' in the OS shell command "cmd &". The option allows Asterisk to run a reaper loop to watch the first fork which immediately exits after spaning the second fork. The actual program is run in the second fork.
file	execvp(file, argv) file parameter
argv	execvp(file, argv) argv parameter

Definition at line 1234 of file asterisk.c.

{
    pid_t pid = safe_exec_prep(dualfork);
 
    if (pid == 0) {
        execvp(file, argv);
        _exit(1);
        /* noreturn from _exit */
    }
 
    return safe_exec_wait(pid);
}

References safe_exec_prep(), and safe_exec_wait().

Referenced by run_externnotify().

ast_safe_system()

int ast_safe_system

(

const char *

s

)

Safely spawn an OS shell command while closing file descriptors.

Note

This replaces the system call in all Asterisk modules

Parameters

s	- OS shell command string to execute.

Warning

Command injection can happen using this call if the passed in string is created using untrusted data from an external source. It is best not to use untrusted data. However, the caller could filter out dangerous characters to avoid command injection.

Definition at line 1247 of file asterisk.c.

{
    pid_t pid = safe_exec_prep(0);
 
    if (pid == 0) {
        execl("/bin/sh", "/bin/sh", "-c", s, (char *) NULL);
        _exit(1);
        /* noreturn from _exit */
    }
 
    return safe_exec_wait(pid);
}

References NULL, safe_exec_prep(), and safe_exec_wait().

Referenced by consolehandler(), and remoteconsolehandler().

ast_set_priority()

int ast_set_priority

(

int

pri

)

We set ourselves to a high priority, that we might pre-empt everything else. If your PBX has heavy activity on it, this is a good thing.

Provided by asterisk.c

Definition at line 1853 of file asterisk.c.

{
    struct sched_param sched;
    memset(&sched, 0, sizeof(sched));
#ifdef __linux__
    if (pri) {
        sched.sched_priority = 10;
        if (sched_setscheduler(0, SCHED_RR, &sched)) {
            return -1;
        }
    } else {
        sched.sched_priority = 0;
        /* According to the manpage, these parameters can never fail. */
        sched_setscheduler(0, SCHED_OTHER, &sched);
    }
#else
    if (pri) {
        if (setpriority(PRIO_PROCESS, 0, -10) == -1) {
            ast_log(LOG_WARNING, "Unable to set high priority\n");
            return -1;
        } else
            ast_verb(1, "Set to high priority\n");
    } else {
        /* According to the manpage, these parameters can never fail. */
        setpriority(PRIO_PROCESS, 0, 0);
    }
#endif
    return 0;
}

References ast_log, ast_verb, LOG_WARNING, sched_setscheduler, and setpriority.

Referenced by app_exec(), asterisk_daemon(), launch_script(), main(), mp3play(), safe_exec_prep(), send_waveform_to_fd(), set_priority_all(), and spawn_mp3().

ast_shutdown_final()

int ast_shutdown_final

(

void

)

Returns

non-zero if the server is actively shutting down.

Since

13.3.0

The server is releasing resources and unloading modules. It won't be long now.

Definition at line 1883 of file asterisk.c.

{
    return shuttingdown == SHUTTING_DOWN_FINAL;
}

References SHUTTING_DOWN_FINAL, and shuttingdown.

Referenced by httpd_process_request(), load_resource(), send_notify(), session_inv_on_media_update(), session_inv_on_redirected(), session_inv_on_rx_offer(), session_inv_on_state_changed(), session_inv_on_tsx_state_changed(), unload_module(), and unload_module().

ast_shutting_down()

int ast_shutting_down

(

void

)

The server is preventing new channel creation in preparation for shutdown and may actively be releasing resources. The shutdown process may be canceled by ast_cancel_shutdown() if it is not too late.

Note

The preparation to shutdown phase can be quite lengthy if we are gracefully shutting down. How long existing calls will last is not up to us.

Returns

non-zero if the server is preparing to or actively shutting down.

Definition at line 1888 of file asterisk.c.

{
    return shutdown_pending;
}

References shutdown_pending.

Referenced by __ast_channel_alloc_ap(), ast_cli_command_full(), ast_unregister_translator(), confbridge_exec(), options_on_rx_request(), and process_message().

AST_THREADSTORAGE_CUSTOM_SCOPE()

AST_THREADSTORAGE_CUSTOM_SCOPE	(	console_state	,
		console_state_init	,
		ast_free_ptr	,
		static
	)

ast_tryconnect()

static int ast_tryconnect ( void  )

static

Definition at line 1696 of file asterisk.c.

{
    struct sockaddr_un sunaddr;
    int res;
    ast_consock = socket(PF_LOCAL, SOCK_STREAM, 0);
    if (ast_consock < 0) {
        fprintf(stderr, "Unable to create socket: %s\n", strerror(errno));
        return 0;
    }
    memset(&sunaddr, 0, sizeof(sunaddr));
    sunaddr.sun_family = AF_LOCAL;
    ast_copy_string(sunaddr.sun_path, ast_config_AST_SOCKET, sizeof(sunaddr.sun_path));
    res = connect(ast_consock, (struct sockaddr *)&sunaddr, sizeof(sunaddr));
    if (res) {
        close(ast_consock);
        ast_consock = -1;
        return 0;
    } else
        return 1;
}

References AF_LOCAL, ast_config_AST_SOCKET, ast_consock, ast_copy_string(), errno, and PF_LOCAL.

Referenced by ast_el_read_char(), and main().

ast_unregister_atexit()

void ast_unregister_atexit

(

void(*)(void)

func

)

Unregister a function registered with ast_register_atexit().

Parameters

func	The callback function to unregister.

Definition at line 1072 of file asterisk.c.

{
    AST_LIST_LOCK(&atexits);
    __ast_unregister_atexit(func);
    AST_LIST_UNLOCK(&atexits);
}

References __ast_unregister_atexit(), AST_LIST_LOCK, AST_LIST_UNLOCK, and ast_atexit::func.

Referenced by unload_module(), and unload_module().

ast_unregister_thread()

void ast_unregister_thread

(

void *

id

)

Definition at line 438 of file asterisk.c.

{
    struct thread_list_t *x;
 
    AST_RWLIST_WRLOCK(&thread_list);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&thread_list, x, list) {
        if ((void *) x->id == id) {
            AST_RWLIST_REMOVE_CURRENT(list);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&thread_list);
    if (x) {
        ast_free(x->name);
        ast_free(x);
    }
}

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, thread_list_t::id, thread_list_t::list, and thread_list_t::name.

Referenced by dummy_start().

ast_unreplace_sigchld()

void ast_unreplace_sigchld

(

void

)

Restore the SIGCHLD handler.

This function is called after a call to ast_replace_sigchld. It restores the SIGCHLD handler that cleans up any zombie processes.

Definition at line 1127 of file asterisk.c.

{
    unsigned int level;
 
    ast_mutex_lock(&safe_system_lock);
 
    /* Wrapping around here is an error */
    ast_assert(safe_system_level > 0);
 
    level = --safe_system_level;
 
    /* only restore the handler if we are the last one */
    if (level == 0) {
        sigaction(SIGCHLD, &safe_system_prev_handler, NULL);
    }
 
    ast_mutex_unlock(&safe_system_lock);
}

References ast_assert, ast_mutex_lock, ast_mutex_unlock, NULL, safe_system_level, safe_system_lock, and safe_system_prev_handler.

Referenced by safe_exec_wait().

asterisk_daemon()

static void asterisk_daemon ( int  isroot, const char *  runuser, const char *  rungroup  )

static

Definition at line 4127 of file asterisk.c.

{
    FILE *f;
    sigset_t sigs;
    int num;
    char *buf;
    char pbx_uuid[AST_UUID_STR_LEN];
 
    /* Set time as soon as possible */
    ast_lastreloadtime = ast_startuptime = ast_tvnow();
 
    /* This needs to remain as high up in the initial start up as possible.
     * daemon causes a fork to occur, which has all sorts of unintended
     * consequences for things that interact with threads.  This call *must*
     * occur before anything in Asterisk spawns or manipulates thread related
     * primitives. */
#if HAVE_WORKING_FORK
    if (ast_opt_always_fork || !ast_opt_no_fork) {
#ifndef HAVE_SBIN_LAUNCHD
        if (daemon(1, 0) < 0) {
            fprintf(stderr, "daemon() failed: %s\n", strerror(errno));
        } else {
            ast_mainpid = getpid();
        }
#else
        fprintf(stderr, "Mac OS X detected.  Use 'launchctl load /Library/LaunchDaemon/org.asterisk.asterisk.plist'.\n");
#endif
    }
#endif
 
    /* At this point everything has been forked successfully,
     * we have determined that we aren't attempting to connect to
     * an Asterisk instance, and that there isn't one already running. */
    multi_thread_safe = 1;
 
    load_astmm_phase_1();
 
    /* Check whether high prio was successfully set by us or some
     * other incantation. */
    if (has_priority()) {
        ast_set_flag64(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY);
    } else {
        ast_clear_flag64(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY);
    }
 
    /* Spawning of astcanary must happen AFTER the call to daemon(3) */
    if (ast_opt_high_priority) {
        snprintf(canary_filename, sizeof(canary_filename), "%s/alt.asterisk.canary.tweet.tweet.tweet", ast_config_AST_RUN_DIR);
 
        /* Don't let the canary child kill Asterisk, if it dies immediately */
        sigaction(SIGPIPE, &ignore_sig_handler, NULL);
 
        canary_pid = fork();
        if (canary_pid == 0) {
            char canary_binary[PATH_MAX], ppid[12];
 
            /* Reset signal handler */
            signal(SIGCHLD, SIG_DFL);
            signal(SIGPIPE, SIG_DFL);
 
            ast_close_fds_above_n(0);
            ast_set_priority(0);
            snprintf(ppid, sizeof(ppid), "%d", (int) ast_mainpid);
 
            /* Use the astcanary binary that we installed */
            snprintf(canary_binary, sizeof(canary_binary), "%s/astcanary", ast_config_AST_SBIN_DIR);
            execl(canary_binary, "astcanary", canary_filename, ppid, (char *)NULL);
 
            /* Should never happen */
            _exit(1);
        } else if (canary_pid > 0) {
            pthread_t dont_care;
            ast_pthread_create_detached(&dont_care, NULL, canary_thread, NULL);
        }
 
        /* Kill the canary when we exit */
        ast_register_atexit(canary_exit);
    }
 
    /* Blindly write the PID file. */
    unlink(ast_config_AST_PID);
    f = fopen(ast_config_AST_PID, "w");
    if (f) {
        fprintf(f, "%ld\n", (long)ast_mainpid);
        fclose(f);
    } else {
        fprintf(stderr, "Unable to open pid file '%s': %s\n", ast_config_AST_PID, strerror(errno));
    }
 
    /* Initialize the terminal.  Since all processes have been forked,
     * we can now start using the standard log messages.
     */
    ast_term_init();
    printf("%s", term_end());
    fflush(stdout);
 
    print_intro_message(runuser, rungroup);
 
    register_config_cli();
 
    check_init(astobj2_init(), "AO2");
    check_init(ast_named_locks_init(), "Named Locks");
 
    if (ast_opt_console) {
        if (el_hist == NULL || el == NULL)
            ast_el_initialize();
        ast_el_read_default_histfile();
    }
 
#ifdef AST_XML_DOCS
    /* Load XML documentation. */
    ast_xmldoc_load_documentation();
#endif
 
    check_init(astdb_init(), "ASTdb");
 
    ast_uuid_init();
 
    if (ast_pbx_uuid_get(pbx_uuid, sizeof(pbx_uuid))) {
        ast_uuid_generate_str(pbx_uuid, sizeof(pbx_uuid));
        ast_db_put("pbx", "UUID", pbx_uuid);
    }
    ast_verb(0, "PBX UUID: %s\n", pbx_uuid);
 
    check_init(ast_json_init(), "libjansson");
    ast_ulaw_init();
    ast_alaw_init();
    ast_utf8_init();
    tdd_init();
    callerid_init();
    ast_builtins_init();
 
    check_init(ast_utils_init(), "Utilities");
    check_init(ast_tps_init(), "Task Processor Core");
    check_init(ast_taskpool_init(), "Taskpool Support");
    check_init(ast_fd_init(), "File Descriptor Debugging");
    check_init(ast_pbx_init(), "ast_pbx_init");
    check_init(aco_init(), "Configuration Option Framework");
    check_init(stasis_init(), "Stasis");
#ifdef TEST_FRAMEWORK
    check_init(ast_test_init(), "Test Framework");
#endif
    check_init(ast_translate_init(), "Translator Core");
 
    ast_aoc_cli_init();
 
    check_init(ast_sorcery_init(), "Sorcery");
    check_init(ast_codec_init(), "Codecs");
    check_init(ast_format_init(), "Formats");
    check_init(ast_format_cache_init(), "Format Cache");
    check_init(ast_codec_builtin_init(), "Built-in Codecs");
    check_init(ast_bucket_init(), "Bucket API");
    check_init(ast_stasis_system_init(), "Stasis system-level information");
    check_init(ast_endpoint_stasis_init(), "Stasis Endpoint");
 
    ast_makesocket();
    /* GCC 4.9 gives a bogus "right-hand operand of comma expression has
     * no effect" warning */
    (void) sigemptyset(&sigs);
    (void) sigaddset(&sigs, SIGHUP);
    (void) sigaddset(&sigs, SIGTERM);
    (void) sigaddset(&sigs, SIGINT);
    (void) sigaddset(&sigs, SIGPIPE);
    (void) sigaddset(&sigs, SIGWINCH);
    pthread_sigmask(SIG_BLOCK, &sigs, NULL);
    sigaction(SIGURG, &urg_handler, NULL);
    signal(SIGINT, __quit_handler);
    signal(SIGTERM, __quit_handler);
    sigaction(SIGHUP, &hup_handler, NULL);
    sigaction(SIGPIPE, &ignore_sig_handler, NULL);
 
    /* ensure that the random number generators are seeded with a different value every time
       Asterisk is started
    */
    srand((unsigned int) getpid() + (unsigned int) time(NULL));
    initstate((unsigned int) getpid() * 65536 + (unsigned int) time(NULL), randompool, sizeof(randompool));
 
    threadstorage_init();
 
    check_init(init_logger(), "Logger");
    run_startup_commands(STARTUP_COMMANDS_PRE_INIT);
 
    check_init(ast_rtp_engine_init(), "RTP Engine");
 
    ast_autoservice_init();
 
    check_init(ast_timing_init(), "Timing");
    check_init(ast_ssl_init(), "SSL");
    read_pjproject_startup_options();
    check_init(ast_pj_init(), "Embedded PJProject");
    check_init(app_init(), "App Core");
    check_init(mwi_init(), "MWI Core");
    check_init(devstate_init(), "Device State Core");
    check_init(ast_msg_init(), "Messaging API");
    check_init(ast_channels_init(), "Channel");
    check_init(ast_endpoint_init(), "Endpoints");
    check_init(ast_pickup_init(), "Call Pickup");
    check_init(ast_bridging_init(), "Bridging");
    check_init(ast_parking_stasis_init(), "Parking Core");
    check_init(ast_device_state_engine_init(), "Device State Engine");
    check_init(ast_presence_state_engine_init(), "Presence State Engine");
    check_init(dns_core_init(), "DNS Resolver Core");
    check_init(ast_dns_system_resolver_init(), "Default DNS resolver");
    check_init(ast_security_stasis_init(), "Security Stasis Topic and Events");
    check_init(ast_image_init(), "Image");
    check_init(ast_file_init(), "Generic File Format Support");
    check_init(load_pbx(), "load_pbx");
    check_init(load_pbx_builtins(), "Builtin PBX Applications");
    check_init(load_pbx_functions_cli(), "PBX Functions Support");
    check_init(load_pbx_variables(), "PBX Variables Support");
    check_init(load_pbx_switch(), "PBX Switch Support");
    check_init(load_pbx_app(), "PBX Application Support");
    check_init(load_pbx_hangup_handler(), "PBX Hangup Handler Support");
    check_init(ast_extension_state_init(), "Extension State Support");
    check_init(ast_extension_state_legacy_init(), "Extension State Legacy Support");
    check_init(ast_extension_state_autohints_init(), "Extension State Autohints Support");
    check_init(ast_local_init(), "Local Proxy Channel Driver");
    check_init(ast_refer_init(), "Refer API");
 
    run_startup_commands(STARTUP_COMMANDS_PRE_MODULE);
 
    /* We should avoid most config loads before this point as they can't use realtime. */
    check_init(load_modules(), "Module");
 
    /*
     * This has to load after the dynamic modules load, as items in the media
     * cache can't be constructed from items in the AstDB without their
     * bucket backends.
     */
    check_init(ast_media_cache_init(), "Media Cache");
 
    /* loads the cli_permissions.conf file needed to implement cli restrictions. */
    ast_cli_perms_init(0);
    ast_cli_channels_init(); /* Not always safe to access CLI commands until startup is complete. */
 
    ast_stun_init();
 
    dnsmgr_start_refresh();
 
    if (ast_opt_no_fork) {
        consolethread = pthread_self();
    }
 
    ast_alertpipe_init(sig_alert_pipe);
 
    ast_process_pending_reloads();
 
    ast_set_flag64(&ast_options, AST_OPT_FLAG_FULLY_BOOTED);
    publish_fully_booted();
 
    pthread_sigmask(SIG_UNBLOCK, &sigs, NULL);
 
    load_astmm_phase_2();
 
    ast_cli_register_multiple(cli_asterisk_shutdown, ARRAY_LEN(cli_asterisk_shutdown));
    ast_cli_register_multiple(cli_asterisk, ARRAY_LEN(cli_asterisk));
    ast_register_cleanup(main_atexit);
 
    run_startup_commands(STARTUP_COMMANDS_FULLY_BOOTED);
    ast_sd_notify("READY=1");
 
    ast_verb(0, COLORIZE_FMT "\n", COLORIZE(COLOR_BRGREEN, 0, "Asterisk Ready."));
 
    logger_queue_start();
 
    if (ast_opt_console) {
        /* Console stuff now... */
        /* Register our quit function */
        char title[296];
        char hostname[MAXHOSTNAMELEN] = "";
 
        if (gethostname(hostname, sizeof(hostname) - 1)) {
            ast_copy_string(hostname, "<Unknown>", sizeof(hostname));
        }
 
        ast_pthread_create_detached(&mon_sig_flags, NULL, monitor_sig_flags, NULL);
 
        set_icon("Asterisk");
        snprintf(title, sizeof(title), "Asterisk Console on '%s' (pid %ld)", hostname, (long)ast_mainpid);
        set_title(title);
 
        el_set(el, EL_GETCFN, ast_el_read_char);
 
        for (;;) {
            if (sig_flags.need_el_end) {
                el_end(el);
 
                return;
            }
 
            if (sig_flags.need_quit || sig_flags.need_quit_handler) {
                quit_handler(0, SHUTDOWN_FAST, 0);
                break;
            }
            buf = (char *) el_gets(el, &num);
 
            if (!buf && write(1, "", 1) < 0)
                return; /* quit */
 
            if (buf) {
                if (buf[strlen(buf)-1] == '\n')
                    buf[strlen(buf)-1] = '\0';
 
                consolehandler(buf);
            }
        }
    }
 
    /* Stall until a quit signal is given */
    monitor_sig_flags(NULL);
}

References __quit_handler(), aco_init(), app_init(), ARRAY_LEN, ast_alaw_init(), ast_alertpipe_init(), ast_aoc_cli_init(), ast_autoservice_init(), ast_bridging_init(), ast_bucket_init(), ast_builtins_init(), ast_channels_init(), ast_clear_flag64, ast_cli_channels_init(), ast_cli_perms_init(), ast_cli_register_multiple, ast_close_fds_above_n(), ast_codec_builtin_init(), ast_codec_init(), ast_config_AST_PID, ast_config_AST_RUN_DIR, ast_config_AST_SBIN_DIR, ast_copy_string(), ast_db_put(), ast_device_state_engine_init(), ast_dns_system_resolver_init(), ast_el_initialize(), ast_el_read_char(), ast_el_read_default_histfile(), ast_endpoint_init(), ast_endpoint_stasis_init(), ast_extension_state_autohints_init(), ast_extension_state_init(), ast_extension_state_legacy_init(), ast_fd_init(), ast_file_init(), ast_format_cache_init(), ast_format_init(), ast_image_init(), ast_json_init(), ast_lastreloadtime, ast_local_init(), ast_mainpid, ast_makesocket(), ast_media_cache_init(), ast_msg_init(), ast_named_locks_init(), ast_opt_always_fork, ast_opt_console, AST_OPT_FLAG_FULLY_BOOTED, AST_OPT_FLAG_HIGH_PRIORITY, ast_opt_high_priority, ast_opt_no_fork, ast_options, ast_parking_stasis_init(), ast_pbx_init(), ast_pbx_uuid_get(), ast_pickup_init(), ast_pj_init(), ast_presence_state_engine_init(), ast_process_pending_reloads(), ast_pthread_create_detached, ast_refer_init(), ast_register_atexit(), ast_register_cleanup(), ast_rtp_engine_init(), ast_sd_notify(), ast_security_stasis_init(), ast_set_flag64, ast_set_priority(), ast_sorcery_init(), ast_ssl_init(), ast_startuptime, ast_stasis_system_init(), ast_stun_init(), ast_taskpool_init(), ast_term_init(), ast_test_init(), ast_timing_init(), ast_tps_init(), ast_translate_init(), ast_tvnow(), ast_ulaw_init(), ast_utf8_init(), ast_utils_init(), ast_uuid_generate_str(), ast_uuid_init(), AST_UUID_STR_LEN, ast_verb, ast_xmldoc_load_documentation(), astdb_init(), astobj2_init(), buf, callerid_init(), canary_exit(), canary_filename, canary_pid, canary_thread(), check_init(), cli_asterisk, cli_asterisk_shutdown, COLOR_BRGREEN, COLORIZE, COLORIZE_FMT, consolehandler(), consolethread, devstate_init(), dns_core_init(), dnsmgr_start_refresh(), el, el_hist, errno, has_priority(), hostname, hup_handler, ignore_sig_handler, init_logger(), load_astmm_phase_1(), load_astmm_phase_2(), load_modules(), load_pbx(), load_pbx_app(), load_pbx_builtins(), load_pbx_functions_cli(), load_pbx_hangup_handler(), load_pbx_switch(), load_pbx_variables(), logger_queue_start(), main_atexit(), MAXHOSTNAMELEN, mon_sig_flags, monitor_sig_flags(), multi_thread_safe, mwi_init(), NULL, PATH_MAX, print_intro_message(), publish_fully_booted(), quit_handler(), randompool, read_pjproject_startup_options(), register_config_cli(), run_startup_commands(), set_icon(), set_title(), SHUTDOWN_FAST, sig_alert_pipe, sig_flags, STARTUP_COMMANDS_FULLY_BOOTED, STARTUP_COMMANDS_PRE_INIT, STARTUP_COMMANDS_PRE_MODULE, stasis_init(), tdd_init(), term_end(), threadstorage_init(), and urg_handler.

Referenced by main().

can_safely_quit()

static int can_safely_quit ( shutdown_nice_t  niceness, int  restart  )

static

Definition at line 1975 of file asterisk.c.

{
    int waited = 0;
 
    /* Check if someone else isn't already doing this. */
    ast_mutex_lock(&safe_system_lock);
    if (shuttingdown != NOT_SHUTTING_DOWN && niceness >= shuttingdown) {
        /* Already in progress and other request was less nice. */
        ast_mutex_unlock(&safe_system_lock);
        ast_verbose("Ignoring asterisk %s request, already in progress.\n", restart ? "restart" : "shutdown");
        return 0;
    }
    shuttingdown = niceness;
    ast_mutex_unlock(&safe_system_lock);
 
    /* Try to get as many CDRs as possible submitted to the backend engines
     * (if in batch mode). really_quit happens to call it again when running
     * the atexit handlers, otherwise this would be a bit early. */
    ast_cdr_engine_term();
 
    /*
     * Shutdown the message queue for the technology agnostic message channel.
     * This has to occur before we pause shutdown pending ast_undestroyed_channels.
     *
     * XXX This is not reversed on shutdown cancel.
     */
    ast_msg_shutdown();
 
    if (niceness == SHUTDOWN_NORMAL) {
        /* Begin shutdown routine, hanging up active channels */
        ast_begin_shutdown();
        if (ast_opt_console) {
            ast_verb(0, "Beginning asterisk %s....\n", restart ? "restart" : "shutdown");
        }
        ast_softhangup_all();
        waited |= wait_for_channels_to_die(niceness, SHUTDOWN_TIMEOUT);
    } else if (niceness >= SHUTDOWN_NICE) {
        if (niceness != SHUTDOWN_REALLY_NICE) {
            ast_begin_shutdown();
        }
        if (ast_opt_console) {
            ast_verb(0, "Waiting for inactivity to perform %s...\n", restart ? "restart" : "halt");
        }
        waited |= wait_for_channels_to_die(niceness, -1);
    }
 
    /* Re-acquire lock and check if someone changed the niceness, in which
     * case someone else has taken over the shutdown.
     */
    ast_mutex_lock(&safe_system_lock);
    if (shuttingdown != niceness) {
        if (shuttingdown == NOT_SHUTTING_DOWN && ast_opt_console) {
            ast_verb(0, "Asterisk %s cancelled.\n", restart ? "restart" : "shutdown");
        }
        ast_mutex_unlock(&safe_system_lock);
        return 0;
    }
 
    if (niceness >= SHUTDOWN_REALLY_NICE) {
        shuttingdown = SHUTTING_DOWN;
        ast_mutex_unlock(&safe_system_lock);
 
        /* No more Mr. Nice guy.  We are committed to shutting down now. */
        ast_begin_shutdown();
        ast_softhangup_all();
        waited |= wait_for_channels_to_die(SHUTTING_DOWN, SHUTDOWN_TIMEOUT);
 
        ast_mutex_lock(&safe_system_lock);
    }
    shuttingdown = SHUTTING_DOWN_FINAL;
    ast_mutex_unlock(&safe_system_lock);
 
    if (niceness >= SHUTDOWN_NORMAL && waited) {
        /*
         * We were not idle.  Give things in progress a chance to
         * recognize the final shutdown phase.
         */
        sleep(1);
    }
    return 1;
}

References ast_begin_shutdown(), ast_cdr_engine_term(), ast_msg_shutdown(), ast_mutex_lock, ast_mutex_unlock, ast_opt_console, ast_softhangup_all(), ast_verb, ast_verbose, NOT_SHUTTING_DOWN, safe_system_lock, SHUTDOWN_NICE, SHUTDOWN_NORMAL, SHUTDOWN_REALLY_NICE, SHUTDOWN_TIMEOUT, SHUTTING_DOWN, SHUTTING_DOWN_FINAL, shuttingdown, and wait_for_channels_to_die().

Referenced by quit_handler().

canary_exit()

static void canary_exit ( void  )

static

Definition at line 3538 of file asterisk.c.

{
    if (canary_pid > 0) {
        int status;
        kill(canary_pid, SIGKILL);
        waitpid(canary_pid, &status, 0);
    }
}

References canary_pid, and status.

Referenced by asterisk_daemon().

canary_thread()

static void * canary_thread ( void *  unused )

static

Definition at line 3509 of file asterisk.c.

{
    struct stat canary_stat;
    struct timeval now;
 
    /* Give the canary time to sing */
    sleep(120);
 
    for (;;) {
        now = ast_tvnow();
        if (stat(canary_filename, &canary_stat) || now.tv_sec > canary_stat.st_mtime + 60) {
            ast_log(LOG_WARNING,
                "The canary is no more.  He has ceased to be!  "
                "He's expired and gone to meet his maker!  "
                "He's a stiff!  Bereft of life, he rests in peace.  "
                "His metabolic processes are now history!  He's off the twig!  "
                "He's kicked the bucket.  He's shuffled off his mortal coil, "
                "run down the curtain, and joined the bleeding choir invisible!!  "
                "THIS is an EX-CANARY.  (Reducing priority)\n");
            set_priority_all(0);
            pthread_exit(NULL);
        }
 
        /* Check the canary once a minute */
        sleep(60);
    }
}

References ast_log, ast_tvnow(), canary_filename, LOG_WARNING, NULL, and set_priority_all().

Referenced by asterisk_daemon().

check_init()

static void check_init ( int  init_result, const char *  name  )

inlinestatic

Definition at line 4114 of file asterisk.c.

{
    if (init_result) {
        if (ast_is_logger_initialized()) {
            ast_log(LOG_ERROR, "%s initialization failed.  ASTERISK EXITING!\n%s", name, term_quit());
        } else {
            fprintf(stderr, "%s initialization failed.  ASTERISK EXITING!\n%s", name, term_quit());
        }
        ast_run_atexits(0);
        exit(init_result == -2 ? 2 : 1);
    }
}

References ast_is_logger_initialized(), ast_log, ast_run_atexits(), LOG_ERROR, name, and term_quit().

Referenced by asterisk_daemon().

cli_complete()

static char * cli_complete ( EditLine *  editline, int  ch  )

static

Definition at line 2991 of file asterisk.c.

{
    int len = 0;
    char *ptr;
    struct ast_vector_string *matches;
    int retval = CC_ERROR;
    char savechr;
    int res;
 
    LineInfo *lf = (LineInfo *)el_line(editline);
 
    savechr = *(char *)lf->cursor;
    *(char *)lf->cursor = '\0';
    ptr = (char *)lf->cursor;
    if (ptr) {
        while (ptr > lf->buffer) {
            if (isspace(*ptr)) {
                ptr++;
                break;
            }
            ptr--;
        }
    }
 
    len = lf->cursor - ptr;
 
    if (ast_opt_remote) {
#define CMD_MATCHESARRAY "_COMMAND MATCHESARRAY \"%s\" \"%s\""
        char *mbuf;
        char *new_mbuf;
        int mlen = 0;
        int maxmbuf = ast_asprintf(&mbuf, CMD_MATCHESARRAY, lf->buffer, ptr);
 
        if (maxmbuf == -1) {
            *((char *) lf->cursor) = savechr;
 
            return (char *)(CC_ERROR);
        }
 
        fdsend(ast_consock, mbuf);
        res = 0;
        mlen = 0;
        mbuf[0] = '\0';
 
        while (!strstr(mbuf, AST_CLI_COMPLETE_EOF) && res != -1) {
            if (mlen + 1024 > maxmbuf) {
                /* Expand buffer to the next 1024 byte increment plus a NULL terminator. */
                maxmbuf = mlen + 1024;
                new_mbuf = ast_realloc(mbuf, maxmbuf + 1);
                if (!new_mbuf) {
                    ast_free(mbuf);
                    *((char *) lf->cursor) = savechr;
 
                    return (char *)(CC_ERROR);
                }
                mbuf = new_mbuf;
            }
            /* Only read 1024 bytes at a time */
            res = read(ast_consock, mbuf + mlen, 1024);
            if (res > 0) {
                if (!strncmp(mbuf, "Usage:", 6)) {
                    /*
                     * Abort on malformed tab completes
                     * If help (tab complete) follows certain
                     * special characters, the main Asterisk process
                     * provides usage for the internal tab complete
                     * helper command that the remote console processes
                     * use.
                     * If this happens, the AST_CLI_COMPLETE_EOF sentinel
                     * value never gets sent. As a result, we'll just block
                     * forever if we don't handle this case.
                     * If we get command usage on a tab complete, then
                     * we know this scenario just happened and we should
                     * just silently ignore and do nothing.
                     */
                    break;
                }
                mlen += res;
                mbuf[mlen] = '\0';
            }
        }
        mbuf[mlen] = '\0';
 
        matches = ast_el_strtoarr(mbuf);
        ast_free(mbuf);
    } else {
        matches = ast_cli_completion_vector((char *)lf->buffer, ptr);
    }
 
    if (matches) {
        int i;
        int maxlen, match_len;
        const char *best_match = AST_VECTOR_GET(matches, 0);
 
        if (!ast_strlen_zero(best_match)) {
            el_deletestr(editline, (int) len);
            el_insertstr(editline, best_match);
            retval = CC_REFRESH;
        }
 
        if (AST_VECTOR_SIZE(matches) == 2) {
            /* Found an exact match */
            el_insertstr(editline, " ");
            retval = CC_REFRESH;
        } else {
            /* Must be more than one match */
            for (i = 1, maxlen = 0; i < AST_VECTOR_SIZE(matches); i++) {
                match_len = strlen(AST_VECTOR_GET(matches, i));
                if (match_len > maxlen) {
                    maxlen = match_len;
                }
            }
 
            fprintf(stdout, "\n");
            ast_cli_display_match_list(matches, maxlen);
            retval = CC_REDISPLAY;
        }
        AST_VECTOR_CALLBACK_VOID(matches, ast_free);
        AST_VECTOR_PTR_FREE(matches);
    }
 
    *((char *) lf->cursor) = savechr;
 
    return (char *)(long)retval;
}

References ast_asprintf, AST_CLI_COMPLETE_EOF, ast_cli_completion_vector(), ast_cli_display_match_list(), ast_consock, ast_el_strtoarr(), ast_free, ast_opt_remote, ast_realloc, ast_strlen_zero(), AST_VECTOR_CALLBACK_VOID, AST_VECTOR_GET, AST_VECTOR_PTR_FREE, AST_VECTOR_SIZE, CMD_MATCHESARRAY, fdsend(), and len().

Referenced by ast_el_initialize().

cli_prompt()

static char * cli_prompt ( EditLine *  editline )

static

Definition at line 2804 of file asterisk.c.

{
    char tmp[100];
    char *pfmt;
    int color_used = 0;
    static int cli_prompt_changes = 0;
    struct passwd *pw;
    struct group *gr;
 
    if (prompt == NULL) {
        prompt = ast_str_create(100);
    } else if (!cli_prompt_changes) {
        return ast_str_buffer(prompt);
    } else {
        ast_str_reset(prompt);
    }
 
    if ((pfmt = getenv("ASTERISK_PROMPT"))) {
        char *t = pfmt;
        struct timeval ts = ast_tvnow();
        while (*t != '\0') {
            if (*t == '%') {
                char hostname[MAXHOSTNAMELEN] = "";
                int i, which;
                struct ast_tm tm = { 0, };
                int fgcolor = COLOR_WHITE, bgcolor = COLOR_BLACK;
 
                t++;
                switch (*t) {
                case 'C': /* color */
                    t++;
                    if (sscanf(t, "%30d;%30d%n", &fgcolor, &bgcolor, &i) == 2) {
                        ast_term_color_code(&prompt, fgcolor, bgcolor);
                        t += i - 1;
                    } else if (sscanf(t, "%30d%n", &fgcolor, &i) == 1) {
                        ast_term_color_code(&prompt, fgcolor, 0);
                        t += i - 1;
                    }
 
                    /* If the color has been reset correctly, then there's no need to reset it later */
                    color_used = ((fgcolor == COLOR_WHITE) && (bgcolor == COLOR_BLACK)) ? 0 : 1;
                    break;
                case 'd': /* date */
                    if (ast_localtime(&ts, &tm, NULL)) {
                        ast_strftime(tmp, sizeof(tmp), "%Y-%m-%d", &tm);
                        ast_str_append(&prompt, 0, "%s", tmp);
                        cli_prompt_changes++;
                    }
                    break;
                case 'g': /* group */
                    if ((gr = getgrgid(getgid()))) {
                        ast_str_append(&prompt, 0, "%s", gr->gr_name);
                    }
                    break;
                case 'h': /* hostname */
                    if (!gethostname(hostname, sizeof(hostname) - 1)) {
                        ast_str_append(&prompt, 0, "%s", hostname);
                    } else {
                        ast_str_append(&prompt, 0, "%s", "localhost");
                    }
                    break;
                case 'H': /* short hostname */
                    if (!gethostname(hostname, sizeof(hostname) - 1)) {
                        char *dotptr;
                        if ((dotptr = strchr(hostname, '.'))) {
                            *dotptr = '\0';
                        }
                        ast_str_append(&prompt, 0, "%s", hostname);
                    } else {
                        ast_str_append(&prompt, 0, "%s", "localhost");
                    }
                    break;
#ifdef HAVE_GETLOADAVG
                case 'l': /* load avg */
                    t++;
                    if (sscanf(t, "%30d", &which) == 1 && which > 0 && which <= 3) {
                        double list[3];
                        getloadavg(list, 3);
                        ast_str_append(&prompt, 0, "%.2f", list[which - 1]);
                        cli_prompt_changes++;
                    }
                    break;
#endif
                case 's': /* Asterisk system name (from asterisk.conf) */
                    ast_str_append(&prompt, 0, "%s", ast_config_AST_SYSTEM_NAME);
                    break;
                case 't': /* time */
                    if (ast_localtime(&ts, &tm, NULL)) {
                        ast_strftime(tmp, sizeof(tmp), "%H:%M:%S", &tm);
                        ast_str_append(&prompt, 0, "%s", tmp);
                        cli_prompt_changes++;
                    }
                    break;
                case 'u': /* username */
                    if ((pw = getpwuid(getuid()))) {
                        ast_str_append(&prompt, 0, "%s", pw->pw_name);
                    }
                    break;
                case '#': /* process console or remote? */
                    ast_str_append(&prompt, 0, "%c", ast_opt_remote ? '>' : '#');
                    break;
                case '%': /* literal % */
                    ast_str_append(&prompt, 0, "%c", '%');
                    break;
                case '\0': /* % is last character - prevent bug */
                    t--;
                    break;
                }
            } else {
                ast_str_append(&prompt, 0, "%c", *t);
            }
            t++;
        }
        if (color_used) {
            /* Force colors back to normal at end */
            ast_term_color_code(&prompt, 0, 0);
        }
    } else {
        ast_str_set(&prompt, 0, "%s%s",
            remotehostname ? remotehostname : "",
            ASTERISK_PROMPT);
    }
 
    return ast_str_buffer(prompt);
}

References ast_config_AST_SYSTEM_NAME, ast_localtime(), ast_opt_remote, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_reset(), ast_str_set(), ast_strftime(), ast_term_color_code(), ast_tvnow(), ASTERISK_PROMPT, COLOR_BLACK, COLOR_WHITE, getloadavg(), hostname, MAXHOSTNAMELEN, NULL, prompt, and remotehostname.

Referenced by ast_el_initialize().

console_print()

static int console_print ( const char *  s )

static

Definition at line 2228 of file asterisk.c.

{
    struct console_state_data *state =
        ast_threadstorage_get(&console_state, sizeof(*state));
 
    char prefix[80];
    const char *c;
    int num, res = 0;
    unsigned int newline;
 
    do {
        if (VERBOSE_HASMAGIC(s)) {
 
            /* always use the given line's level, otherwise
               we'll use the last line's level */
            state->verbose_line_level = VERBOSE_MAGIC2LEVEL(s);
 
            /* move past magic */
            s++;
 
            set_header(prefix, sizeof(prefix), state->verbose_line_level);
        } else {
            *prefix = '\0';
        }
        c = s;
 
        /* for a given line separate on verbose magic, newline, and eol */
        if ((s = strchr(c, '\n'))) {
            ++s;
            newline = 1;
        } else {
            s = strchr(c, '\0');
            newline = 0;
        }
 
        /* check if we should write this line after calculating begin/end
           so we process the case of a higher level line embedded within
           two lower level lines */
        if (state->verbose_line_level > option_verbose) {
            continue;
        }
 
        if (!ast_strlen_zero(prefix)) {
            fputs(prefix, stdout);
        }
 
        num = s - c;
        if (fwrite(c, sizeof(char), num, stdout) < num) {
            break;
        }
 
        if (!res) {
            /* if at least some info has been written
               we'll want to return true */
            res = 1;
        }
    } while (*s);
 
    if (newline) {
        /* if ending on a newline then reset last level to zero
            since what follows may be not be logging output */
        state->verbose_line_level = 0;
    }
 
    if (res) {
        fflush(stdout);
    }
 
    return res;
}

References ast_strlen_zero(), ast_threadstorage_get(), c, option_verbose, prefix, set_header(), VERBOSE_HASMAGIC, and VERBOSE_MAGIC2LEVEL.

Referenced by ast_console_puts_mutable_full(), and ast_el_read_char().

console_state_init()

static int console_state_init ( void *  ptr )

static

Definition at line 2219 of file asterisk.c.

{
    struct console_state_data *state = ptr;
    state->verbose_line_level = 0;
    return 0;
}

consolehandler()

static void consolehandler ( const char *  s )

static

Definition at line 2310 of file asterisk.c.

{
    printf("%s", term_end());
    fflush(stdout);
 
    /* Called when readline data is available */
    if (!ast_all_zeros(s))
        ast_el_add_history(s);
    /* The real handler for bang */
    if (s[0] == '!') {
        if (s[1])
            ast_safe_system(s+1);
        else
            ast_safe_system(getenv("SHELL") ? getenv("SHELL") : "/bin/sh");
    } else
        ast_cli_command(STDOUT_FILENO, s);
}

References ast_all_zeros(), ast_cli_command, ast_el_add_history(), ast_safe_system(), and term_end().

Referenced by asterisk_daemon().

env_init()

static void env_init ( void  )

static

Definition at line 3590 of file asterisk.c.

{
    setenv("AST_SYSTEMNAME", ast_config_AST_SYSTEM_NAME, 1);
    setenv("AST_BUILD_HOST", ast_build_hostname, 1);
    setenv("AST_BUILD_DATE", ast_build_date, 1);
    setenv("AST_BUILD_KERNEL", ast_build_kernel, 1);
    setenv("AST_BUILD_MACHINE", ast_build_machine, 1);
    setenv("AST_BUILD_OS", ast_build_os, 1);
    setenv("AST_BUILD_USER", ast_build_user, 1);
    setenv("AST_VERSION", ast_get_version(), 1);
}

References ast_build_date, ast_build_hostname, ast_build_kernel, ast_build_machine, ast_build_os, ast_build_user, ast_config_AST_SYSTEM_NAME, ast_get_version(), and setenv().

Referenced by main().

fdprint()

static int fdprint ( int  fd, const char *  s  )

static

Definition at line 1086 of file asterisk.c.

{
    return write(fd, s, strlen(s));
}

Referenced by ast_network_puts(), ast_network_puts_mutable(), listener(), and netconsole().

fdsend()

static int fdsend ( int  fd, const char *  s  )

static

Definition at line 1080 of file asterisk.c.

{
    return write(fd, s, strlen(s) + 1);
}

Referenced by cli_complete(), and send_rasterisk_connect_commands().

handle_abort_shutdown()

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

static

Definition at line 2506 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core abort shutdown";
        e->usage =
            "Usage: core abort shutdown\n"
            "       Causes Asterisk to abort an executing shutdown or restart, and resume normal\n"
            "       call operations.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
 
    ast_cancel_shutdown();
 
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cancel_shutdown(), ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_bang()

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

static

Definition at line 2529 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "!";
        e->usage =
            "Usage: !<command>\n"
            "       Executes a given shell command\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    return CLI_SUCCESS;
}

References CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_clear_profile()

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

static

Definition at line 954 of file asterisk.c.

{
    int i, min, max;
    const char *search = NULL;
    switch (cmd) {
    case CLI_INIT:
        e->command = "core clear profile";
        e->usage = "Usage: core clear profile\n"
               "       clear profile information";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (prof_data == NULL)
        return 0;
 
    DEFINE_PROFILE_MIN_MAX_VALUES;
    for (i= min; i < max; i++) {
        if (!search || strstr(prof_data->e[i].name, search)) {
            prof_data->e[i].value = 0;
            prof_data->e[i].events = 0;
        }
    }
    return CLI_SUCCESS;
}

References CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, DEFINE_PROFILE_MIN_MAX_VALUES, profile_data::e, profile_entry::events, max, min, profile_entry::name, NULL, prof_data, ast_cli_entry::usage, and profile_entry::value.

handle_restart_gracefully()

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

static

Definition at line 2464 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core restart gracefully";
        e->usage =
            "Usage: core restart gracefully\n"
            "       Causes Asterisk to stop accepting new calls and exec() itself performing a cold\n"
            "       restart when all active calls have ended.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    quit_handler(0, SHUTDOWN_NICE, 1 /* restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_NICE, and ast_cli_entry::usage.

handle_restart_now()

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

static

Definition at line 2443 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core restart now";
        e->usage =
            "Usage: core restart now\n"
            "       Causes Asterisk to hangup all calls and exec() itself performing a cold\n"
            "       restart.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    quit_handler(0, SHUTDOWN_NORMAL, 1 /* restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_NORMAL, and ast_cli_entry::usage.

handle_restart_when_convenient()

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

static

Definition at line 2485 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core restart when convenient";
        e->usage =
            "Usage: core restart when convenient\n"
            "       Causes Asterisk to perform a cold restart when all active calls have ended.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, "Waiting for inactivity to perform restart\n");
    quit_handler(0, SHUTDOWN_REALLY_NICE, 1 /* restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli(), ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_REALLY_NICE, and ast_cli_entry::usage.

handle_show_profile()

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

static

Definition at line 919 of file asterisk.c.

{
    int i, min, max;
    const char *search = NULL;
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show profile";
        e->usage = "Usage: core show profile\n"
               "       show profile information";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (prof_data == NULL)
        return 0;
 
    DEFINE_PROFILE_MIN_MAX_VALUES;
    ast_cli(a->fd, "profile values (%d, allocated %d)\n-------------------\n",
        prof_data->entries, prof_data->max_size);
    ast_cli(a->fd, "%6s   %8s  %10s %12s %12s  %s\n", "ID", "Scale", "Events",
            "Value", "Average", "Name");
    for (i = min; i < max; i++) {
        struct profile_entry *entry = &prof_data->e[i];
        if (!search || strstr(entry->name, search))
            ast_cli(a->fd, "%6d: [%8ld] %10ld %12lld %12lld  %s\n",
            i,
            (long)entry->scale,
            (long)entry->events, (long long)entry->value,
            (long long)(entry->events ? entry->value / entry->events : entry->value),
            entry->name);
    }
    return CLI_SUCCESS;
}

References a, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, DEFINE_PROFILE_MIN_MAX_VALUES, profile_data::e, profile_data::entries, profile_entry::events, max, profile_data::max_size, min, profile_entry::name, NULL, prof_data, profile_entry::scale, and profile_entry::value.

handle_show_settings()

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

static

Give an overview of core settings.

Todo:

we could check musiconhold, voicemail, smdi, adsi, queues

Definition at line 475 of file asterisk.c.

{
    char buf[BUFSIZ];
    struct ast_tm tm;
    char eid_str[128];
    struct rlimit limits;
    char pbx_uuid[AST_UUID_STR_LEN];
#if defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS)
    char dir[PATH_MAX];
#endif
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show settings";
        e->usage = "Usage: core show settings\n"
               "       Show core misc settings";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_eid_to_str(eid_str, sizeof(eid_str), &ast_eid_default);
    ast_pbx_uuid_get(pbx_uuid, sizeof(pbx_uuid));
 
    ast_cli(a->fd, "\nPBX Core settings\n");
    ast_cli(a->fd, "-----------------\n");
    ast_cli(a->fd, "  Version:                     %s\n", ast_get_version());
    ast_cli(a->fd, "  ABI related Build Options:   %s\n", S_OR(ast_get_build_opts(), "(none)"));
    ast_cli(a->fd, "  All Build Options:           %s\n", S_OR(ast_get_build_opts_all(), "(none)"));
    if (ast_option_maxcalls)
        ast_cli(a->fd, "  Maximum calls:               %d (Current %d)\n", ast_option_maxcalls, ast_active_channels());
    else
        ast_cli(a->fd, "  Maximum calls:               Not set\n");
 
    if (getrlimit(RLIMIT_NOFILE, &limits)) {
        ast_cli(a->fd, "  Maximum open file handles:   Error because of %s\n", strerror(errno));
    } else if (limits.rlim_cur == RLIM_INFINITY) {
        ast_cli(a->fd, "  Maximum open file handles:   Unlimited\n");
    } else if (limits.rlim_cur < ast_option_maxfiles) {
        ast_cli(a->fd, "  Maximum open file handles:   %d (is) %d (requested)\n", (int) limits.rlim_cur, ast_option_maxfiles);
    } else {
        ast_cli(a->fd, "  Maximum open file handles:   %d\n", (int) limits.rlim_cur);
    }
 
    ast_cli(a->fd, "  Root console verbosity:      %d\n", option_verbose);
    ast_cli(a->fd, "  Current console verbosity:   %d\n", ast_verb_console_get());
    ast_cli(a->fd, "  Debug level:                 %d\n", option_debug);
    ast_cli(a->fd, "  Trace level:                 %d\n", option_trace);
    ast_cli(a->fd, "  Dump core on crash:          %s\n", ast_opt_dump_core ? "Yes" : "No");
    print_file(a->fd, "  Core dump file:              ", "/proc/sys/kernel/core_pattern");
    ast_cli(a->fd, "  Maximum load average:        %lf\n", ast_option_maxload);
#if defined(HAVE_SYSINFO)
    ast_cli(a->fd, "  Minimum free memory:         %ld MB\n", option_minmemfree);
#endif
    if (ast_localtime(&ast_startuptime, &tm, NULL)) {
        ast_strftime(buf, sizeof(buf), "%H:%M:%S", &tm);
        ast_cli(a->fd, "  Startup time:                %s\n", buf);
    }
    if (ast_localtime(&ast_lastreloadtime, &tm, NULL)) {
        ast_strftime(buf, sizeof(buf), "%H:%M:%S", &tm);
        ast_cli(a->fd, "  Last reload time:            %s\n", buf);
    }
    ast_cli(a->fd, "  System:                      %s/%s built by %s on %s %s\n", ast_build_os, ast_build_kernel, ast_build_user, ast_build_machine, ast_build_date);
    ast_cli(a->fd, "  System name:                 %s\n", ast_config_AST_SYSTEM_NAME);
    ast_cli(a->fd, "  Entity ID:                   %s\n", eid_str);
    ast_cli(a->fd, "  PBX UUID:                    %s\n", pbx_uuid);
    ast_cli(a->fd, "  Default language:            %s\n", ast_defaultlanguage);
    ast_cli(a->fd, "  User name and group:         %s/%s\n", ast_config_AST_RUN_USER, ast_config_AST_RUN_GROUP);
#if defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS)
#if defined(HAVE_EUIDACCESS) && !defined(HAVE_EACCESS)
#define eaccess euidaccess
#endif
    if (!getcwd(dir, sizeof(dir))) {
        if (eaccess(dir, R_OK | X_OK | F_OK)) {
            ast_cli(a->fd, "  Running directory:           %s\n", "Unable to access");
        } else {
            ast_cli(a->fd, "  Running directory:           %s (%s)\n", dir, "Unable to access");
        }
    } else {
        ast_cli(a->fd, "  Running directory:           %s\n", dir);
    }
#endif /* defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS) */
    ast_cli(a->fd, "  Executable includes:         %s\n", ast_opt_exec_includes ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Transcode via SLIN:          %s\n", ast_opt_transcode_via_slin ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Transmit silence during rec: %s\n", ast_opt_transmit_silence ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Generic PLC:                 %s\n", ast_opt_generic_plc ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Generic PLC on equal codecs: %s\n", ast_opt_generic_plc_on_equal_codecs ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Hide Msg Chan AMI events:    %s\n", ast_opt_hide_messaging_ami_events ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Sounds search custom dir:    %s\n", ast_opt_sounds_search_custom ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Min DTMF duration::          %u\n", option_dtmfminduration);
#if !defined(LOW_MEMORY)
    ast_cli(a->fd, "  Cache media frames:          %s\n", ast_opt_cache_media_frames ? "Enabled" : "Disabled");
#endif
    ast_cli(a->fd, "  RTP use dynamic payloads:    %u\n", ast_option_rtpusedynamic);
 
    if (ast_option_rtpptdynamic == AST_RTP_PT_LAST_REASSIGN) {
        ast_cli(a->fd, "  RTP dynamic payload types:   %u,%u-%u\n",
                ast_option_rtpptdynamic,
                AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_MAX_PT - 1);
    } else if (ast_option_rtpptdynamic < AST_RTP_PT_LAST_REASSIGN) {
        ast_cli(a->fd, "  RTP dynamic payload types:   %u-%u,%u-%u\n",
                ast_option_rtpptdynamic, AST_RTP_PT_LAST_REASSIGN,
                AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_MAX_PT - 1);
    } else {
        ast_cli(a->fd, "  RTP dynamic payload types:   %u-%u\n",
                AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_MAX_PT - 1);
    }
    ast_cli(a->fd, "  Channel storage backend:     %s\n",
        ast_channel_get_current_storage_driver_name());
    ast_cli(a->fd, "  Shell on remote consoles:    %s\n",
        ast_option_disable_remote_console_shell ? "Disabled" : "Enabled");
 
    ast_cli(a->fd, "\n* Subsystems\n");
    ast_cli(a->fd, "  -------------\n");
    ast_cli(a->fd, "  Manager (AMI):               %s\n", ast_manager_check_enabled() ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Web Manager (AMI/HTTP):      %s\n", ast_webmanager_check_enabled() ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Call data records:           %s\n", ast_cdr_is_enabled() ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Realtime Architecture (ARA): %s\n", ast_realtime_enabled() ? "Enabled" : "Disabled");
 
    /*! \todo we could check musiconhold, voicemail, smdi, adsi, queues  */
 
    ast_cli(a->fd, "\n* Directories\n");
    ast_cli(a->fd, "  -------------\n");
    ast_cli(a->fd, "  Configuration file:          %s\n", ast_config_AST_CONFIG_FILE);
    ast_cli(a->fd, "  Configuration directory:     %s\n", ast_config_AST_CONFIG_DIR);
    ast_cli(a->fd, "  Module directory:            %s\n", ast_config_AST_MODULE_DIR);
    ast_cli(a->fd, "  Spool directory:             %s\n", ast_config_AST_SPOOL_DIR);
    ast_cli(a->fd, "  Log directory:               %s\n", ast_config_AST_LOG_DIR);
    ast_cli(a->fd, "  Run/Sockets directory:       %s\n", ast_config_AST_RUN_DIR);
    ast_cli(a->fd, "  PID file:                    %s\n", ast_config_AST_PID);
    ast_cli(a->fd, "  VarLib directory:            %s\n", ast_config_AST_VAR_DIR);
    ast_cli(a->fd, "  Data directory:              %s\n", ast_config_AST_DATA_DIR);
    ast_cli(a->fd, "  ASTDB:                       %s\n", ast_config_AST_DB);
    ast_cli(a->fd, "  IAX2 Keys directory:         %s\n", ast_config_AST_KEY_DIR);
    ast_cli(a->fd, "  AGI Scripts directory:       %s\n", ast_config_AST_AGI_DIR);
    ast_cli(a->fd, "  Cache directory:             %s\n", ast_config_AST_CACHE_DIR);
    ast_cli(a->fd, "\n\n");
    return CLI_SUCCESS;
}

References a, ast_active_channels(), ast_build_date, ast_build_kernel, ast_build_machine, ast_build_os, ast_build_user, ast_cdr_is_enabled(), ast_channel_get_current_storage_driver_name(), ast_cli(), ast_config_AST_AGI_DIR, ast_config_AST_CACHE_DIR, ast_config_AST_CONFIG_DIR, ast_config_AST_CONFIG_FILE, ast_config_AST_DATA_DIR, ast_config_AST_DB, ast_config_AST_KEY_DIR, ast_config_AST_LOG_DIR, ast_config_AST_MODULE_DIR, ast_config_AST_PID, ast_config_AST_RUN_DIR, ast_config_AST_RUN_GROUP, ast_config_AST_RUN_USER, ast_config_AST_SPOOL_DIR, ast_config_AST_SYSTEM_NAME, ast_config_AST_VAR_DIR, ast_defaultlanguage, ast_eid_default, ast_eid_to_str(), ast_get_build_opts(), ast_get_build_opts_all(), ast_get_version(), ast_lastreloadtime, ast_localtime(), ast_manager_check_enabled(), ast_opt_cache_media_frames, ast_opt_dump_core, ast_opt_exec_includes, ast_opt_generic_plc, ast_opt_generic_plc_on_equal_codecs, ast_opt_hide_messaging_ami_events, ast_opt_sounds_search_custom, ast_opt_transcode_via_slin, ast_opt_transmit_silence, ast_option_disable_remote_console_shell, ast_option_maxcalls, ast_option_maxfiles, ast_option_maxload, ast_option_rtpptdynamic, ast_option_rtpusedynamic, ast_pbx_uuid_get(), ast_realtime_enabled(), AST_RTP_MAX_PT, AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_PT_LAST_REASSIGN, ast_startuptime, ast_strftime(), AST_UUID_STR_LEN, ast_verb_console_get(), ast_webmanager_check_enabled(), buf, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, errno, F_OK, NULL, option_debug, option_dtmfminduration, option_minmemfree, option_trace, option_verbose, PATH_MAX, print_file(), R_OK, S_OR, and ast_cli_entry::usage.

handle_show_sysinfo()

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

static

Give an overview of system statistics.

Definition at line 681 of file asterisk.c.

{
    uint64_t physmem, freeram;
#if defined(HAVE_SYSINFO) || defined(HAVE_SWAPCTL)
    int totalswap = 0;
    uint64_t freeswap = 0;
#endif
    int nprocs = 0;
    long uptime = 0;
#if defined(HAVE_SYSINFO)
    struct sysinfo sys_info;
#elif defined(HAVE_SYSCTL)
    static int pageshift;
    struct vmtotal vmtotal;
    struct timeval  boottime;
    time_t  now;
    int mib[2], pagesize;
#if defined(HAVE_SWAPCTL)
    int usedswap = 0;
#endif
    size_t len;
#endif
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show sysinfo";
        e->usage =
            "Usage: core show sysinfo\n"
            "       List current system information.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
#if defined(HAVE_SYSINFO)
    sysinfo(&sys_info);
    uptime = sys_info.uptime / 3600;
    physmem = sys_info.totalram * sys_info.mem_unit;
    freeram = (sys_info.freeram * sys_info.mem_unit) / 1024;
    totalswap = (sys_info.totalswap * sys_info.mem_unit) / 1024;
    freeswap = (sys_info.freeswap * sys_info.mem_unit) / 1024;
    nprocs = sys_info.procs;
#elif defined(HAVE_SYSCTL)
    /* calculate the uptime by looking at boottime */
    time(&now);
    mib[0] = CTL_KERN;
    mib[1] = KERN_BOOTTIME;
    len = sizeof(boottime);
    if (sysctl(mib, 2, &boottime, &len, NULL, 0) != -1) {
        uptime = now - boottime.tv_sec;
    }
    uptime = uptime/3600;
    /* grab total physical memory  */
    mib[0] = CTL_HW;
#if defined(HW_PHYSMEM64)
    mib[1] = HW_PHYSMEM64;
#else
    mib[1] = HW_PHYSMEM;
#endif
    len = sizeof(physmem);
    sysctl(mib, 2, &physmem, &len, NULL, 0);
 
    pagesize = getpagesize();
    pageshift = 0;
    while (pagesize > 1) {
        pageshift++;
        pagesize >>= 1;
    }
 
    /* we only need the amount of log(2)1024 for our conversion */
    pageshift -= 10;
 
    /* grab vm totals */
    mib[0] = CTL_VM;
    mib[1] = VM_METER;
    len = sizeof(vmtotal);
    sysctl(mib, 2, &vmtotal, &len, NULL, 0);
    freeram = (vmtotal.t_free << pageshift);
    /* generate swap usage and totals */
#if defined(HAVE_SWAPCTL)
    swapmode(&usedswap, &totalswap);
    freeswap = (totalswap - usedswap);
#endif
    /* grab number of processes */
#if defined(__OpenBSD__)
    mib[0] = CTL_KERN;
    mib[1] = KERN_NPROCS;
    len = sizeof(nprocs);
    sysctl(mib, 2, &nprocs, &len, NULL, 0);
#endif
#endif
 
    ast_cli(a->fd, "\nSystem Statistics\n");
    ast_cli(a->fd, "-----------------\n");
    ast_cli(a->fd, "  System Uptime:             %ld hours\n", uptime);
    ast_cli(a->fd, "  Total RAM:                 %" PRIu64 " KiB\n", physmem / 1024);
    ast_cli(a->fd, "  Free RAM:                  %" PRIu64 " KiB\n", freeram);
#if defined(HAVE_SYSINFO)
    ast_cli(a->fd, "  Buffer RAM:                %" PRIu64 " KiB\n", ((uint64_t) sys_info.bufferram * sys_info.mem_unit) / 1024);
#endif
#if defined(HAVE_SYSINFO) || defined(HAVE_SWAPCTL)
    ast_cli(a->fd, "  Total Swap Space:          %d KiB\n", totalswap);
    ast_cli(a->fd, "  Free Swap Space:           %" PRIu64 " KiB\n\n", freeswap);
#endif
    ast_cli(a->fd, "  Number of Processes:       %d \n\n", nprocs);
    return CLI_SUCCESS;
}

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

handle_show_threads()

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

static

Definition at line 615 of file asterisk.c.

{
    int count = 0;
    struct thread_list_t *cur;
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show threads";
        e->usage =
            "Usage: core show threads\n"
            "       List threads currently active in the system.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    AST_RWLIST_RDLOCK(&thread_list);
    AST_RWLIST_TRAVERSE(&thread_list, cur, list) {
        ast_cli(a->fd, "%p %d %s\n", (void *)cur->id, cur->lwp, cur->name);
        count++;
    }
    AST_RWLIST_UNLOCK(&thread_list);
    ast_cli(a->fd, "%d threads listed.\n", count);
    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, thread_list_t::id, thread_list_t::list, thread_list_t::lwp, thread_list_t::name, NULL, and ast_cli_entry::usage.

handle_stop_gracefully()

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

static

Definition at line 2401 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core stop gracefully";
        e->usage =
            "Usage: core stop gracefully\n"
            "       Causes Asterisk to not accept new calls, and exit when all\n"
            "       active calls have terminated normally.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    quit_handler(0, SHUTDOWN_NICE, 0 /* no restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_NICE, and ast_cli_entry::usage.

handle_stop_now()

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

static

Definition at line 2381 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core stop now";
        e->usage =
            "Usage: core stop now\n"
            "       Shuts down a running Asterisk immediately, hanging up all active calls .\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    quit_handler(0, SHUTDOWN_NORMAL, 0 /* not restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_NORMAL, and ast_cli_entry::usage.

handle_stop_when_convenient()

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

static

Definition at line 2422 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core stop when convenient";
        e->usage =
            "Usage: core stop when convenient\n"
            "       Causes Asterisk to perform a shutdown when all active calls have ended.\n";
        ast_cli_allow_at_shutdown(e);
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, "Waiting for inactivity to perform halt\n");
    quit_handler(0, SHUTDOWN_REALLY_NICE, 0 /* don't restart */);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli(), ast_cli_allow_at_shutdown(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, quit_handler(), SHUTDOWN_REALLY_NICE, and ast_cli_entry::usage.

handle_version()

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

static

Definition at line 2360 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show version";
        e->usage =
            "Usage: core show version\n"
            "       Shows Asterisk version information.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, "Asterisk %s built by %s @ %s on a %s running %s on %s\n",
        ast_get_version(), ast_build_user, ast_build_hostname,
        ast_build_machine, ast_build_os, ast_build_date);
    return CLI_SUCCESS;
}

References a, ast_build_date, ast_build_hostname, ast_build_machine, ast_build_os, ast_build_user, ast_cli(), ast_get_version(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

has_priority()

static int has_priority ( void  )

static

Check whether we were set to high(er) priority.

Definition at line 1790 of file asterisk.c.

{
    /* Neither of these calls should fail with these arguments. */
#ifdef __linux__
    /* For SCHED_OTHER, SCHED_BATCH and SCHED_IDLE, this will return
     * 0. For the realtime priorities SCHED_RR and SCHED_FIFO, it
     * will return something >= 1. */
    return sched_getscheduler(0);
#else
    /* getpriority() can return a value in -20..19 (or even -INF..20)
     * where negative numbers are high priority. We don't bother
     * checking errno. If the query fails and it returns -1, we'll
     * assume that we're running at high prio; a safe assumption
     * that will enable the resource starvation monitor (canary)
     * just in case. */
    return (getpriority(PRIO_PROCESS, 0) < 0);
#endif
}

Referenced by ast_ari_validate_dialplan_cep(), and asterisk_daemon().

listener()

static void * listener ( void *  unused )

static

Definition at line 1530 of file asterisk.c.

{
    struct sockaddr_un sunaddr;
    int s;
    socklen_t len;
    int x;
    int poll_result;
    struct pollfd fds[1];
 
    for (;;) {
        if (ast_socket < 0) {
            return NULL;
        }
        fds[0].fd = ast_socket;
        fds[0].events = POLLIN;
        poll_result = ast_poll(fds, 1, -1);
        pthread_testcancel();
        if (poll_result < 0) {
            if (errno != EINTR) {
                ast_log(LOG_WARNING, "poll returned error: %s\n", strerror(errno));
            }
            continue;
        }
        len = sizeof(sunaddr);
        s = accept(ast_socket, (struct sockaddr *)&sunaddr, &len);
        if (s < 0) {
            if (errno != EINTR)
                ast_log(LOG_WARNING, "Accept returned %d: %s\n", s, strerror(errno));
        } else {
#if defined(SO_PASSCRED)
            int sckopt = 1;
            /* turn on socket credentials passing. */
            if (setsockopt(s, SOL_SOCKET, SO_PASSCRED, &sckopt, sizeof(sckopt)) < 0) {
                ast_log(LOG_WARNING, "Unable to turn on socket credentials passing\n");
                close(s);
            } else
#endif
            {
                for (x = 0; x < AST_MAX_CONNECTS; x++) {
                    if (consoles[x].fd >= 0) {
                        continue;
                    }
                    if (socketpair(AF_LOCAL, SOCK_STREAM, 0, consoles[x].p)) {
                        ast_log(LOG_ERROR, "Unable to create pipe: %s\n", strerror(errno));
                        fdprint(s, "Server failed to create pipe\n");
                        close(s);
                        break;
                    }
                    ast_fd_set_flags(consoles[x].p[1], O_NONBLOCK);
                    consoles[x].mute = 1; /* Default is muted, we will un-mute if necessary */
                    /* Default uid and gid to -2, so then in cli.c/cli_has_permissions() we will be able
                       to know if the user didn't send the credentials. */
                    consoles[x].uid = -2;
                    consoles[x].gid = -2;
                    /* Server default of remote console verbosity level is OFF. */
                    consoles[x].option_verbose = 0;
                    consoles[x].fd = s;
                    if (ast_pthread_create_detached_background(&consoles[x].t, NULL, netconsole, &consoles[x])) {
                        consoles[x].fd = -1;
                        ast_log(LOG_ERROR, "Unable to spawn thread to handle connection: %s\n", strerror(errno));
                        close(consoles[x].p[0]);
                        close(consoles[x].p[1]);
                        fdprint(s, "Server failed to spawn thread\n");
                        close(s);
                    }
                    break;
                }
                if (x >= AST_MAX_CONNECTS) {
                    fdprint(s, "No more connections allowed\n");
                    ast_log(LOG_WARNING, "No more connections allowed\n");
                    close(s);
                } else if ((consoles[x].fd > -1) && (!ast_opt_hide_connect)) {
                    ast_verb(3, "Remote UNIX connection\n");
                }
            }
        }
    }
    return NULL;
}

References AF_LOCAL, ast_fd_set_flags, ast_log, AST_MAX_CONNECTS, ast_opt_hide_connect, ast_poll, ast_pthread_create_detached_background, ast_socket, ast_verb, consoles, errno, console::fd, fdprint(), console::gid, len(), LOG_ERROR, LOG_WARNING, console::mute, netconsole(), NULL, console::option_verbose, and console::uid.

Referenced by __allocate_taskprocessor(), __ast_taskpool_serializer_push_wait(), ast_makesocket(), ast_taskpool_serializer_group(), ast_taskpool_serializer_suspend(), ast_taskpool_serializer_unsuspend(), ast_taskprocessor_create_with_listener(), ast_taskprocessor_get(), ast_taskprocessor_listener_alloc(), ast_taskprocessor_listener_get_tps(), ast_taskprocessor_listener_get_user_data(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), ast_threadpool_create(), ast_threadpool_listener_alloc(), ast_threadpool_listener_get_user_data(), ast_threadpool_serializer_group(), default_listener_pvt_dtor(), default_listener_shutdown(), default_listener_start(), default_task_pushed(), default_tps_processing_function(), execute_tasks(), handle_cli_threadpool_push_efficiency(), handle_cli_threadpool_push_serializer_efficiency(), listener_check(), listener_shutdown(), serializer_shutdown(), serializer_shutdown(), serializer_task_pushed(), serializer_task_pushed(), taskpool_serializer_suspend_task(), taskprocessor_listener_dtor(), test_emptied(), test_emptied(), test_shutdown(), test_shutdown(), test_state_changed(), test_task_pushed(), test_task_pushed(), threadpool_tps_emptied(), threadpool_tps_shutdown(), threadpool_tps_task_pushed(), and wait_for_task_pushed().

main()

int main	(	int	argc,
		char *	argv[]
	)

Check for options

Todo:

Document these options

Note

Please keep the ordering here to alphabetical, capital letters first. This will make it easier in the future to select unused option flags for new features.

The q option is never used anywhere, only defined

Can ONLY be used with remote console

Definition at line 3620 of file asterisk.c.

{
    int c;
    int x;
    int isroot = 1, rundir_exists = 0;
    RAII_VAR(char *, runuser, NULL, ast_free);
    RAII_VAR(char *, rungroup, NULL, ast_free);
    RAII_VAR(char *, xarg, NULL, ast_free);
    struct rlimit l;
    static const char *getopt_settings = "BC:cde:FfG:ghIiL:M:mnpqRrs:TtU:VvWXx:";
 
    /* Try to explicitly set a UTF-8 locale. This is needed for
       libedit, as the LC_CTYPE category of the locale impacts the the
       multi-byte character functions provided by libc. If it fails,
       so be it. */
    if (!setlocale(LC_ALL, "C.UTF-8")) {
        ast_debug(1, "Tried to set locale to C.UTF-8 but it failed\n");
    }
 
    /* Remember original args for restart */
    if (argc > ARRAY_LEN(_argv) - 1) {
        fprintf(stderr, "Truncating argument size to %d\n", (int)ARRAY_LEN(_argv) - 1);
        argc = ARRAY_LEN(_argv) - 1;
    }
    for (x = 0; x < argc; x++)
        _argv[x] = argv[x];
    _argv[x] = NULL;
 
    if (geteuid() != 0)
        isroot = 0;
 
    /* if the progname is rasterisk consider it a remote console */
    if (argv[0] && (strstr(argv[0], "rasterisk")) != NULL) {
        ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK | AST_OPT_FLAG_REMOTE);
    }
    ast_mainpid = getpid();
 
    /* Process command-line options that affect asterisk.conf load. */
    while ((c = getopt(argc, argv, getopt_settings)) != -1) {
        switch (c) {
        case 'X':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES);
            break;
        case 'C':
            set_asterisk_conf_path(optarg);
            break;
        case 'd':
            option_debug++;
            break;
        case 'h':
            show_cli_help();
            exit(0);
        case 'R':
        case 'r':
        case 'x':
            /* ast_opt_remote is checked during config load.  This is only part of what
             * these options do, see the second loop for the rest of the actions. */
            ast_set_flag64(&ast_options, AST_OPT_FLAG_REMOTE);
            break;
        case 'V':
            show_version();
            exit(0);
        case 'v':
            option_verbose++;
            break;
        case '?':
            exit(1);
        }
    }
 
    /* Initialize env so it is available if #exec is used in asterisk.conf. */
    env_init();
 
    load_asterisk_conf();
 
    /* Update env to include any systemname that was set. */
    env_init();
 
    /*! \brief Check for options
     *
     * \todo Document these options
     */
    optind = 1;
    while ((c = getopt(argc, argv, getopt_settings)) != -1) {
        /*!\note Please keep the ordering here to alphabetical, capital letters
         * first.  This will make it easier in the future to select unused
         * option flags for new features. */
        switch (c) {
        case 'B': /* Force black background */
            ast_set_flag64(&ast_options, AST_OPT_FLAG_FORCE_BLACK_BACKGROUND);
            ast_clear_flag64(&ast_options, AST_OPT_FLAG_LIGHT_BACKGROUND);
            break;
        case 'X':
            /* The command-line -X option enables #exec for asterisk.conf only. */
            break;
        case 'C':
            /* already processed. */
            break;
        case 'c':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK | AST_OPT_FLAG_CONSOLE);
            break;
        case 'd':
            /* already processed. */
            break;
#if defined(HAVE_SYSINFO)
        case 'e':
            if ((sscanf(&optarg[1], "%30ld", &option_minmemfree) != 1) || (option_minmemfree < 0)) {
                option_minmemfree = 0;
            }
            break;
#endif
#if HAVE_WORKING_FORK
        case 'F':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_ALWAYS_FORK);
            break;
        case 'f':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK);
            break;
#endif
        case 'G':
            rungroup = ast_strdup(optarg);
            break;
        case 'g':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_DUMP_CORE);
            break;
        case 'h':
            /* already processed. */
            break;
        case 'I':
            fprintf(stderr,
                "NOTICE: The -I option is no longer needed.\n"
                "  It will always be enabled if you have a timing module loaded.\n");
            break;
        case 'i':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_INIT_KEYS);
            break;
        case 'L':
            if ((sscanf(optarg, "%30lf", &ast_option_maxload) != 1) || (ast_option_maxload < 0.0)) {
                ast_option_maxload = 0.0;
            }
            break;
        case 'M':
            if ((sscanf(optarg, "%30d", &ast_option_maxcalls) != 1) || (ast_option_maxcalls < 0)) {
                ast_option_maxcalls = 0;
            }
            break;
        case 'm':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_MUTE);
            break;
        case 'n':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_COLOR);
            break;
        case 'p':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY);
            break;
        case 'q':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_QUIET);
            break;
        case 'R':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK | AST_OPT_FLAG_REMOTE | AST_OPT_FLAG_RECONNECT);
            break;
        case 'r':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK | AST_OPT_FLAG_REMOTE);
            break;
        case 's':
            if (ast_opt_remote) {
                set_socket_path(optarg);
            }
            break;
        case 'T':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_TIMESTAMP);
            break;
        case 't':
            ast_set_flag64(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES);
            break;
        case 'U':
            runuser = ast_strdup(optarg);
            break;
        case 'V':
        case 'v':
            /* already processed. */
            break;
        case 'W': /* White background */
            ast_set_flag64(&ast_options, AST_OPT_FLAG_LIGHT_BACKGROUND);
            ast_clear_flag64(&ast_options, AST_OPT_FLAG_FORCE_BLACK_BACKGROUND);
            break;
        case 'x':
            /* -r is implied by -x so set the flags -r sets as well. */
            ast_set_flag64(&ast_options, AST_OPT_FLAG_NO_FORK | AST_OPT_FLAG_REMOTE);
 
            ast_set_flag64(&ast_options, AST_OPT_FLAG_EXEC | AST_OPT_FLAG_NO_COLOR);
            xarg = ast_strdup(optarg);
            break;
        case '?':
            /* already processed. */
            break;
        }
    }
 
    if (ast_opt_remote) {
        int didwarn = 0;
        optind = 1;
 
        /* Not all options can be used with remote console. Warn if they're used. */
        while ((c = getopt(argc, argv, getopt_settings)) != -1) {
            switch (c) {
            /* okay to run with remote console */
            case 'B': /* force black background */
            case 'C': /* set config path */
            case 'd': /* debug */
            case 'h': /* help */
            case 'I': /* obsolete timing option: warning already thrown if used */
            case 'L': /* max load */
            case 'M': /* max calls */
            case 'm': /* mute */
            /*! \note The q option is never used anywhere, only defined */
            case 'q': /* quiet */
            case 'R': /* reconnect */
            case 'r': /* remote */
            /*! \note Can ONLY be used with remote console */
            case 's': /* set socket path */
            case 'T': /* timestamp */
            case 'V': /* version */
            case 'v': /* verbose */
            case 'W': /* white background */
            case 'x': /* remote execute */
            case '?': /* ? */
                break;
            /* can only be run when Asterisk is starting */
            case 'X': /* enables #exec for asterisk.conf only. */
            case 'c': /* foreground console */
            case 'e': /* minimum memory free */
            case 'F': /* always fork */
            case 'f': /* no fork */
            case 'G': /* run group */
            case 'g': /* dump core */
            case 'i': /* init keys */
            case 'n': /* no color */
            case 'p': /* high priority */
            case 't': /* cache record files */
            case 'U': /* run user */
                fprintf(stderr, "'%c' option is not compatible with remote console mode and has no effect.\n", c);
                didwarn = 1;
            }
        }
        if (didwarn) {
            fprintf(stderr, "\n"); /* if any warnings print out, make them stand out */
        }
    }
 
    /* For remote connections, change the name of the remote connection.
     * We do this for the benefit of init scripts (which need to know if/when
     * the main asterisk process has died yet). */
    if (ast_opt_remote) {
        strcpy(argv[0], "rasterisk");
        for (x = 1; x < argc; x++) {
            argv[x] = argv[0] + 10;
        }
    }
 
    if (ast_opt_always_fork && (ast_opt_remote || ast_opt_console)) {
        fprintf(stderr, "'alwaysfork' is not compatible with console or remote console mode; ignored\n");
        ast_clear_flag64(&ast_options, AST_OPT_FLAG_ALWAYS_FORK);
    }
 
    if (ast_opt_dump_core) {
        memset(&l, 0, sizeof(l));
        l.rlim_cur = RLIM_INFINITY;
        l.rlim_max = RLIM_INFINITY;
        if (setrlimit(RLIMIT_CORE, &l)) {
            fprintf(stderr, "Unable to disable core size resource limit: %s\n", strerror(errno));
        }
    }
 
    if (getrlimit(RLIMIT_NOFILE, &l)) {
        fprintf(stderr, "Unable to check file descriptor limit: %s\n", strerror(errno));
    }
 
#if !defined(CONFIGURE_RAN_AS_ROOT)
    /* Check if select(2) will run with more file descriptors */
    do {
        int fd, fd2;
        ast_fdset readers;
        struct timeval tv = { 0, };
 
        if (l.rlim_cur <= FD_SETSIZE) {
            /* The limit of select()able FDs is irrelevant, because we'll never
             * open one that high. */
            break;
        }
 
        if (!(fd = open("/dev/null", O_RDONLY))) {
            fprintf(stderr, "Cannot open a file descriptor at boot? %s\n", strerror(errno));
            break; /* XXX Should we exit() here? XXX */
        }
 
        fd2 = ((l.rlim_cur > sizeof(readers) * 8) ? sizeof(readers) * 8 : l.rlim_cur) - 1;
        if (dup2(fd, fd2) < 0) {
            fprintf(stderr, "Cannot open maximum file descriptor %d at boot? %s\n", fd2, strerror(errno));
            close(fd);
            break;
        }
 
        FD_ZERO(&readers);
        FD_SET(fd2, &readers);
        if (ast_select(fd2 + 1, &readers, NULL, NULL, &tv) < 0) {
            fprintf(stderr, "Maximum select()able file descriptor is %d\n", FD_SETSIZE);
        }
        ast_FD_SETSIZE = l.rlim_cur > ast_FDMAX ? ast_FDMAX : l.rlim_cur;
        close(fd);
        close(fd2);
    } while (0);
#elif defined(HAVE_VARIABLE_FDSET)
    ast_FD_SETSIZE = l.rlim_cur > ast_FDMAX ? ast_FDMAX : l.rlim_cur;
#endif /* !defined(CONFIGURE_RAN_AS_ROOT) */
 
    if ((!rungroup) && !ast_strlen_zero(ast_config_AST_RUN_GROUP))
        rungroup = ast_strdup(ast_config_AST_RUN_GROUP);
    if ((!runuser) && !ast_strlen_zero(ast_config_AST_RUN_USER))
        runuser = ast_strdup(ast_config_AST_RUN_USER);
 
    /* Must install this signal handler up here to ensure that if the canary
     * fails to execute that it doesn't kill the Asterisk process.
     */
    sigaction(SIGCHLD, &child_handler, NULL);
 
    /* It's common on some platforms to clear /var/run at boot.  Create the
     * socket file directory before we drop privileges. */
    if (mkdir(ast_config_AST_RUN_DIR, 0755)) {
        if (errno == EEXIST) {
            rundir_exists = 1;
        } else {
            fprintf(stderr, "Unable to create socket file directory.  Remote consoles will not be able to connect! (%s)\n", strerror(x));
        }
    }
 
#ifndef __CYGWIN__
 
    if (isroot) {
        ast_set_priority(ast_opt_high_priority);
    }
 
    if (isroot && rungroup) {
        struct group *gr;
        gr = getgrnam(rungroup);
        if (!gr) {
            fprintf(stderr, "No such group '%s'!\n", rungroup);
            exit(1);
        }
        if (!rundir_exists && chown(ast_config_AST_RUN_DIR, -1, gr->gr_gid)) {
            fprintf(stderr, "Unable to chgrp run directory to %d (%s)\n", (int) gr->gr_gid, rungroup);
        }
        if (setgid(gr->gr_gid)) {
            fprintf(stderr, "Unable to setgid to %d (%s)\n", (int)gr->gr_gid, rungroup);
            exit(1);
        }
        if (setgroups(0, NULL)) {
            fprintf(stderr, "Unable to drop unneeded groups\n");
            exit(1);
        }
    }
 
    if (runuser && !ast_opt_remote) {
#ifdef HAVE_CAP
        int has_cap = 1;
#endif /* HAVE_CAP */
        struct passwd *pw;
        pw = getpwnam(runuser);
        if (!pw) {
            fprintf(stderr, "No such user '%s'!\n", runuser);
            exit(1);
        }
        if (chown(ast_config_AST_RUN_DIR, pw->pw_uid, -1)) {
            fprintf(stderr, "Unable to chown run directory to %d (%s)\n", (int) pw->pw_uid, runuser);
        }
#ifdef HAVE_CAP
        if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0)) {
            ast_log(LOG_WARNING, "Unable to keep capabilities.\n");
            has_cap = 0;
        }
#endif /* HAVE_CAP */
        if (!isroot && pw->pw_uid != geteuid()) {
            fprintf(stderr, "Asterisk started as nonroot, but runuser '%s' requested.\n", runuser);
            exit(1);
        }
        if (!rungroup) {
            if (setgid(pw->pw_gid)) {
                fprintf(stderr, "Unable to setgid to %d!\n", (int)pw->pw_gid);
                exit(1);
            }
            if (isroot && initgroups(pw->pw_name, pw->pw_gid)) {
                fprintf(stderr, "Unable to init groups for '%s'\n", runuser);
                exit(1);
            }
        }
        if (setuid(pw->pw_uid)) {
            fprintf(stderr, "Unable to setuid to %d (%s)\n", (int)pw->pw_uid, runuser);
            exit(1);
        }
#ifdef HAVE_CAP
        if (has_cap) {
            cap_t cap;
 
            cap = cap_from_text("cap_net_admin=eip");
 
            if (cap_set_proc(cap)) {
                fprintf(stderr, "Unable to install capabilities.\n");
            }
            if (cap_free(cap)) {
                fprintf(stderr, "Unable to drop capabilities.\n");
            }
        }
#endif /* HAVE_CAP */
    }
 
#endif /* __CYGWIN__ */
 
#ifdef linux
    if (geteuid() && ast_opt_dump_core) {
        if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) < 0) {
            fprintf(stderr, "Unable to set the process for core dumps after changing to a non-root user. %s\n", strerror(errno));
        }
    }
#endif
 
    {
#if defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS)
        char dir[PATH_MAX];
        if (!getcwd(dir, sizeof(dir)) || eaccess(dir, R_OK | X_OK | F_OK)) {
            fprintf(stderr, "Unable to access the running directory (%s).  Changing to '/' for compatibility.\n", strerror(errno));
            /* If we cannot access the CWD, then we couldn't dump core anyway,
             * so chdir("/") won't break anything. */
            if (chdir("/")) {
                /* chdir(/) should never fail, so this ends up being a no-op */
                fprintf(stderr, "chdir(\"/\") failed?!! %s\n", strerror(errno));
            }
        } else
#endif /* defined(HAVE_EACCESS) || defined(HAVE_EUIDACCESS) */
        if (!ast_opt_no_fork && !ast_opt_dump_core) {
            /* Backgrounding, but no cores, so chdir won't break anything. */
            if (chdir("/")) {
                fprintf(stderr, "Unable to chdir(\"/\") ?!! %s\n", strerror(errno));
            }
        }
    }
 
    /* Initial value of the maximum active system verbosity level. */
    ast_verb_sys_level = option_verbose;
 
    if (ast_sd_get_fd_un(SOCK_STREAM, ast_config_AST_SOCKET) > 0) {
        ast_socket_is_sd = 1;
    }
 
    /* DO NOT perform check for existing daemon if systemd has CLI socket activation */
    if (!ast_socket_is_sd && ast_tryconnect()) {
        /* One is already running */
        if (ast_opt_remote) {
            multi_thread_safe = 1;
            if (ast_opt_exec) {
                ast_remotecontrol(xarg);
                quit_handler(0, SHUTDOWN_FAST, 0);
                exit(0);
            }
            ast_term_init();
            printf("%s", term_end());
            fflush(stdout);
 
            print_intro_message(runuser, rungroup);
            printf("%s", term_quit());
            ast_remotecontrol(NULL);
            quit_handler(0, SHUTDOWN_FAST, 0);
            exit(0);
        } else {
            fprintf(stderr, "Asterisk already running on %s.  Use 'asterisk -r' to connect.\n", ast_config_AST_SOCKET);
            printf("%s", term_quit());
            exit(1);
        }
    } else if (ast_opt_remote || ast_opt_exec) {
        fprintf(stderr, "Unable to connect to remote asterisk (does %s exist?)\n", ast_config_AST_SOCKET);
        printf("%s", term_quit());
        exit(1);
    }
 
#ifdef HAVE_CAP
    child_cap = cap_from_text("cap_net_admin-eip");
#endif
    /* Not a remote console? Start the daemon. */
    asterisk_daemon(isroot, runuser, rungroup);
#ifdef HAS_CAP
    cap_free(child_cap);
#endif
    return 0;
}

References _argv, ARRAY_LEN, ast_clear_flag64, ast_config_AST_RUN_DIR, ast_config_AST_RUN_GROUP, ast_config_AST_RUN_USER, ast_config_AST_SOCKET, ast_debug, ast_FD_SETSIZE, ast_FDMAX, ast_free, ast_log, ast_mainpid, ast_opt_always_fork, ast_opt_console, ast_opt_dump_core, ast_opt_exec, AST_OPT_FLAG_ALWAYS_FORK, AST_OPT_FLAG_CACHE_RECORD_FILES, AST_OPT_FLAG_CONSOLE, AST_OPT_FLAG_DUMP_CORE, AST_OPT_FLAG_EXEC, AST_OPT_FLAG_EXEC_INCLUDES, AST_OPT_FLAG_FORCE_BLACK_BACKGROUND, AST_OPT_FLAG_HIGH_PRIORITY, AST_OPT_FLAG_INIT_KEYS, AST_OPT_FLAG_LIGHT_BACKGROUND, AST_OPT_FLAG_MUTE, AST_OPT_FLAG_NO_COLOR, AST_OPT_FLAG_NO_FORK, AST_OPT_FLAG_QUIET, AST_OPT_FLAG_RECONNECT, AST_OPT_FLAG_REMOTE, AST_OPT_FLAG_TIMESTAMP, ast_opt_high_priority, ast_opt_no_fork, ast_opt_remote, ast_option_maxcalls, ast_option_maxload, ast_options, ast_remotecontrol(), ast_sd_get_fd_un(), ast_select(), ast_set_flag64, ast_set_priority(), ast_socket_is_sd, ast_strdup, ast_strlen_zero(), ast_term_init(), ast_tryconnect(), ast_verb_sys_level, asterisk_daemon(), c, child_handler, env_init(), errno, F_OK, FD_SET, FD_ZERO, load_asterisk_conf(), LOG_WARNING, multi_thread_safe, NULL, option_debug, option_minmemfree, option_verbose, PATH_MAX, print_intro_message(), quit_handler(), R_OK, RAII_VAR, set_asterisk_conf_path(), set_socket_path(), show_cli_help(), show_version(), SHUTDOWN_FAST, term_end(), and term_quit().

main_atexit()

static void main_atexit ( void  )

static

Definition at line 3615 of file asterisk.c.

{
    ast_cli_unregister_multiple(cli_asterisk, ARRAY_LEN(cli_asterisk));
}

References ARRAY_LEN, ast_cli_unregister_multiple(), and cli_asterisk.

Referenced by asterisk_daemon().

monitor_sig_flags()

static void * monitor_sig_flags ( void *  unused )

static

Definition at line 3484 of file asterisk.c.

{
    for (;;) {
        struct pollfd p = { sig_alert_pipe[0], POLLIN, 0 };
 
        ast_poll(&p, 1, -1);
        if (sig_flags.need_reload) {
            sig_flags.need_reload = 0;
            ast_module_reload(NULL);
        }
        if (sig_flags.need_quit) {
            sig_flags.need_quit = 0;
            if ((consolethread != AST_PTHREADT_NULL) && (consolethread != pthread_self())) {
                sig_flags.need_quit_handler = 1;
                pthread_kill(consolethread, SIGURG);
            } else {
                quit_handler(0, SHUTDOWN_NORMAL, 0);
            }
        }
        ast_alertpipe_read(sig_alert_pipe);
    }
 
    return NULL;
}

References ast_alertpipe_read(), ast_module_reload(), ast_poll, AST_PTHREADT_NULL, consolethread, NULL, quit_handler(), SHUTDOWN_NORMAL, sig_alert_pipe, and sig_flags.

Referenced by asterisk_daemon().

netconsole()

static void * netconsole ( void *  vconsole )

static

Definition at line 1440 of file asterisk.c.

{
    struct console *con = vconsole;
    char hostname[MAXHOSTNAMELEN] = "";
    char inbuf[512];
    char outbuf[512];
    const char * const end_buf = inbuf + sizeof(inbuf);
    char *start_read = inbuf;
    int res;
    struct pollfd fds[2];
 
    if (gethostname(hostname, sizeof(hostname)-1))
        ast_copy_string(hostname, "<Unknown>", sizeof(hostname));
    snprintf(outbuf, sizeof(outbuf), "%s/%ld/%s\n", hostname, (long)ast_mainpid, ast_get_version());
    fdprint(con->fd, outbuf);
    ast_verb_console_register(&con->option_verbose);
    for (;;) {
        fds[0].fd = con->fd;
        fds[0].events = POLLIN;
        fds[0].revents = 0;
        fds[1].fd = con->p[0];
        fds[1].events = POLLIN;
        fds[1].revents = 0;
 
        res = ast_poll(fds, 2, -1);
        if (res < 0) {
            if (errno != EINTR)
                ast_log(LOG_WARNING, "poll returned < 0: %s\n", strerror(errno));
            continue;
        }
        if (fds[0].revents) {
            int cmds_read, bytes_read;
            if ((bytes_read = read_credentials(con->fd, start_read, end_buf - start_read, con)) < 1) {
                break;
            }
            /* XXX This will only work if it is the first command, and I'm not sure fixing it is worth the effort. */
            if (strncmp(inbuf, "cli quit after ", 15) == 0) {
                ast_cli_command_multiple_full(con->uid, con->gid, con->fd, bytes_read - 15, inbuf + 15);
                break;
            }
            /* ast_cli_command_multiple_full will only process individual commands terminated by a
             * NULL and not trailing partial commands. */
            if (!(cmds_read = ast_cli_command_multiple_full(con->uid, con->gid, con->fd, bytes_read + start_read - inbuf, inbuf))) {
                /* No commands were read. We either have a short read on the first command
                 * with space left, or a command that is too long */
                if (start_read + bytes_read < end_buf) {
                    start_read += bytes_read;
                } else {
                    ast_log(LOG_ERROR, "Command too long! Skipping\n");
                    start_read = inbuf;
                }
                continue;
            }
            if (start_read[bytes_read - 1] == '\0') {
                /* The read ended on a command boundary, start reading again at the head of inbuf */
                start_read = inbuf;
                continue;
            }
            /* If we get this far, we have left over characters that have not been processed.
             * Advance to the character after the last command read by ast_cli_command_multiple_full.
             * We are guaranteed to have at least cmds_read NULLs */
            while (cmds_read-- && (start_read = strchr(start_read, '\0'))) {
                start_read++;
            }
            memmove(inbuf, start_read, end_buf - start_read);
            start_read = end_buf - start_read + inbuf;
        }
        if (fds[1].revents) {
            res = read_credentials(con->p[0], outbuf, sizeof(outbuf), con);
            if (res < 1) {
                ast_log(LOG_ERROR, "read returned %d\n", res);
                break;
            }
            res = write(con->fd, outbuf, res);
            if (res < 1)
                break;
        }
    }
    ast_verb_console_unregister();
    if (!ast_opt_hide_connect) {
        ast_verb(3, "Remote UNIX connection disconnected\n");
    }
    close(con->fd);
    close(con->p[0]);
    close(con->p[1]);
    con->fd = -1;
 
    return NULL;
}

References ast_cli_command_multiple_full(), ast_copy_string(), ast_get_version(), ast_log, ast_mainpid, ast_opt_hide_connect, ast_poll, ast_verb, ast_verb_console_register(), ast_verb_console_unregister(), errno, console::fd, fdprint(), console::gid, hostname, inbuf(), LOG_ERROR, LOG_WARNING, MAXHOSTNAMELEN, NULL, console::option_verbose, console::p, read_credentials(), and console::uid.

Referenced by listener().

print_file()

static int print_file ( int  fd, char *  desc, const char *  filename  )

static

Print the contents of a file.

Definition at line 458 of file asterisk.c.

{
    FILE *f;
    char c;
    if (!(f = fopen(filename, "r"))) {
        return -1;
    }
    ast_cli(fd, "%s", desc);
    while ((c = fgetc(f)) != EOF) {
        ast_cli(fd, "%c", c);
    }
    fclose(f);
    /* no need for trailing new line, the file already has one */
    return 0;
}

References ast_cli(), c, and desc.

Referenced by handle_show_settings().

print_intro_message()

static void print_intro_message ( const char *  runuser, const char *  rungroup  )

static

Definition at line 3602 of file asterisk.c.

{
    if (ast_opt_console || option_verbose || (ast_opt_remote && !ast_opt_exec)) {
        WELCOME_MESSAGE;
        if (runuser) {
            ast_verbose("Running as user '%s'\n", runuser);
        }
        if (rungroup) {
            ast_verbose("Running under group '%s'\n", rungroup);
        }
    }
}

References ast_opt_console, ast_opt_exec, ast_opt_remote, ast_verbose, option_verbose, and WELCOME_MESSAGE.

Referenced by asterisk_daemon(), and main().

process_histfile()

static void process_histfile ( int(*)(const char *filename)  readwrite )

static

Definition at line 3220 of file asterisk.c.

{
    struct passwd *pw = getpwuid(geteuid());
    int ret = 0;
    char *name = NULL;
 
    if (!pw || ast_strlen_zero(pw->pw_dir)) {
        ast_log(LOG_ERROR, "Unable to determine home directory.  History read/write disabled.\n");
        return;
    }
 
    ret = ast_asprintf(&name, "%s/.asterisk_history", pw->pw_dir);
    if (ret <= 0) {
        ast_log(LOG_ERROR, "Unable to create history file name.  History read/write disabled.\n");
        return;
    }
 
    ret = readwrite(name);
    if (ret < 0) {
        ast_log(LOG_ERROR, "Unable to read or write history file '%s'\n", name);
    }
 
    ast_free(name);
 
    return;
}

References ast_asprintf, ast_free, ast_log, ast_strlen_zero(), LOG_ERROR, name, and NULL.

Referenced by ast_el_read_default_histfile(), and ast_el_write_default_histfile().

publish_fully_booted()

static void publish_fully_booted ( void  )

static

Definition at line 989 of file asterisk.c.

{
    struct ast_json *json_object;
    int uptime = 0;
    int lastreloaded = 0;
    struct timeval tmp;
    struct timeval curtime = ast_tvnow();
 
    if (ast_startuptime.tv_sec) {
        tmp = ast_tvsub(curtime, ast_startuptime);
        uptime = (int) tmp.tv_sec;
    }
 
    if (ast_lastreloadtime.tv_sec) {
        tmp = ast_tvsub(curtime, ast_lastreloadtime);
        lastreloaded = (int) tmp.tv_sec;
    }
 
    json_object = ast_json_pack("{s: s, s: i, s: i}",
            "Status", "Fully Booted",
            "Uptime", uptime,
            "LastReload", lastreloaded);
    ast_manager_publish_event("FullyBooted", EVENT_FLAG_SYSTEM, json_object);
    ast_json_unref(json_object);
}

References ast_json_pack(), ast_json_unref(), ast_lastreloadtime, ast_manager_publish_event(), ast_startuptime, ast_tvnow(), ast_tvsub(), and EVENT_FLAG_SYSTEM.

Referenced by asterisk_daemon().

quit_handler()

static void quit_handler ( int  num, shutdown_nice_t  niceness, int  restart  )

static

Definition at line 1923 of file asterisk.c.

{
    if (can_safely_quit(niceness, restart)) {
        really_quit(num, niceness, restart);
        /* No one gets here. */
    }
    /* It wasn't our time. */
}

References can_safely_quit(), and really_quit().

Referenced by ast_el_read_char(), asterisk_daemon(), handle_restart_gracefully(), handle_restart_now(), handle_restart_when_convenient(), handle_stop_gracefully(), handle_stop_now(), handle_stop_when_convenient(), main(), monitor_sig_flags(), and remoteconsolehandler().

rdtsc()

static __inline uint64_t rdtsc ( void  )

static

Definition at line 878 of file asterisk.c.

{
    return 0;
}

Referenced by ast_mark().

read_credentials()

static int read_credentials ( int  fd, char *  buffer, size_t  size, struct console *  con  )

static

read() function supporting the reception of user credentials.

Parameters

fd	Socket file descriptor.
buffer	Receive buffer.
size	'buffer' size.
con	Console structure to set received credentials

Return values

-1	on error
the	number of bytes received on success.

Definition at line 1390 of file asterisk.c.

{
#if defined(SO_PEERCRED)
#ifdef HAVE_STRUCT_SOCKPEERCRED_UID
#define HAVE_STRUCT_UCRED_UID
    struct sockpeercred cred;
#else
    struct ucred cred;
#endif
    socklen_t len = sizeof(cred);
#endif
#if defined(HAVE_GETPEEREID)
    uid_t uid;
    gid_t gid;
#else
    int uid, gid;
#endif
    int result;
 
    result = read(fd, buffer, size);
    if (result < 0) {
        return result;
    }
 
#if defined(SO_PEERCRED) && (defined(HAVE_STRUCT_UCRED_UID) || defined(HAVE_STRUCT_UCRED_CR_UID))
    if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cred, &len)) {
        return result;
    }
#if defined(HAVE_STRUCT_UCRED_UID)
    uid = cred.uid;
    gid = cred.gid;
#else /* defined(HAVE_STRUCT_UCRED_CR_UID) */
    uid = cred.cr_uid;
    gid = cred.cr_gid;
#endif /* defined(HAVE_STRUCT_UCRED_UID) */
 
#elif defined(HAVE_GETPEEREID)
    if (getpeereid(fd, &uid, &gid)) {
        return result;
    }
#else
    return result;
#endif
    con->uid = uid;
    con->gid = gid;
 
    return result;
}

References console::gid, len(), result, and console::uid.

Referenced by netconsole().

read_pjproject_startup_options()

static void read_pjproject_startup_options ( void  )

static

Definition at line 3450 of file asterisk.c.

{
    struct ast_config *cfg;
    struct ast_variable *v;
    struct ast_flags config_flags = { CONFIG_FLAG_NOCACHE | CONFIG_FLAG_NOREALTIME };
 
    ast_option_pjproject_log_level = DEFAULT_PJ_LOG_MAX_LEVEL;
    ast_option_pjproject_cache_pools = DEFAULT_PJPROJECT_CACHE_POOLS;
 
    cfg = ast_config_load2("pjproject.conf", "" /* core, can't reload */, config_flags);
    if (!cfg
        || cfg == CONFIG_STATUS_FILEUNCHANGED
        || cfg == CONFIG_STATUS_FILEINVALID) {
        /* We'll have to use defaults */
        return;
    }
 
    for (v = ast_variable_browse(cfg, "startup"); v; v = v->next) {
        if (!strcasecmp(v->name, "log_level")) {
            if (sscanf(v->value, "%30d", &ast_option_pjproject_log_level) != 1) {
                ast_option_pjproject_log_level = DEFAULT_PJ_LOG_MAX_LEVEL;
            } else if (ast_option_pjproject_log_level < 0) {
                ast_option_pjproject_log_level = 0;
            } else if (MAX_PJ_LOG_MAX_LEVEL < ast_option_pjproject_log_level) {
                ast_option_pjproject_log_level = MAX_PJ_LOG_MAX_LEVEL;
            }
        } else if (!strcasecmp(v->name, "cache_pools")) {
            ast_option_pjproject_cache_pools = !ast_false(v->value);
        }
    }
 
    ast_config_destroy(cfg);
}

References ast_config_destroy(), ast_config_load2(), ast_false(), ast_option_pjproject_cache_pools, ast_option_pjproject_log_level, ast_variable_browse(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_NOREALTIME, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_PJ_LOG_MAX_LEVEL, DEFAULT_PJPROJECT_CACHE_POOLS, MAX_PJ_LOG_MAX_LEVEL, ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by asterisk_daemon().

really_quit()

static void really_quit ( int  num, shutdown_nice_t  niceness, int  restart  )

static

Called when exiting is certain.

Definition at line 2058 of file asterisk.c.

{
    int active_channels;
    struct ast_json *json_object = NULL;
    int run_cleanups = niceness >= SHUTDOWN_NICE;
 
    if (run_cleanups && modules_shutdown()) {
        ast_verb(0, "Some modules could not be unloaded, switching to fast shutdown\n");
        run_cleanups = 0;
    }
 
    if (!restart && !ast_opt_remote) {
        ast_sd_notify("STOPPING=1");
    }
    if (ast_opt_console || (ast_opt_remote && !ast_opt_exec)) {
        ast_el_write_default_histfile();
        if (consolethread == AST_PTHREADT_NULL || consolethread == pthread_self()) {
            /* Only end if we are the consolethread, otherwise there's a race with that thread. */
            if (el != NULL) {
                el_end(el);
            }
            if (el_hist != NULL) {
                history_end(el_hist);
            }
        } else if (!restart) {
            sig_flags.need_el_end = 1;
            pthread_kill(consolethread, SIGURG);
        }
    }
    active_channels = ast_active_channels();
    /* Don't publish messages if we're a remote console - we won't have all of the Stasis
     * topics or message types
     */
    if (!ast_opt_remote) {
        json_object = ast_json_pack("{s: s, s: s}",
                "Shutdown", active_channels ? "Uncleanly" : "Cleanly",
                "Restart", restart ? "True" : "False");
        ast_manager_publish_event("Shutdown", EVENT_FLAG_SYSTEM, json_object);
        ast_json_unref(json_object);
        json_object = NULL;
    }
    ast_verb(0, "Asterisk %s ending (%d).\n",
        active_channels ? "uncleanly" : "cleanly", num);
 
    ast_verb(0, "Executing last minute cleanups\n");
    ast_run_atexits(run_cleanups);
 
    ast_debug(1, "Asterisk ending (%d).\n", num);
    if (ast_socket > -1) {
        pthread_cancel(lthread);
        close(ast_socket);
        ast_socket = -1;
        if (!ast_socket_is_sd) {
            unlink(ast_config_AST_SOCKET);
        }
        pthread_kill(lthread, SIGURG);
        pthread_join(lthread, NULL);
    }
    if (ast_consock > -1)
        close(ast_consock);
    if (!ast_opt_remote)
        unlink(ast_config_AST_PID);
    ast_alertpipe_close(sig_alert_pipe);
    printf("%s", term_quit());
    if (restart) {
        int i;
        ast_verb(0, "Preparing for Asterisk restart...\n");
        /* Mark all FD's for closing on exec */
        for (i = 3; i < 32768; i++) {
            fcntl(i, F_SETFD, FD_CLOEXEC);
        }
        ast_verb(0, "Asterisk is now restarting...\n");
        restartnow = 1;
 
        /* close logger */
        close_logger();
        clean_time_zones();
 
        /* If there is a consolethread running send it a SIGHUP
           so it can execvp, otherwise we can do it ourselves */
        if ((consolethread != AST_PTHREADT_NULL) && (consolethread != pthread_self())) {
            pthread_kill(consolethread, SIGHUP);
            /* Give the signal handler some time to complete */
            sleep(2);
        } else
            execvp(_argv[0], _argv);
 
    } else {
        /* close logger */
        close_logger();
        clean_time_zones();
    }
 
    exit(0);
}

References _argv, active_channels(), ast_active_channels(), ast_alertpipe_close(), ast_config_AST_PID, ast_config_AST_SOCKET, ast_consock, ast_debug, ast_el_write_default_histfile(), ast_json_pack(), ast_json_unref(), ast_manager_publish_event(), ast_opt_console, ast_opt_exec, ast_opt_remote, AST_PTHREADT_NULL, ast_run_atexits(), ast_sd_notify(), ast_socket, ast_socket_is_sd, ast_verb, clean_time_zones(), close_logger(), consolethread, el, el_hist, EVENT_FLAG_SYSTEM, lthread, modules_shutdown(), NULL, restartnow, SHUTDOWN_NICE, sig_alert_pipe, sig_flags, and term_quit().

Referenced by quit_handler().

register_atexit()

static int register_atexit ( void(*)(void)  func, int  is_cleanup  )

static

Definition at line 1043 of file asterisk.c.

{
    struct ast_atexit *ae;
 
    ae = ast_calloc(1, sizeof(*ae));
    if (!ae) {
        return -1;
    }
    ae->func = func;
    ae->is_cleanup = is_cleanup;
 
    AST_LIST_LOCK(&atexits);
    __ast_unregister_atexit(func);
    AST_LIST_INSERT_HEAD(&atexits, ae, list);
    AST_LIST_UNLOCK(&atexits);
 
    return 0;
}

References __ast_unregister_atexit(), ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_atexit::func, ast_atexit::is_cleanup, and ast_atexit::list.

Referenced by ast_register_atexit(), and ast_register_cleanup().

remoteconsolehandler()

static int remoteconsolehandler ( const char *  s )

static

Definition at line 2328 of file asterisk.c.

{
    int ret = 0;
 
    /* Called when readline data is available */
    if (!ast_all_zeros(s))
        ast_el_add_history(s);
 
    while (isspace(*s)) {
        s++;
    }
 
    /* The real handler for bang */
    if (s[0] == '!') {
        if (ast_option_disable_remote_console_shell) {
            printf("Shell access is disabled on remote consoles\n");
            return 1;
        }
        if (s[1])
            ast_safe_system(s+1);
        else
            ast_safe_system(getenv("SHELL") ? getenv("SHELL") : "/bin/sh");
        ret = 1;
    } else if ((strncasecmp(s, "quit", 4) == 0 || strncasecmp(s, "exit", 4) == 0) &&
        (s[4] == '\0' || isspace(s[4]))) {
        quit_handler(0, SHUTDOWN_FAST, 0);
        ret = 1;
    }
 
    return ret;
}

References ast_all_zeros(), ast_el_add_history(), ast_option_disable_remote_console_shell, ast_safe_system(), quit_handler(), and SHUTDOWN_FAST.

Referenced by ast_remotecontrol().

run_startup_commands()

static void run_startup_commands ( enum startup_commands_phase  phase )

static

Definition at line 3560 of file asterisk.c.

{
    int fd;
    struct ast_config *cfg;
    struct ast_flags cfg_flags = { 0 };
    struct ast_variable *v;
 
    if (!(cfg = ast_config_load2("cli.conf", "" /* core, can't reload */, cfg_flags)))
        return;
    if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
        return;
    }
 
    fd = open("/dev/null", O_RDWR);
    if (fd < 0) {
        ast_config_destroy(cfg);
        return;
    }
 
    for (v = ast_variable_browse(cfg, "startup_commands"); v; v = v->next) {
        char *value = ast_str_to_lower(ast_strdupa(v->value));
        if (ast_in_delimited_string(value, startup_commands_phase_str[phase], ',')) {
            ast_cli_command(fd, v->name);
        }
    }
 
    close(fd);
    ast_config_destroy(cfg);
}

References ast_cli_command, ast_config_destroy(), ast_config_load2(), ast_in_delimited_string(), ast_str_to_lower(), ast_strdupa, ast_variable_browse(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, ast_variable::name, ast_variable::next, startup_commands_phase_str, ast_variable::value, and value.

Referenced by asterisk_daemon().

safe_exec_prep()

static pid_t safe_exec_prep ( int  dualfork )

static

fork and perform other preparations for spawning applications

Definition at line 1147 of file asterisk.c.

{
    pid_t pid;
 
#if defined(HAVE_WORKING_FORK) || defined(HAVE_WORKING_VFORK)
    ast_replace_sigchld();
 
#ifdef HAVE_WORKING_FORK
    pid = fork();
#else
    pid = vfork();
#endif
 
    if (pid == 0) {
#ifdef HAVE_CAP
        cap_set_proc(child_cap);
#endif
#ifdef HAVE_WORKING_FORK
        if (ast_opt_high_priority) {
            ast_set_priority(0);
        }
        /* Close file descriptors and launch system command */
        ast_close_fds_above_n(STDERR_FILENO);
#endif
        if (dualfork) {
#ifdef HAVE_WORKING_FORK
            pid = fork();
#else
            pid = vfork();
#endif
            if (pid < 0) {
                /* Second fork failed. */
                /* No logger available. */
                _exit(1);
            }
 
            if (pid > 0) {
                /* This is the first fork, exit so the reaper finishes right away. */
                _exit(0);
            }
 
            /* This is the second fork.  The first fork will exit immediately so
             * Asterisk doesn't have to wait for completion.
             * ast_safe_system("cmd &") would run in the background, but the '&'
             * cannot be added with ast_safe_execvp, so we have to double fork.
             */
        }
    }
 
    if (pid < 0) {
        ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
    }
#else
    ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(ENOTSUP));
    pid = -1;
#endif
 
    return pid;
}

References ast_close_fds_above_n(), ast_log, ast_opt_high_priority, ast_replace_sigchld(), ast_set_priority(), errno, and LOG_WARNING.

Referenced by ast_safe_execvp(), and ast_safe_system().

safe_exec_wait()

static int safe_exec_wait ( pid_t  pid )

static

wait for spawned application to complete and unreplace sigchld

Definition at line 1208 of file asterisk.c.

{
    int res = -1;
 
#if defined(HAVE_WORKING_FORK) || defined(HAVE_WORKING_VFORK)
    if (pid > 0) {
        for (;;) {
            int status;
 
            res = waitpid(pid, &status, 0);
            if (res > -1) {
                res = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
                break;
            }
            if (errno != EINTR) {
                break;
            }
        }
    }
 
    ast_unreplace_sigchld();
#endif
 
    return res;
}

References ast_unreplace_sigchld(), errno, status, WEXITSTATUS, and WIFEXITED.

Referenced by ast_safe_execvp(), and ast_safe_system().

send_rasterisk_connect_commands()

static void send_rasterisk_connect_commands ( void  )

static

Definition at line 2660 of file asterisk.c.

{
    char buf[80];
 
    /*
     * Tell the server asterisk instance about the verbose level
     * initially desired.
     */
    if (option_verbose) {
        snprintf(buf, sizeof(buf), "core set verbose atleast %d silent", option_verbose);
        fdsend(ast_consock, buf);
    }
 
    if (option_debug) {
        snprintf(buf, sizeof(buf), "core set debug atleast %d", option_debug);
        fdsend(ast_consock, buf);
    }
 
    /* Leave verbose filtering to the server. */
    option_verbose = INT_MAX;
 
    if (!ast_opt_mute) {
        fdsend(ast_consock, "logger mute silent");
    } else {
        printf("log and verbose output currently muted ('logger mute' to unmute)\n");
    }
}

References ast_consock, ast_opt_mute, buf, fdsend(), option_debug, and option_verbose.

Referenced by ast_el_read_char(), and ast_remotecontrol().

set_header()

static void set_header ( char *  outbuf, int  maxout, char  level  )

static

Definition at line 2169 of file asterisk.c.

{
    const char *cmp;
    char date[40];
 
    switch (level) {
    case 0: cmp = NULL;
        break;
    case 1: cmp = VERBOSE_PREFIX_1;
        break;
    case 2: cmp = VERBOSE_PREFIX_2;
        break;
    case 3: cmp = VERBOSE_PREFIX_3;
        break;
    case 4: cmp = VERBOSE_PREFIX_4;
        break;
    case 5: cmp = VERBOSE_PREFIX_5;
        break;
    case 6: cmp = VERBOSE_PREFIX_6;
        break;
    case 7: cmp = VERBOSE_PREFIX_7;
        break;
    case 8: cmp = VERBOSE_PREFIX_8;
        break;
    case 9: cmp = VERBOSE_PREFIX_9;
        break;
    default: cmp = VERBOSE_PREFIX_10;
        break;
    }
 
    if (ast_opt_timestamp) {
        struct ast_tm tm;
        struct timeval now = ast_tvnow();
        ast_localtime(&now, &tm, NULL);
        ast_strftime(date, sizeof(date), ast_logger_get_dateformat(), &tm);
    }
 
    snprintf(outbuf, maxout, "%s%s%s%s%s%s",
        ast_opt_timestamp ? "[" : "",
        ast_opt_timestamp ? date : "",
        ast_opt_timestamp ? "] " : "",
        cmp ? ast_term_color(COLOR_GRAY, 0) : "",
        cmp ? cmp : "",
        cmp ? ast_term_reset() : "");
}

References ast_localtime(), ast_logger_get_dateformat(), ast_opt_timestamp, ast_strftime(), ast_term_color(), ast_term_reset(), ast_tvnow(), COLOR_GRAY, NULL, 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 console_print().

set_icon()

static void set_icon ( char *  text )

static

Definition at line 1783 of file asterisk.c.

{
    if (getenv("TERM") && strstr(getenv("TERM"), "xterm"))
        fprintf(stdout, "\033]1;%s\007", text);
}

References text.

Referenced by asterisk_daemon().

set_priority_all()

static int set_priority_all ( int  pri )

static

Set priority on all known threads.

Definition at line 1810 of file asterisk.c.

{
#if !defined(__linux__)
    /* The non-linux version updates the entire process prio. */
    return ast_set_priority(pri);
#elif defined(LOW_MEMORY)
    ast_log(LOG_WARNING, "Unable to enumerate all threads to update priority\n");
    return ast_set_priority(pri);
#else
    struct thread_list_t *cur;
    struct sched_param sched;
    char const *policy_str;
    int policy;
 
    memset(&sched, 0, sizeof(sched));
    if (pri) {
        policy = SCHED_RR;
        policy_str = "realtime";
        sched.sched_priority = 10;
    } else {
        policy = SCHED_OTHER;
        policy_str = "regular";
        sched.sched_priority = 0;
    }
    if (sched_setscheduler(getpid(), policy, &sched)) {
        ast_log(LOG_WARNING, "Unable to set %s thread priority on main thread\n", policy_str);
        return -1;
    }
    ast_verb(1, "Setting %s thread priority on all threads\n", policy_str);
    AST_RWLIST_RDLOCK(&thread_list);
    AST_RWLIST_TRAVERSE(&thread_list, cur, list) {
        /* Don't care about the return value. It should work. */
        sched_setscheduler(cur->lwp, policy, &sched);
    }
    AST_RWLIST_UNLOCK(&thread_list);
    return 0;
#endif
}

References ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_set_priority(), ast_verb, LOG_WARNING, thread_list_t::lwp, and sched_setscheduler.

Referenced by canary_thread().

set_title()

static void set_title ( char *  text )

static

Set an X-term or screen title.

Definition at line 1777 of file asterisk.c.

{
    if (getenv("TERM") && strstr(getenv("TERM"), "xterm"))
        fprintf(stdout, "\033]2;%s\007", text);
}

References text.

Referenced by asterisk_daemon().

show_cli_help()

static int show_cli_help ( void  )

static

Definition at line 3411 of file asterisk.c.

{
    printf("Asterisk %s, " COPYRIGHT_TAG "\n", ast_get_version());
    printf("Usage: asterisk [OPTIONS]\n");
    printf("Valid Options:\n");
    printf("   -V              Display version number and exit\n");
    printf("   -C <configfile> Use an alternate configuration file\n");
    printf("   -G <group>      Run as a group other than the caller\n");
    printf("   -U <user>       Run as a user other than the caller\n");
    printf("   -c              Provide console CLI\n");
    printf("   -d              Increase debugging (multiple d's = more debugging)\n");
#if HAVE_WORKING_FORK
    printf("   -f              Do not fork\n");
    printf("   -F              Always fork\n");
#endif
    printf("   -g              Dump core in case of a crash\n");
    printf("   -h              This help screen\n");
    printf("   -i              Initialize crypto keys at startup\n");
    printf("   -L <load>       Limit the maximum load average before rejecting new calls\n");
    printf("   -M <value>      Limit the maximum number of calls to the specified value\n");
    printf("   -m              Mute debugging and console output on the console\n");
    printf("   -n              Disable console colorization. Can be used only at startup.\n");
    printf("   -p              Run as pseudo-realtime thread\n");
    printf("   -q              Quiet mode (suppress output)\n");
    printf("   -r              Connect to Asterisk on this machine\n");
    printf("   -R              Same as -r, except attempt to reconnect if disconnected\n");
    printf("   -s <socket>     Connect to Asterisk via socket <socket> (only valid with -r)\n");
    printf("   -t              Record soundfiles in /var/tmp and move them where they\n");
    printf("                   belong after they are done\n");
    printf("   -T              Display the time in [Mmm dd hh:mm:ss] format for each line\n");
    printf("                   of output to the CLI. Cannot be used with remote console mode.\n\n");
    printf("   -v              Increase verbosity (multiple v's = more verbose)\n");
    printf("   -x <cmd>        Execute command <cmd> (implies -r)\n");
    printf("   -X              Enable use of #exec in asterisk.conf\n");
    printf("   -W              Adjust terminal colors to compensate for a light background\n");
    printf("\n");
    return 0;
}

References ast_get_version(), and COPYRIGHT_TAG.

Referenced by main().

show_license()

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

static

Definition at line 2606 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show license";
        e->usage =
            "Usage: core show license\n"
            "       Shows the license(s) for this copy of Asterisk.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, "%s", license_lines);
 
    return CLI_SUCCESS;
}

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

show_version()

static int show_version ( void  )

static

Definition at line 3405 of file asterisk.c.

{
    printf("Asterisk %s\n", ast_get_version());
    return 0;
}

References ast_get_version().

Referenced by main().

show_warranty()

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

static

Definition at line 2569 of file asterisk.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show warranty";
        e->usage =
            "Usage: core show warranty\n"
            "       Shows the warranty (if any) for this copy of Asterisk.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, "%s", warranty_lines);
 
    return CLI_SUCCESS;
}

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

wait_for_channels_to_die()

static int wait_for_channels_to_die ( shutdown_nice_t  niceness, int  seconds  )

static

Definition at line 1945 of file asterisk.c.

{
    time_t start;
    time_t now;
    int waited = 0;
 
    time(&start);
    for (;;) {
        if (!ast_undestroyed_channels() || shuttingdown != niceness) {
            break;
        }
        if (seconds < 0) {
            /* No timeout so just poll every second */
            sleep(1);
        } else {
            time(&now);
 
            /* Wait up to the given seconds for all channels to go away */
            if (seconds < (now - start)) {
                break;
            }
 
            /* Sleep 1/10 of a second */
            usleep(100000);
        }
        waited = 1;
    }
    return waited;
}

References ast_undestroyed_channels(), and shuttingdown.

Referenced by can_safely_quit().

Variable Documentation

_argv

char* _argv[256]

static

Definition at line 362 of file asterisk.c.

Referenced by _hup_handler(), main(), and really_quit().

ast_consock

int ast_consock = -1

static

UNIX Socket for controlling another asterisk

Definition at line 322 of file asterisk.c.

Referenced by ast_el_read_char(), ast_remotecontrol(), ast_tryconnect(), cli_complete(), really_quit(), and send_rasterisk_connect_commands().

ast_lastreloadtime

struct timeval ast_lastreloadtime

Definition at line 345 of file asterisk.c.

Referenced by action_corestatus(), action_login(), ast_ari_asterisk_get_info(), ast_module_reload(), ast_var_Config(), asterisk_daemon(), get_last_reload_cb(), handle_show_settings(), handle_showuptime(), and publish_fully_booted().

ast_mainpid

pid_t ast_mainpid

Definition at line 323 of file asterisk.c.

Referenced by asterisk_daemon(), main(), netconsole(), safe_append(), and scan_service().

ast_socket

int ast_socket = -1

static

UNIX Socket for allowing remote control

Definition at line 320 of file asterisk.c.

Referenced by ast_makesocket(), listener(), and really_quit().

ast_socket_is_sd

int ast_socket_is_sd = 0

static

Is socket activation responsible for ast_socket?

Definition at line 321 of file asterisk.c.

Referenced by ast_makesocket(), main(), and really_quit().

ast_startuptime

struct timeval ast_startuptime

Definition at line 344 of file asterisk.c.

Referenced by action_corestatus(), action_login(), ast_ari_asterisk_get_info(), ast_var_Config(), asterisk_daemon(), get_core_uptime_cb(), handle_show_settings(), handle_showcalls(), handle_showuptime(), and publish_fully_booted().

atexits

struct atexits atexits = AST_LIST_HEAD_INIT_VALUE

static

canary_filename

char canary_filename[128]

static

Definition at line 395 of file asterisk.c.

Referenced by asterisk_daemon(), and canary_thread().

canary_pid

int canary_pid = 0

static

Definition at line 394 of file asterisk.c.

Referenced by asterisk_daemon(), and canary_exit().

child_handler

struct sigaction child_handler

static

Initial value:

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

Definition at line 1771 of file asterisk.c.

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

Referenced by main().

cli_asterisk

struct ast_cli_entry cli_asterisk[]

static

Definition at line 2643 of file asterisk.c.

                                             {
    AST_CLI_DEFINE(handle_abort_shutdown, "Cancel a running shutdown"),
    AST_CLI_DEFINE(show_warranty, "Show the warranty (if any) for this copy of Asterisk"),
    AST_CLI_DEFINE(show_license, "Show the license(s) for this copy of Asterisk"),
    AST_CLI_DEFINE(handle_version, "Display version info"),
    AST_CLI_DEFINE(handle_bang, "Execute a shell command"),
#if !defined(LOW_MEMORY)
    AST_CLI_DEFINE(handle_show_threads, "Show running threads"),
#if defined(HAVE_SYSINFO) || defined(HAVE_SYSCTL)
    AST_CLI_DEFINE(handle_show_sysinfo, "Show System Information"),
#endif
    AST_CLI_DEFINE(handle_show_profile, "Display profiling info"),
    AST_CLI_DEFINE(handle_show_settings, "Show some core settings"),
    AST_CLI_DEFINE(handle_clear_profile, "Clear profiling info"),
#endif /* ! LOW_MEMORY */
};

Referenced by asterisk_daemon(), and main_atexit().

cli_asterisk_shutdown

struct ast_cli_entry cli_asterisk_shutdown[]

static

Shutdown Asterisk CLI commands.

Note

These CLI commands cannot be unregistered at shutdown because one of them is likely the reason for the shutdown. The CLI generates a warning if a command is in-use when it is unregistered.

Definition at line 2634 of file asterisk.c.

                                                      {
    AST_CLI_DEFINE(handle_stop_now, "Shut down Asterisk immediately"),
    AST_CLI_DEFINE(handle_stop_gracefully, "Gracefully shut down Asterisk"),
    AST_CLI_DEFINE(handle_stop_when_convenient, "Shut down Asterisk at empty call volume"),
    AST_CLI_DEFINE(handle_restart_now, "Restart Asterisk immediately"),
    AST_CLI_DEFINE(handle_restart_gracefully, "Restart Asterisk gracefully"),
    AST_CLI_DEFINE(handle_restart_when_convenient, "Restart Asterisk at empty call volume"),
};

Referenced by asterisk_daemon().

consoles

struct console consoles[AST_MAX_CONNECTS]

Definition at line 351 of file asterisk.c.

Referenced by ast_console_toggle_loglevel(), ast_console_toggle_mute(), ast_makesocket(), ast_network_puts(), ast_network_puts_mutable(), and listener().

consolethread

pthread_t consolethread = AST_PTHREADT_NULL

static

Definition at line 392 of file asterisk.c.

Referenced by ast_console_puts_mutable_full(), asterisk_daemon(), monitor_sig_flags(), and really_quit().

el

EditLine* el

static

Definition at line 348 of file asterisk.c.

Referenced by __ast_context_destroy(), __ast_internal_context_destroy(), _hup_handler(), add_pri(), add_priority(), ast_add_extension2(), ast_add_extension2_lockopt(), ast_el_add_history(), ast_el_initialize(), ast_el_read_history(), ast_el_write_history(), ast_remotecontrol(), asterisk_daemon(), editline_read_char(), g722_encode(), handle_cli_dialplan_save(), read_char(), really_quit(), and show_dialplan_helper().

el_hist

History* el_hist

static

Definition at line 347 of file asterisk.c.

Referenced by ast_el_add_history(), ast_el_initialize(), ast_el_read_history(), ast_el_write_history(), ast_remotecontrol(), asterisk_daemon(), and really_quit().

hup_handler

struct sigaction hup_handler

static

Initial value:

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

Definition at line 1751 of file asterisk.c.

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

Referenced by asterisk_daemon().

ignore_sig_handler

struct sigaction ignore_sig_handler

static

Initial value:

= {
    .sa_handler = SIG_IGN,
}

Definition at line 1101 of file asterisk.c.

                                             {
    .sa_handler = SIG_IGN,
};

Referenced by asterisk_daemon().

license_lines

const char license_lines[]

static

Definition at line 2587 of file asterisk.c.

                                    {
    "\n"
    "This program is free software; you can redistribute it and/or modify\n"
    "it under the terms of the GNU General Public License version 2 as\n"
    "published by the Free Software Foundation.\n"
    "\n"
    "This program also contains components licensed under other licenses.\n"
    "They include:\n"
    "\n"
    "This program is distributed in the hope that it will be useful,\n"
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    "GNU General Public License for more details.\n"
    "\n"
    "You should have received a copy of the GNU General Public License\n"
    "along with this program; if not, write to the Free Software\n"
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
};

Referenced by show_license().

lthread

pthread_t lthread

static

Definition at line 1378 of file asterisk.c.

Referenced by ast_makesocket(), and really_quit().

mon_sig_flags

pthread_t mon_sig_flags

static

Definition at line 393 of file asterisk.c.

Referenced by asterisk_daemon().

multi_thread_safe

int multi_thread_safe

static

Definition at line 396 of file asterisk.c.

Referenced by ast_register_thread(), asterisk_daemon(), and main().

need_el_end

unsigned int need_el_end

Definition at line 409 of file asterisk.c.

need_quit

unsigned int need_quit

Definition at line 407 of file asterisk.c.

need_quit_handler

unsigned int need_quit_handler

Definition at line 408 of file asterisk.c.

need_reload

unsigned int need_reload

Definition at line 406 of file asterisk.c.

null_sig_handler

struct sigaction null_sig_handler

static

Initial value:

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

Definition at line 1096 of file asterisk.c.

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

Referenced by ast_replace_sigchld().

prof_data

struct profile_data* prof_data

static

Definition at line 804 of file asterisk.c.

Referenced by ast_add_profile(), ast_mark(), ast_profile(), handle_clear_profile(), and handle_show_profile().

prompt

struct ast_str* prompt = NULL

static

Examples

app_skel.c.

Definition at line 2802 of file asterisk.c.

Referenced by ast_app_getdata(), ast_app_getdata_full(), ast_app_getdata_terminator(), auth_exec(), cli_prompt(), handle_speechrecognize(), load_module(), minivm_accmess_exec(), play_files_helper(), and pw_cb().

randompool

char randompool[256]

static

Definition at line 398 of file asterisk.c.

Referenced by asterisk_daemon().

remotehostname

char* remotehostname

static

Definition at line 349 of file asterisk.c.

Referenced by ast_remotecontrol(), and cli_prompt().

restartnow

int restartnow

static

Definition at line 391 of file asterisk.c.

Referenced by _hup_handler(), and really_quit().

safe_system_level

unsigned int safe_system_level = 0

static

Keep track of how many threads are currently trying to wait*() on a child process.

Definition at line 1109 of file asterisk.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

safe_system_lock

ast_mutex_t safe_system_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 1105 of file asterisk.c.

Referenced by ast_begin_shutdown(), ast_cancel_shutdown(), ast_replace_sigchld(), ast_unreplace_sigchld(), and can_safely_quit().

safe_system_prev_handler

struct sigaction safe_system_prev_handler

static

Definition at line 1110 of file asterisk.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

shutdown_pending

int shutdown_pending

static

Prevent new channel allocation for shutdown.

Definition at line 389 of file asterisk.c.

Referenced by ast_begin_shutdown(), ast_cancel_shutdown(), and ast_shutting_down().

shuttingdown

shutdown_nice_t shuttingdown = NOT_SHUTTING_DOWN

static

Definition at line 386 of file asterisk.c.

Referenced by ast_begin_shutdown(), ast_cancel_shutdown(), ast_shutdown_final(), can_safely_quit(), and wait_for_channels_to_die().

sig_alert_pipe

int sig_alert_pipe[2] = { -1, -1 }

static

Definition at line 404 of file asterisk.c.

{ -1, -1 };

Referenced by __quit_handler(), _hup_handler(), asterisk_daemon(), monitor_sig_flags(), and really_quit().

[struct]

struct { ... } sig_flags

Referenced by __quit_handler(), __remote_quit_handler(), _hup_handler(), ast_el_read_char(), ast_remotecontrol(), asterisk_daemon(), monitor_sig_flags(), and really_quit().

startup_commands_phase_str

const char* startup_commands_phase_str[]

static

Initial value:

= {
    "pre-init",
    "pre-module",
    "fully-booted,yes,true,y,t,1,on"
}

Definition at line 3553 of file asterisk.c.

                                                  {
    "pre-init",
    "pre-module",
    "fully-booted,yes,true,y,t,1,on"
};

Referenced by run_startup_commands().

thread_list

struct thread_list thread_list = AST_RWLIST_HEAD_INIT_VALUE

static

urg_handler

struct sigaction urg_handler

static

Initial value:

= {
    .sa_handler = _urg_handler,
}

Definition at line 1728 of file asterisk.c.

                                      {
    .sa_handler = _urg_handler,
};

Referenced by asterisk_daemon().

warranty_lines

const char warranty_lines[]

static

Definition at line 2544 of file asterisk.c.

                                     {
    "\n"
    "               NO WARRANTY\n"
    "\n"
    "BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n"
    "FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\n"
    "OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n"
    "PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n"
    "OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n"
    "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\n"
    "TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\n"
    "PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n"
    "REPAIR OR CORRECTION.\n"
    "\n"
    "IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n"
    "WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n"
    "REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n"
    "INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n"
    "OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n"
    "TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n"
    "YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n"
    "PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n"
    "POSSIBILITY OF SUCH DAMAGES.\n"
};

Referenced by show_warranty().