#include "asterisk.h"
#include "asterisk/compat.h"
#include "asterisk/paths.h"
#include <errno.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <stdarg.h>
#include <string.h>
#include <locale.h>
#include <ctype.h>
#include <err.h>
#include <regex.h>
#include <limits.h>
#include <pthread.h>
#include <netdb.h>
#include <sys/param.h>
#include <signal.h>
#include "asterisk/inline_api.h"
#include "asterisk/endian.h"
#include "asterisk/ast_expr.h"
#include "asterisk/extconf.h"
#include "asterisk/hashtab.h"
#include "asterisk/ael_structs.h"
#include "asterisk/pval.h"

Include dependency graph for extconf.c:

Data Structures
struct	ast_app
	ast_app: A registered application More...

struct	ast_category

struct	ast_channel
	Main Channel structure associated with a channel. More...

struct	ast_comment
	Structure to keep comments for rewriting configuration files. More...

struct	ast_config

struct	ast_config_engine
	Configuration engine structure, used to define realtime drivers. More...

struct	ast_config_include

struct	ast_config_map

struct	ast_context
	ast_context: An extension context - must remain in sync with fake_context More...

struct	ast_custom_function
	Data structure associated with a custom dialplan function. More...

struct	ast_exten
	ast_exten: An extension The dialplan is saved as a linked list with each context having it's own linked list of extensions - one item per priority. More...

struct	ast_flags
	Structure used to handle boolean flags. More...

struct	ast_hint
	Structure for dial plan hints. More...

struct	ast_ignorepat
	ast_ignorepat: Ignore patterns in dial plan More...

struct	ast_include
	ast_include: include= support in extensions.conf More...

struct	ast_state_cb
	ast_state_cb: An extension state notify register item More...

struct	ast_sw
	ast_sw: Switch statement in extensions.conf More...

struct	ast_switch

struct	ast_timing

struct	ast_var_t

struct	ast_variable
	Structure for variables, used for configurations and for channel variables. More...

struct	hints

struct	store_hint

struct	store_hints

struct	varshead

Macros
#define	__AST_MUTEX_DEFINE(scope, mutex) scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE

#define	__AST_RWLOCK_DEFINE(scope, rwlock) scope ast_rwlock_t rwlock = AST_RWLOCK_INIT_VALUE

#define	__LOG_DEBUG 0

#define	__LOG_DTMF 6

#define	__LOG_ERROR 4

#define	__LOG_EVENT 1

#define	__LOG_NOTICE 2

#define	__LOG_VERBOSE 5

#define	__LOG_WARNING 3

#define	__MTX_PROF(a) return pthread_mutex_lock((a))

#define	_A_ __FILE__, __LINE__, __PRETTY_FUNCTION__

#define	_ASTERISK_LOCK_H /* A small indication that this is horribly wrong. */

#define	AST_API_MODULE 1 /* gimme the inline defs! */

#define	AST_CACHE_DIR_LEN 512

#define	AST_DEFAULT_OPTIONS AST_OPT_FLAG_TRANSCODE_VIA_SLIN

#define	AST_FILENAME_MAX 80

#define	ast_fully_booted ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)

#define	AST_LIST_APPEND_LIST(head, list, field)
	Appends a whole list to the tail of a list. More...

#define	AST_LIST_EMPTY(head) (AST_LIST_FIRST(head) == NULL)
	Checks whether the specified list contains any entries. More...

#define	AST_LIST_ENTRY(type)
	Declare a forward link structure inside a list entry. More...

#define	AST_LIST_FIRST(head) ((head)->first)
	Returns the first entry contained in a list. More...

#define	AST_LIST_HEAD(name, type)
	Defines a structure to be used to hold a list of specified type. More...

#define	AST_LIST_HEAD_INIT(head)
	Initializes a list head structure. More...

#define	AST_LIST_HEAD_INIT_NOLOCK(head)
	Initializes a list head structure. More...

#define	AST_LIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD. More...

#define	AST_LIST_HEAD_NOLOCK(name, type)
	Defines a structure to be used to hold a list of specified type (with no lock). More...

#define	AST_LIST_HEAD_NOLOCK_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK. More...

#define	AST_LIST_HEAD_NOLOCK_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized. More...

#define	AST_LIST_HEAD_SET(head, entry)
	Initializes a list head structure with a specified first entry. More...

#define	AST_LIST_HEAD_SET_NOLOCK(head, entry)
	Initializes a list head structure with a specified first entry. More...

#define	AST_LIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized. More...

#define	AST_LIST_INSERT_AFTER(head, listelm, elm, field)
	Inserts a list entry after a given entry. More...

#define	AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field)
	Inserts a list entry before the current entry during a traversal. More...

#define	AST_LIST_INSERT_HEAD(head, elm, field)
	Inserts a list entry at the head of a list. More...

#define	AST_LIST_INSERT_TAIL(head, elm, field)
	Appends a list entry to the tail of a list. More...

#define	AST_LIST_LAST(head) ((head)->last)
	Returns the last entry contained in a list. More...

#define	AST_LIST_NEXT(elm, field) ((elm)->field.next)
	Returns the next entry in the list after the given entry. More...

#define	AST_LIST_REMOVE(head, elm, field)
	Removes a specific entry from a list. More...

#define	AST_LIST_REMOVE_CURRENT(head, field)
	Removes the current entry from a list during a traversal. More...

#define	AST_LIST_REMOVE_HEAD(head, field)
	Removes and returns the head entry from a list. More...

#define	AST_LIST_TRAVERSE(head, var, field) for((var) = (head)->first; (var); (var) = (var)->field.next)
	Loops over (traverses) the entries in a list. More...

#define	AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
	Loops safely over (traverses) the entries in a list. More...

#define	AST_LIST_TRAVERSE_SAFE_END }
	Closes a safe loop traversal block. More...

#define	AST_MAX_EXTENSION 80

#define	AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex)

#define	AST_MUTEX_INIT_VALUE ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)

#define	AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__

#define	AST_MUTEX_KIND PTHREAD_MUTEX_RECURSIVE

#define	ast_opt_always_fork ast_test_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)

#define	ast_opt_cache_record_files ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)

#define	ast_opt_console ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)

#define	ast_opt_dont_warn ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)

#define	ast_opt_dump_core ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)

#define	ast_opt_exec ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)

#define	ast_opt_exec_includes ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)

#define	ast_opt_high_priority ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)

#define	ast_opt_init_keys ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)

#define	ast_opt_mute ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)

#define	ast_opt_no_color ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)

#define	ast_opt_no_fork ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)

#define	ast_opt_override_config ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)

#define	ast_opt_priority_jumping ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)

#define	ast_opt_quiet ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)

#define	ast_opt_reconnect ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)

#define	ast_opt_remote ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)

#define	ast_opt_timestamp ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)

#define	ast_opt_transcode_via_slin ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)

#define	ast_opt_transmit_silence ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)

#define	ast_pthread_mutex_init(pmutex, a) pthread_mutex_init(pmutex,a)

#define	AST_PTHREADT_NULL (pthread_t) -1

#define	AST_PTHREADT_STOP (pthread_t) -2

#define	AST_RWLIST_APPEND_LIST AST_LIST_APPEND_LIST

#define	AST_RWLIST_EMPTY AST_LIST_EMPTY

#define	AST_RWLIST_ENTRY AST_LIST_ENTRY

#define	AST_RWLIST_FIRST AST_LIST_FIRST

#define	AST_RWLIST_HEAD(name, type)
	Defines a structure to be used to hold a read/write list of specified type. More...

#define	AST_RWLIST_HEAD_DESTROY(head)
	Destroys an rwlist head structure. More...

#define	AST_RWLIST_HEAD_INIT(head)
	Initializes an rwlist head structure. More...

#define	AST_RWLIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_RWLIST_HEAD. More...

#define	AST_RWLIST_HEAD_SET(head, entry)
	Initializes an rwlist head structure with a specified first entry. More...

#define	AST_RWLIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a read/write list of specified type, statically initialized. More...

#define	AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER

#define	AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT

#define	AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD

#define	AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL

#define	AST_RWLIST_LAST AST_LIST_LAST

#define	AST_RWLIST_NEXT AST_LIST_NEXT

#define	AST_RWLIST_RDLOCK(head) ast_rwlock_rdlock(&(head)->lock)
	Read locks a list. More...

#define	AST_RWLIST_REMOVE AST_LIST_REMOVE

#define	AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT

#define	AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD

#define	AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE

#define	AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN

#define	AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END

#define	AST_RWLIST_UNLOCK(head) ast_rwlock_unlock(&(head)->lock)
	Attempts to unlock a read/write based list. More...

#define	AST_RWLIST_WRLOCK(head) ast_rwlock_wrlock(&(head)->lock)
	Write locks a list. More...

#define	AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock)

#define	AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER

#define	ast_set2_flag(p, value, flag)

#define	ast_test_flag(p, flag)

#define	ASTMM_LIBC ASTMM_IGNORE

#define	BACKGROUND_MATCHEXTEN (1 << 2)

#define	BACKGROUND_NOANSWER (1 << 1)

#define	BACKGROUND_PLAYBACK (1 << 3)

#define	BACKGROUND_SKIP (1 << 0)

#define	CB_INCR 250

#define	COMMENT_END "--;"

#define	COMMENT_META ';'

#define	COMMENT_START ";--"

#define	COMMENT_TAG '-'

#define	DEBUG_M(a)

#define	EVENTLOG "event_log"

#define	EXT_DATA_SIZE 8192

#define	gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__

#define	LOG_DEBUG __LOG_DEBUG, _A_

#define	LOG_DTMF __LOG_DTMF, _A_

#define	LOG_ERROR __LOG_ERROR, _A_

#define	LOG_EVENT __LOG_EVENT, _A_

#define	LOG_NOTICE __LOG_NOTICE, _A_

#define	LOG_VERBOSE __LOG_VERBOSE, _A_

#define	LOG_WARNING __LOG_WARNING, _A_

#define	MAX_INCLUDE_LEVEL 10

#define	MAX_NESTED_COMMENTS 128

#define	ONE_MILLION 1000000

#define	PRIORITY_HINT -1

#define	pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t

#define	pthread_create __use_ast_pthread_create_instead__

#define	pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init

#define	PTHREAD_MUTEX_INIT_VALUE PTHREAD_MUTEX_INITIALIZER

#define	pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t

#define	QUEUELOG "queue_log"

#define	S_OR(a, b) (!ast_strlen_zero(a) ? (a) : (b))

#define	STATUS_NO_CONTEXT 1

#define	STATUS_NO_EXTENSION 2

#define	STATUS_NO_LABEL 4

#define	STATUS_NO_PRIORITY 3

#define	STATUS_SUCCESS 5

#define	SWITCH_DATA_LENGTH 256

#define	VAR_BUF_SIZE 4096

#define	VAR_HARDTRAN 3

#define	VAR_NORMAL 1

#define	VAR_SOFTTRAN 2

#define	VERBOSE_PREFIX_1 " "

#define	VERBOSE_PREFIX_2 " == "

#define	VERBOSE_PREFIX_3 " -- "

#define	VERBOSE_PREFIX_4 " > "

Typedefs
typedef pthread_cond_t	ast_cond_t

typedef pthread_mutex_t	ast_mutex_t

typedef pthread_rwlock_t	ast_rwlock_t

typedef int(*	ast_state_cb_type) (char context, char id, enum ast_extension_states state, void *data)

typedef int()	ast_switch_f(struct ast_channel chan, const char context, const char exten, int priority, const char callerid, const char *data)

typedef struct ast_config *	config_load_func(const char database, const char table, const char configfile, struct ast_config config, int withcomments, const char *suggested_include_file)

typedef struct ast_config *	realtime_multi_get(const char database, const char table, va_list ap)

typedef int	realtime_update(const char database, const char table, const char keyfield, const char entity, va_list ap)

typedef struct ast_variable *	realtime_var_get(const char database, const char table, va_list ap)

Enumerations
enum	ast_extension_states { AST_EXTENSION_REMOVED = -2, AST_EXTENSION_DEACTIVATED = -1, AST_EXTENSION_NOT_INUSE = 0, AST_EXTENSION_INUSE = 1 << 0, AST_EXTENSION_BUSY = 1 << 1, AST_EXTENSION_UNAVAILABLE = 1 << 2, AST_EXTENSION_RINGING = 1 << 3, AST_EXTENSION_ONHOLD = 1 << 4, AST_EXTENSION_REMOVED = -2, AST_EXTENSION_DEACTIVATED = -1, AST_EXTENSION_NOT_INUSE = 0, AST_EXTENSION_INUSE = 1 << 0, AST_EXTENSION_BUSY = 1 << 1, AST_EXTENSION_UNAVAILABLE = 1 << 2, AST_EXTENSION_RINGING = 1 << 3, AST_EXTENSION_ONHOLD = 1 << 4 }

enum	ast_option_flags { AST_OPT_FLAG_EXEC_INCLUDES = (1 << 0), AST_OPT_FLAG_NO_FORK = (1 << 1), AST_OPT_FLAG_QUIET = (1 << 2), AST_OPT_FLAG_CONSOLE = (1 << 3), AST_OPT_FLAG_HIGH_PRIORITY = (1 << 4), AST_OPT_FLAG_INIT_KEYS = (1 << 5), AST_OPT_FLAG_REMOTE = (1 << 6), AST_OPT_FLAG_EXEC = (1 << 7), AST_OPT_FLAG_NO_COLOR = (1 << 8), AST_OPT_FLAG_FULLY_BOOTED = (1 << 9), AST_OPT_FLAG_TRANSCODE_VIA_SLIN = (1 << 10), AST_OPT_FLAG_STDEXTEN_MACRO = (1 << 11), AST_OPT_FLAG_DUMP_CORE = (1 << 12), AST_OPT_FLAG_CACHE_RECORD_FILES = (1 << 13), AST_OPT_FLAG_TIMESTAMP = (1 << 14), AST_OPT_FLAG_CACHE_MEDIA_FRAMES = (1 << 15), AST_OPT_FLAG_RECONNECT = (1 << 16), AST_OPT_FLAG_TRANSMIT_SILENCE = (1 << 17), AST_OPT_FLAG_DONT_WARN = (1 << 18), AST_OPT_FLAG_REF_DEBUG = (1 << 20), AST_OPT_FLAG_ALWAYS_FORK = (1 << 21), AST_OPT_FLAG_MUTE = (1 << 22), AST_OPT_FLAG_DEBUG_MODULE = (1 << 23), AST_OPT_FLAG_TRACE_MODULE = (1 << 24), AST_OPT_FLAG_LIGHT_BACKGROUND = (1 << 25), AST_OPT_FLAG_HIDE_MESSAGING_AMI_EVENTS = (1 << 26), AST_OPT_FLAG_FORCE_BLACK_BACKGROUND = (1 << 27), AST_OPT_FLAG_HIDE_CONSOLE_CONNECT = (1 << 28), AST_OPT_FLAG_LOCK_CONFIG_DIR = (1 << 29), AST_OPT_FLAG_GENERIC_PLC = (1 << 30), AST_OPT_FLAG_GENERIC_PLC_ON_EQUAL_CODECS = (1 << 31), AST_OPT_FLAG_EXEC_INCLUDES = (1 << 0), AST_OPT_FLAG_NO_FORK = (1 << 1), AST_OPT_FLAG_QUIET = (1 << 2), AST_OPT_FLAG_CONSOLE = (1 << 3), AST_OPT_FLAG_HIGH_PRIORITY = (1 << 4), AST_OPT_FLAG_INIT_KEYS = (1 << 5), AST_OPT_FLAG_REMOTE = (1 << 6), AST_OPT_FLAG_EXEC = (1 << 7), AST_OPT_FLAG_NO_COLOR = (1 << 8), AST_OPT_FLAG_FULLY_BOOTED = (1 << 9), AST_OPT_FLAG_TRANSCODE_VIA_SLIN = (1 << 10), AST_OPT_FLAG_DUMP_CORE = (1 << 12), AST_OPT_FLAG_CACHE_RECORD_FILES = (1 << 13), AST_OPT_FLAG_TIMESTAMP = (1 << 14), AST_OPT_FLAG_OVERRIDE_CONFIG = (1 << 15), AST_OPT_FLAG_RECONNECT = (1 << 16), AST_OPT_FLAG_TRANSMIT_SILENCE = (1 << 17), AST_OPT_FLAG_DONT_WARN = (1 << 18), AST_OPT_FLAG_ALWAYS_FORK = (1 << 21), AST_OPT_FLAG_MUTE = (1 << 22), AST_OPT_FLAG_DEBUG_FILE = (1 << 23), AST_OPT_FLAG_LIGHT_BACKGROUND = (1 << 25), AST_OPT_FLAG_FORCE_BLACK_BACKGROUND = (1 << 27) }

Functions
static struct ast_context *	__ast_context_create (struct ast_context *extcontexts, const char name, const char *registrar, int existsokay)

static void	__ast_context_destroy (struct ast_context con, const char registrar)

static int	_extension_match_core (const char pattern, const char data, enum ext_match_t mode)

static void	_null_sig_handler (int sig)
	NULL handler so we can collect the child exit status. More...

static int	add_pri (struct ast_context con, struct ast_exten tmp, struct ast_exten el, struct ast_exten e, int replace)
	add the extension in the priority chain. returns 0 on success, -1 on failure More...

static struct ast_comment *	ALLOC_COMMENT (const char *buffer)

static int	ast_add_extension2 (struct ast_context con, int replace, const char extension, int priority, const char label, const char callerid, const char application, void data, void(datad)(void ), const char *registrar)
	Main interface to add extensions to the list for out context. More...

static int	ast_add_hint (struct ast_exten *e)
	ast_add_hint: Add hint to hint list, check initial extension state More...

static unsigned int	ast_app_separate_args (char buf, char delim, char *array, int arraylen)

int	ast_atomic_dec_and_test (volatile int *p)
	decrement *p by 1 and return true if the variable has reached 0. Useful e.g. to check if a refcount has reached 0. More...

int	ast_atomic_fetchadd_int (volatile int *p, int v)
	Atomically add v to p and return the previous value of *p. This can be used to handle reference counts, and the return value can be used to generate unique identifiers. More...

int	ast_build_timing (struct ast_timing i, const char info_in)
	Construct a timing bitmap, for use in time-based conditionals. More...

static void	ast_category_append (struct ast_config config, struct ast_category category)

static char *	ast_category_browse (struct ast_config config, const char prev)

static void	ast_category_destroy (struct ast_category *cat)

static struct ast_category *	ast_category_get (const struct ast_config config, const char category_name)

static struct ast_category *	ast_category_new (const char name, const char in_file, int lineno)

static int	ast_change_hint (struct ast_exten oe, struct ast_exten ne)
	ast_change_hint: Change hint for an extension More...

int	ast_check_timing (const struct ast_timing *i)
	Evaluate a pre-constructed bitmap as to whether the current time falls within the range specified. More...

static void	ast_config_destroy (struct ast_config *cfg)

struct ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
	Retrieve the current category name being built. More...

static struct ast_config *	ast_config_internal_load (const char filename, struct ast_config cfg, int withcomments, const char *suggested_incl_file)

static struct ast_config *	ast_config_new (void)

void	ast_config_set_current_category (struct ast_config cfg, const struct ast_category cat)
	Set the category within the configuration as being current. More...

void	ast_console_puts (const char *string)
	write the string to the root console, and all attached network console clients More...

static int	ast_context_add_ignorepat2 (struct ast_context con, const char value, const char *registrar)

static int	ast_context_add_include2 (struct ast_context con, const char value, const char *registrar)

static int	ast_context_add_switch2 (struct ast_context con, const char value, const char data, int eval, const char registrar)

static struct ast_context *	ast_context_find (const char *name)

static struct ast_context *	ast_context_find_or_create (struct ast_context *extcontexts, void tab, const char name, const char registrar)

int	ast_context_ignorepats_count (struct ast_context *con)

int	ast_context_includes_count (struct ast_context *con)

int	ast_context_switches_count (struct ast_context *con)

static int	ast_context_verify_includes (struct ast_context *con)

void	ast_copy_string (char dst, const char src, size_t size)

static int	ast_extension_match (const char pattern, const char data)

static int	ast_findlabel_extension2 (struct ast_channel c, struct ast_context con, const char exten, const char label, const char *callerid)

static int	ast_func_read (struct ast_channel chan, const char function, char *workspace, size_t len)

static int	ast_func_write (struct ast_channel chan, const char function, const char *value)

static const char *	ast_get_context_name (struct ast_context *con)

static const char *	ast_get_extension_app (struct ast_exten *e)

static const char *	ast_get_extension_name (struct ast_exten *exten)

static struct ast_config_include *	ast_include_find (struct ast_config conf, const char included_file)

static struct ast_config_include *	ast_include_new (struct ast_config conf, const char from_file, const char included_file, int is_exec, const char exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size)

static void	ast_includes_destroy (struct ast_config_include *incls)

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

void	ast_log_backtrace (void)
	Log a backtrace of the current thread's execution stack to the Asterisk log. More...

void	ast_mark_lock_failed (void *lock_addr)
	Mark the last lock as failed (trylock) More...

static void	ast_merge_contexts_and_delete (struct ast_context *extcontexts, const char registrar)

static int	ast_mutex_init (ast_mutex_t *pmutex)

static char *	ast_process_quotes_and_slashes (char *start, char find, char replace_with)

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

static int	ast_remove_hint (struct ast_exten *e)
	ast_remove_hint: Remove hint from extension More...

void	ast_replace_sigchld (void)
	Replace the SIGCHLD handler. More...

static int	ast_rwlock_destroy (ast_rwlock_t *prwlock)

static int	ast_rwlock_init (ast_rwlock_t *prwlock)

static int	ast_rwlock_rdlock (ast_rwlock_t *prwlock)

static int	ast_rwlock_unlock (ast_rwlock_t *prwlock)

static int	ast_rwlock_wrlock (ast_rwlock_t *prwlock)

int	ast_safe_system (const char *s)
	Safely spawn an OS shell command while closing file descriptors. More...

static void	ast_shrink_phone_number (char *n)
	Clean up phone string remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets. Basically, remove anything that could be invalid in a pattern. More...

char *	ast_skip_blanks (const char *str)

char *	ast_strip (char *s)
	Strip leading/trailing whitespace from a string. More...

static force_inline int	ast_strlen_zero (const char *s)

char *	ast_trim_blanks (char *str)
	Trims trailing whitespace characters from a string. More...

static int	ast_true (const char *s)

struct timeval	ast_tvadd (struct timeval a, struct timeval b)
	Returns the sum of two timevals a + b. More...

struct timeval	ast_tvnow (void)

struct timeval	ast_tvsub (struct timeval a, struct timeval b)
	Returns the difference of two timevals a - b. More...

static int	ast_unlock_context (struct ast_context *con)

static int	ast_unlock_contexts (void)

void	ast_unreplace_sigchld (void)
	Restore the SIGCHLD handler. More...

static struct ast_var_t *	ast_var_assign (const char name, const char value)

static void	ast_var_delete (struct ast_var_t *var)

static const char *	ast_var_name (const struct ast_var_t *var)

static const char *	ast_var_value (const struct ast_var_t *var)

static void	ast_variable_append (struct ast_category category, struct ast_variable variable)

static struct ast_variable *	ast_variable_browse (const struct ast_config config, const char category)

static struct ast_variable *	ast_variable_new (const char name, const char value, const char *filename)

static const char *	ast_variable_retrieve (const struct ast_config config, const char category, const char *variable)

static void	ast_variables_destroy (struct ast_variable *v)

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

static struct ast_exten *	ast_walk_context_extensions (struct ast_context con, struct ast_exten exten)

static struct ast_ignorepat *	ast_walk_context_ignorepats (struct ast_context con, struct ast_ignorepat ip)

static struct ast_include *	ast_walk_context_includes (struct ast_context con, struct ast_include inc)

static struct ast_sw *	ast_walk_context_switches (struct ast_context con, struct ast_sw sw)

static struct ast_context *	ast_walk_contexts (struct ast_context *con)

static struct ast_exten *	ast_walk_extension_priorities (struct ast_exten exten, struct ast_exten priority)

static int	ast_wrlock_context (struct ast_context *con)

static int	ast_wrlock_contexts (void)

static struct ast_category *	category_get (const struct ast_config config, const char category_name, int ignored)

static void	CB_ADD (char *str)

static void	CB_ADD_LEN (char *str, int len)

static void	CB_INIT (void)

static void	CB_RESET (void)

static struct ast_config *	config_text_file_load (const char database, const char table, const char filename, struct ast_config cfg, int withcomments, const char *suggested_include_file)

static void	destroy_exten (struct ast_exten *e)

static int	ext_cmp (const char a, const char b)
	the full routine to compare extensions in rules. More...

static int	ext_cmp1 (const char **p)
	helper functions to sort extensions and patterns in the desired way, so that more specific patterns appear first. More...

static int	ext_strncpy (char dst, const char src, int len)
	copy a string skipping whitespace More...

static int	extension_match_core (const char pattern, const char data, enum ext_match_t mode)

static struct ast_config_engine *	find_engine (const char family, char database, int dbsiz, char *table, int tabsiz)
	Find realtime engine for realtime family. More...

static void	gen_header (FILE f1, const char configfile, const char fn, const char generator)

static unsigned	get_range (char src, int max, char const names[], const char *msg)
	helper function to return a range up to max (7, 12, 31 respectively). names, if supplied, is an array of names that should be mapped to numbers. More...

static void	get_timerange (struct ast_timing i, char times)
	store a bitmask of valid times, one bit each 2 minute More...

static int	include_valid (struct ast_include *i)

static void	inherit_category (struct ast_category new, const struct ast_category base)

static void	LLB_ADD (char *str)

int	localized_add_extension2 (struct ast_context con, int replace, const char extension, int priority, const char label, const char callerid, const char application, void data, void(datad)(void ), const char *registrar)

void	localized_ast_include_rename (struct ast_config conf, const char from_file, const char *to_file)

struct ast_category *	localized_category_get (const struct ast_config config, const char category_name)

struct ast_config *	localized_config_load (const char *filename)

struct ast_config *	localized_config_load_with_comments (const char *filename)

int	localized_config_text_file_save (const char configfile, const struct ast_config cfg, const char *generator)

int	localized_context_add_ignorepat2 (struct ast_context con, const char value, const char *registrar)

int	localized_context_add_include2 (struct ast_context con, const char value, const char *registrar)

int	localized_context_add_switch2 (struct ast_context con, const char value, const char data, int eval, const char registrar)

void	localized_context_destroy (struct ast_context con, const char registrar)

struct ast_context *	localized_context_find_or_create (struct ast_context *extcontexts, void tab, const char name, const char registrar)

int	localized_context_verify_includes (struct ast_context *con)

struct ast_exten *	localized_find_extension (struct ast_context bypass, struct pbx_find_info q, const char context, const char exten, int priority, const char label, const char callerid, enum ext_match_t action)

void	localized_merge_contexts_and_delete (struct ast_context *extcontexts, void tab, const char *registrar)

int	localized_pbx_builtin_setvar (struct ast_channel chan, const void data)

int	localized_pbx_load_module (void)

void	localized_use_conf_dir (void)

void	localized_use_local_dir (void)

struct ast_exten *	localized_walk_context_extensions (struct ast_context con, struct ast_exten exten)

struct ast_include *	localized_walk_context_includes (struct ast_context con, struct ast_include inc)

struct ast_sw *	localized_walk_context_switches (struct ast_context con, struct ast_sw sw)

struct ast_context *	localized_walk_contexts (struct ast_context *con)

struct ast_exten *	localized_walk_extension_priorities (struct ast_exten exten, struct ast_exten priority)

static int	lookup_name (const char s, char const names[], int max)
	Helper for get_range. return the index of the matching entry, starting from 1. If names is not supplied, try numeric values. More...

static int	matchcid (const char cidpattern, const char callerid)

static void	move_variables (struct ast_category old, struct ast_category new)

static struct ast_category *	next_available_category (struct ast_category *cat)

static void	null_datad (void *foo)

static int	parse_variable_name (char var, int offset, int length, int isfunc)
	extract offset:length from variable name. Returns 1 if there is a offset:length part, which is trimmed off (values go into variables) More...

static int	pbx_builtin_setvar (struct ast_channel chan, const void data)

static void	pbx_builtin_setvar_helper (struct ast_channel chan, const char name, const char *value)

static int	pbx_extension_helper (struct ast_channel c, struct ast_context con, const char context, const char exten, int priority, const char label, const char callerid, enum ext_match_t action)
	The return value depends on the action: More...

static struct ast_exten *	pbx_find_extension (struct ast_channel chan, struct ast_context bypass, struct pbx_find_info q, const char context, const char exten, int priority, const char label, const char *callerid, enum ext_match_t action)

static int	pbx_load_config (const char *config_file)

static void	pbx_retrieve_variable (struct ast_channel c, const char var, char *ret, char workspace, int workspacelen, struct varshead *headp)
	Support for Asterisk built-in variables in the dialplan. More...

static void	pbx_substitute_variables_helper (struct ast_channel c, const char cp1, char *cp2, int count)

static void	pbx_substitute_variables_helper_full (struct ast_channel c, struct varshead headp, const char cp1, char cp2, int count)

static int	process_text_line (struct ast_config cfg, struct ast_category cat, char buf, int lineno, const char configfile, int withcomments, const char suggested_include_file)

static void	set_fn (char fn, int fn_size, const char file, const char *configfile)

static char *	substring (const char value, int offset, int length, char workspace, size_t workspace_len)
	takes a substring. It is ok to call with value == workspace. More...

static struct timeval	tvfix (struct timeval a)

static struct ast_variable *	variable_clone (const struct ast_variable *old)

Variables
char	ast_defaultlanguage []

int	ast_language_is_prefix
	The following variable controls the layout of localized sound files. If 0, use the historical layout with prefix just before the filename (i.e. digits/en/1.gsm , digits/it/1.gsm or default to digits/1.gsm), if 1 put the prefix at the beginning of the filename (i.e. en/digits/1.gsm, it/digits/1.gsm or default to digits/1.gsm). The latter permits a language to be entirely in one directory. More...

pid_t	ast_mainpid

int	ast_option_maxcalls

double	ast_option_maxload

struct ast_flags	ast_options = { AST_DEFAULT_OPTIONS }

static int	autofallthrough_config = 0

static int	clearglobalvars_config = 0

static char *	comment_buffer

static int	comment_buffer_size

static struct ast_config_engine *	config_engine_list

static char *	config_filename = "extensions.conf"

static struct ast_config_map *	config_maps = NULL

static ast_rwlock_t	conlock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }

static struct ast_context *	contexts = NULL

char *	days []

char	debug_filename [AST_FILENAME_MAX]

static char *	extconfig_conf = "extconfig.conf"

static char *	global_registrar = "conf2ael"

static struct varshead	globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE

static ast_rwlock_t	globalslock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }

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

static char *	lline_buffer

static int	lline_buffer_size

static struct ast_context *	local_contexts = NULL

char *	months []

static struct sigaction	null_sig_handler

int	option_debug

int	option_verbose

char	record_cache_dir [AST_CACHE_DIR_LEN]

static unsigned int	safe_system_level = 0
	Keep track of how many threads are currently trying to wait*() on a child process. More...

static struct sigaction	safe_system_prev_handler

static int	static_config = 0

static struct ast_config_engine	text_file_engine

static int	use_local_dir = 1

static char	userscontext [AST_MAX_EXTENSION] = "default"

static int	write_protect_config = 1

Detailed Description

A condensation of the pbx_config stuff, to read into exensions.conf, and provide an interface to the data there, for operations outside of asterisk. A huge, awful hack.

Definition in file extconf.c.

Macro Definition Documentation

◆ __AST_MUTEX_DEFINE

#define __AST_MUTEX_DEFINE	(	scope,
		mutex
	)	scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE

Definition at line 496 of file extconf.c.

◆ __AST_RWLOCK_DEFINE

#define __AST_RWLOCK_DEFINE	(	scope,
		rwlock
	)	scope ast_rwlock_t rwlock = AST_RWLOCK_INIT_VALUE

Definition at line 564 of file extconf.c.

◆ __LOG_DEBUG

#define __LOG_DEBUG 0

Definition at line 120 of file extconf.c.

◆ __LOG_DTMF

#define __LOG_DTMF 6

Definition at line 156 of file extconf.c.

◆ __LOG_ERROR

#define __LOG_ERROR 4

Definition at line 144 of file extconf.c.

◆ __LOG_EVENT

#define __LOG_EVENT 1

Definition at line 126 of file extconf.c.

◆ __LOG_NOTICE

#define __LOG_NOTICE 2

Definition at line 132 of file extconf.c.

◆ __LOG_VERBOSE

#define __LOG_VERBOSE 5

Definition at line 150 of file extconf.c.

◆ __LOG_WARNING

#define __LOG_WARNING 3

Definition at line 138 of file extconf.c.

◆ __MTX_PROF

#define __MTX_PROF ( a ) return pthread_mutex_lock((a))

Definition at line 163 of file extconf.c.

◆ _A_

#define _A_ __FILE__, __LINE__, __PRETTY_FUNCTION__

Definition at line 115 of file extconf.c.

◆ _ASTERISK_LOCK_H

#define _ASTERISK_LOCK_H /* A small indication that this is horribly wrong. */

Definition at line 160 of file extconf.c.

◆ AST_API_MODULE

#define AST_API_MODULE 1 /* gimme the inline defs! */

Definition at line 78 of file extconf.c.

◆ AST_CACHE_DIR_LEN

#define AST_CACHE_DIR_LEN 512

Definition at line 1359 of file extconf.c.

◆ AST_DEFAULT_OPTIONS

#define AST_DEFAULT_OPTIONS AST_OPT_FLAG_TRANSCODE_VIA_SLIN

These are the options that set by default when Asterisk starts

Definition at line 1363 of file extconf.c.

◆ AST_FILENAME_MAX

#define AST_FILENAME_MAX 80

Definition at line 1360 of file extconf.c.

◆ ast_fully_booted

#define ast_fully_booted ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)

Definition at line 1376 of file extconf.c.

◆ AST_LIST_APPEND_LIST

#define AST_LIST_APPEND_LIST	(	head,
		list,
		field
	)

Appends a whole list to the tail of a list.

Parameters

head	This is a pointer to the list head structure
list	This is a pointer to the list to be appended.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 1996 of file extconf.c.

◆ AST_LIST_EMPTY

#define AST_LIST_EMPTY ( head ) (AST_LIST_FIRST(head) == NULL)

Checks whether the specified list contains any entries.

Parameters

head	This is a pointer to the list head structure

Returns non-zero if the list has entries, zero if not.

Definition at line 1734 of file extconf.c.

◆ AST_LIST_ENTRY

#define AST_LIST_ENTRY ( type )

Value:

struct {                      \
   struct type *next;                  \
}

Declare a forward link structure inside a list entry.

Parameters

type	This is the type of each list entry.

This macro declares a structure to be used to link list entries together. It must be used inside the definition of the structure named in type, as follows:

struct list_entry {
   ...
   AST_LIST_ENTRY(list_entry) list;
}

The field name list here is arbitrary, and can be anything you wish.

Definition at line 1695 of file extconf.c.

◆ AST_LIST_FIRST

#define AST_LIST_FIRST ( head ) ((head)->first)

Returns the first entry contained in a list.

Parameters

head	This is a pointer to the list head structure

Definition at line 1706 of file extconf.c.

Referenced by ast_walk_context_switches().

◆ AST_LIST_HEAD

#define AST_LIST_HEAD	(	name,
		type
	)

Value:

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
   ast_mutex_t lock;                \
}

Defines a structure to be used to hold a list of specified type.

Parameters

name	This will be the name of the defined structure.
type	This is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

static AST_LIST_HEAD(entry_list, entry) entries;

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 1458 of file extconf.c.

◆ AST_LIST_HEAD_INIT

#define AST_LIST_HEAD_INIT ( head )

Value:

{              \
   (head)->first = NULL;                  \
   (head)->last = NULL;                \
   ast_mutex_init(&(head)->lock);               \
}

Initializes a list head structure.

Parameters

head	This is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list) and recreating the embedded lock.

Definition at line 1886 of file extconf.c.

◆ AST_LIST_HEAD_INIT_NOLOCK

#define AST_LIST_HEAD_INIT_NOLOCK ( head )

Value:

{           \
   (head)->first = NULL;                  \
   (head)->last = NULL;                \
}

Initializes a list head structure.

Parameters

head	This is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list). There is no embedded lock handling with this macro.

Definition at line 1927 of file extconf.c.

◆ AST_LIST_HEAD_INIT_VALUE

#define AST_LIST_HEAD_INIT_VALUE

Value:

{     \
   .first = NULL,             \
   .last = NULL,              \
   .lock = AST_MUTEX_INIT_VALUE,       \
   }

Defines initial values for a declaration of AST_LIST_HEAD.

Definition at line 1519 of file extconf.c.

◆ AST_LIST_HEAD_NOLOCK

#define AST_LIST_HEAD_NOLOCK	(	name,
		type
	)

Value:

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
}

Defines a structure to be used to hold a list of specified type (with no lock).

Parameters

name	This will be the name of the defined structure.
type	This is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 1510 of file extconf.c.

◆ AST_LIST_HEAD_NOLOCK_INIT_VALUE

#define AST_LIST_HEAD_NOLOCK_INIT_VALUE

Value:

{  \
   .first = NULL,             \
   .last = NULL,              \
   }

Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK.

Definition at line 1537 of file extconf.c.

◆ AST_LIST_HEAD_NOLOCK_STATIC

#define AST_LIST_HEAD_NOLOCK_STATIC	(	name,
		type
	)

Value:

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
} name = AST_LIST_HEAD_NOLOCK_INIT_VALUE

Defines a structure to be used to hold a list of specified type, statically initialized.

This is the same as AST_LIST_HEAD_STATIC, except without the lock included.

Definition at line 1631 of file extconf.c.

◆ AST_LIST_HEAD_SET

#define AST_LIST_HEAD_SET	(	head,
		entry
	)

Value:

do {           \
   (head)->first = (entry);               \
   (head)->last = (entry);                \
   ast_mutex_init(&(head)->lock);               \
} while (0)

Initializes a list head structure with a specified first entry.

Parameters

head	This is a pointer to the list head structure
entry	pointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value and recreating the embedded lock.

Definition at line 1645 of file extconf.c.

◆ AST_LIST_HEAD_SET_NOLOCK

#define AST_LIST_HEAD_SET_NOLOCK	(	head,
		entry
	)

Value:

do {        \
   (head)->first = (entry);               \
   (head)->last = (entry);                \
} while (0)

Initializes a list head structure with a specified first entry.

Parameters

head	This is a pointer to the list head structure
entry	pointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value.

Definition at line 1673 of file extconf.c.

◆ AST_LIST_HEAD_STATIC

#define AST_LIST_HEAD_STATIC	(	name,
		type
	)

Value:

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
   ast_mutex_t lock;                \
} name = AST_LIST_HEAD_INIT_VALUE

Defines a structure to be used to hold a list of specified type, statically initialized.

Parameters

name	This will be the name of the defined structure.
type	This is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type, and allocates an instance of it, initialized to be empty.

Example usage:

static AST_LIST_HEAD_STATIC(entry_list, entry);

This would define struct entry_list, intended to hold a list of type struct entry.

Definition at line 1576 of file extconf.c.

◆ AST_LIST_INSERT_AFTER

#define AST_LIST_INSERT_AFTER	(	head,
		listelm,
		elm,
		field
	)

Inserts a list entry after a given entry.

Parameters

head	This is a pointer to the list head structure
listelm	This is a pointer to the entry after which the new entry should be inserted.
elm	This is a pointer to the entry to be inserted.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 1941 of file extconf.c.

◆ AST_LIST_INSERT_BEFORE_CURRENT

#define AST_LIST_INSERT_BEFORE_CURRENT	(	head,
		elm,
		field
	)

Inserts a list entry before the current entry during a traversal.

Parameters

head	This is a pointer to the list head structure
elm	This is a pointer to the entry to be inserted.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Note: This macro can only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN() block.

Definition at line 1859 of file extconf.c.

◆ AST_LIST_INSERT_HEAD

#define AST_LIST_INSERT_HEAD	(	head,
		elm,
		field
	)

Inserts a list entry at the head of a list.

Parameters

head	This is a pointer to the list head structure
elm	This is a pointer to the entry to be inserted.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 1957 of file extconf.c.

Referenced by pbx_builtin_setvar_helper().

◆ AST_LIST_INSERT_TAIL

#define AST_LIST_INSERT_TAIL	(	head,
		elm,
		field
	)

Appends a list entry to the tail of a list.

Parameters

head	This is a pointer to the list head structure
elm	This is a pointer to the entry to be appended.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Note: The link field in the appended entry is not modified, so if it is actually the head of a list itself, the entire list will be appended temporarily (until the next AST_LIST_INSERT_TAIL is performed).

Definition at line 1977 of file extconf.c.

Referenced by ast_context_add_switch2().

◆ AST_LIST_LAST

#define AST_LIST_LAST ( head ) ((head)->last)

Returns the last entry contained in a list.

Parameters

head	This is a pointer to the list head structure

Definition at line 1714 of file extconf.c.

◆ AST_LIST_NEXT

#define AST_LIST_NEXT	(	elm,
		field
	)	((elm)->field.next)

Returns the next entry in the list after the given entry.

Parameters

elm	This is a pointer to the current entry.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 1724 of file extconf.c.

Referenced by ast_walk_context_switches().

◆ AST_LIST_REMOVE

#define AST_LIST_REMOVE	(	head,
		elm,
		field
	)

Removes a specific entry from a list.

Parameters

head	This is a pointer to the list head structure
elm	This is a pointer to the entry to be removed.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Warning: The removed entry is not freed nor modified in any way.

Definition at line 2038 of file extconf.c.

Referenced by pbx_builtin_setvar_helper().

◆ AST_LIST_REMOVE_CURRENT

#define AST_LIST_REMOVE_CURRENT	(	head,
		field
	)

Removes the current entry from a list during a traversal.

Parameters

head	This is a pointer to the list head structure
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Note: This macro can only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN() block; it is used to unlink the current entry from the list without affecting the list traversal (and without having to re-traverse the list to modify the previous entry, if any).

Definition at line 1837 of file extconf.c.

◆ AST_LIST_REMOVE_HEAD

#define AST_LIST_REMOVE_HEAD	(	head,
		field
	)

Removes and returns the head entry from a list.

Parameters

head	This is a pointer to the list head structure
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Removes the head entry from the list, and returns a pointer to it. This macro is safe to call on an empty list.

Definition at line 2017 of file extconf.c.

Referenced by __ast_context_destroy().

◆ AST_LIST_TRAVERSE

#define AST_LIST_TRAVERSE	(	head,
		var,
		field
	)	for((var) = (head)->first; (var); (var) = (var)->field.next)

Loops over (traverses) the entries in a list.

Parameters

head	This is a pointer to the list head structure
var	This is the name of the variable that will hold a pointer to the current list entry on each iteration. It must be declared before calling this macro.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

This macro is use to loop over (traverse) the entries in a list. It uses a for loop, and supplies the enclosed code with a pointer to each list entry as it loops. It is typically used as follows:

static AST_LIST_HEAD(entry_list, list_entry) entries;
...
struct list_entry {
   ...
   AST_LIST_ENTRY(list_entry) list;
}
...
struct list_entry *current;
...
AST_LIST_TRAVERSE(&entries, current, list) {
   (do something with current here)
}

Warning

If you modify the forward-link pointer contained in the current entry while inside the loop, the behavior will be unpredictable. At a minimum, the following macros will modify the forward-link pointer, and should not be used inside AST_LIST_TRAVERSE() against the entry pointed to by the current pointer without careful consideration of their consequences:

AST_LIST_NEXT() (when used as an lvalue)
AST_LIST_INSERT_AFTER()
AST_LIST_INSERT_HEAD()
AST_LIST_INSERT_TAIL()

Definition at line 1774 of file extconf.c.

Referenced by ast_context_add_switch2(), pbx_builtin_setvar_helper(), pbx_find_extension(), and pbx_retrieve_variable().

◆ AST_LIST_TRAVERSE_SAFE_BEGIN

#define AST_LIST_TRAVERSE_SAFE_BEGIN	(	head,
		var,
		field
	)

Loops safely over (traverses) the entries in a list.

Parameters

head	This is a pointer to the list head structure
var	This is the name of the variable that will hold a pointer to the current list entry on each iteration. It must be declared before calling this macro.
field	This is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

This macro is used to safely loop over (traverse) the entries in a list. It uses a for loop, and supplies the enclosed code with a pointer to each list entry as it loops. It is typically used as follows:

static AST_LIST_HEAD(entry_list, list_entry) entries;
...
struct list_entry {
   ...
   AST_LIST_ENTRY(list_entry) list;
}
...
struct list_entry *current;
...
AST_LIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) {
   (do something with current here)
}
AST_LIST_TRAVERSE_SAFE_END;

It differs from AST_LIST_TRAVERSE() in that the code inside the loop can modify (or even free, after calling AST_LIST_REMOVE_CURRENT()) the entry pointed to by the current pointer without affecting the loop traversal.

Definition at line 1812 of file extconf.c.

◆ AST_LIST_TRAVERSE_SAFE_END

#define AST_LIST_TRAVERSE_SAFE_END }

Closes a safe loop traversal block.

Definition at line 1875 of file extconf.c.

◆ AST_MAX_EXTENSION

#define AST_MAX_EXTENSION 80

Max length of an extension

Definition at line 2079 of file extconf.c.

◆ AST_MUTEX_DEFINE_STATIC

#define AST_MUTEX_DEFINE_STATIC ( mutex ) __AST_MUTEX_DEFINE(static, mutex)

Definition at line 504 of file extconf.c.

◆ AST_MUTEX_INIT_VALUE

#define AST_MUTEX_INIT_VALUE ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)

Definition at line 467 of file extconf.c.

◆ AST_MUTEX_INITIALIZER

#define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__

Definition at line 506 of file extconf.c.

◆ AST_MUTEX_KIND

#define AST_MUTEX_KIND PTHREAD_MUTEX_RECURSIVE

Definition at line 194 of file extconf.c.

Referenced by ast_mutex_init().

◆ ast_opt_always_fork

#define ast_opt_always_fork ast_test_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)

Definition at line 1386 of file extconf.c.

◆ ast_opt_cache_record_files

#define ast_opt_cache_record_files ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)

Definition at line 1380 of file extconf.c.

◆ ast_opt_console

#define ast_opt_console ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)

Definition at line 1370 of file extconf.c.

◆ ast_opt_dont_warn

#define ast_opt_dont_warn ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)

Definition at line 1385 of file extconf.c.

Referenced by pbx_load_config().

◆ ast_opt_dump_core

#define ast_opt_dump_core ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)

Definition at line 1379 of file extconf.c.

◆ ast_opt_exec

#define ast_opt_exec ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)

Definition at line 1374 of file extconf.c.

◆ ast_opt_exec_includes

#define ast_opt_exec_includes ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)

Definition at line 1367 of file extconf.c.

Referenced by process_text_line().

◆ ast_opt_high_priority

#define ast_opt_high_priority ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)

Definition at line 1371 of file extconf.c.

◆ ast_opt_init_keys

#define ast_opt_init_keys ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)

Definition at line 1372 of file extconf.c.

◆ ast_opt_mute

#define ast_opt_mute ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)

Definition at line 1387 of file extconf.c.

◆ ast_opt_no_color

#define ast_opt_no_color ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)

Definition at line 1375 of file extconf.c.

◆ ast_opt_no_fork

#define ast_opt_no_fork ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)

Definition at line 1368 of file extconf.c.

◆ ast_opt_override_config

#define ast_opt_override_config ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)

Definition at line 1382 of file extconf.c.

◆ ast_opt_priority_jumping

#define ast_opt_priority_jumping ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)

Definition at line 1378 of file extconf.c.

◆ ast_opt_quiet

#define ast_opt_quiet ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)

Definition at line 1369 of file extconf.c.

◆ ast_opt_reconnect

#define ast_opt_reconnect ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)

Definition at line 1383 of file extconf.c.

◆ ast_opt_remote

#define ast_opt_remote ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)

Definition at line 1373 of file extconf.c.

◆ ast_opt_timestamp

#define ast_opt_timestamp ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)

Definition at line 1381 of file extconf.c.

◆ ast_opt_transcode_via_slin

#define ast_opt_transcode_via_slin ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)

Definition at line 1377 of file extconf.c.

◆ ast_opt_transmit_silence

#define ast_opt_transmit_silence ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)

Definition at line 1384 of file extconf.c.

◆ ast_pthread_mutex_init

#define ast_pthread_mutex_init	(	pmutex,
		a
	)	pthread_mutex_init(pmutex,a)

Definition at line 479 of file extconf.c.

◆ AST_PTHREADT_NULL

#define AST_PTHREADT_NULL (pthread_t) -1

Definition at line 180 of file extconf.c.

◆ AST_PTHREADT_STOP

#define AST_PTHREADT_STOP (pthread_t) -2

Definition at line 181 of file extconf.c.

◆ AST_RWLIST_APPEND_LIST

#define AST_RWLIST_APPEND_LIST AST_LIST_APPEND_LIST

Definition at line 2006 of file extconf.c.

◆ AST_RWLIST_EMPTY

#define AST_RWLIST_EMPTY AST_LIST_EMPTY

Definition at line 1736 of file extconf.c.

◆ AST_RWLIST_ENTRY

#define AST_RWLIST_ENTRY AST_LIST_ENTRY

Definition at line 1700 of file extconf.c.

◆ AST_RWLIST_FIRST

#define AST_RWLIST_FIRST AST_LIST_FIRST

Definition at line 1708 of file extconf.c.

◆ AST_RWLIST_HEAD

#define AST_RWLIST_HEAD	(	name,
		type
	)

Value:

struct name {                                                           \
        struct type *first;                                             \
        struct type *last;                                              \
        ast_rwlock_t lock;                                              \
}

Defines a structure to be used to hold a read/write list of specified type.

Parameters

name	This will be the name of the defined structure.
type	This is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

static AST_RWLIST_HEAD(entry_list, entry) entries;

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 1484 of file extconf.c.

◆ AST_RWLIST_HEAD_DESTROY

#define AST_RWLIST_HEAD_DESTROY ( head )

Value:

{                                 \
        (head)->first = NULL;                                           \
        (head)->last = NULL;                                            \
        ast_rwlock_destroy(&(head)->lock);                              \
}

Destroys an rwlist head structure.

Parameters

head	This is a pointer to the list head structure

This macro destroys a list head structure by setting the head entry to NULL (empty list) and destroying the embedded lock. It does not free the structure from memory.

Definition at line 1913 of file extconf.c.

◆ AST_RWLIST_HEAD_INIT

#define AST_RWLIST_HEAD_INIT ( head )

Value:

{                                    \
        (head)->first = NULL;                                           \
        (head)->last = NULL;                                            \
        ast_rwlock_init(&(head)->lock);                                 \
}

Initializes an rwlist head structure.

Parameters

head	This is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list) and recreating the embedded lock.

Definition at line 1899 of file extconf.c.

◆ AST_RWLIST_HEAD_INIT_VALUE

#define AST_RWLIST_HEAD_INIT_VALUE

Value:

{               \
        .first = NULL,                                  \
        .last = NULL,                                   \
        .lock = AST_RWLOCK_INIT_VALUE,                  \
        }

Defines initial values for a declaration of AST_RWLIST_HEAD.

Definition at line 1528 of file extconf.c.

◆ AST_RWLIST_HEAD_SET

#define AST_RWLIST_HEAD_SET	(	head,
		entry
	)

Value:

do {                           \
        (head)->first = (entry);                                        \
        (head)->last = (entry);                                         \
        ast_rwlock_init(&(head)->lock);                                 \
} while (0)

Initializes an rwlist head structure with a specified first entry.

Parameters

head	This is a pointer to the list head structure
entry	pointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value and recreating the embedded lock.

Definition at line 1659 of file extconf.c.

◆ AST_RWLIST_HEAD_STATIC

#define AST_RWLIST_HEAD_STATIC	(	name,
		type
	)

Value:

struct name {                                                           \
        struct type *first;                                             \
        struct type *last;                                              \
        ast_rwlock_t lock;                                              \
} name = AST_RWLIST_HEAD_INIT_VALUE

Defines a structure to be used to hold a read/write list of specified type, statically initialized.

Parameters

name	This will be the name of the defined structure.
type	This is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type, and allocates an instance of it, initialized to be empty.

Example usage:

static AST_RWLIST_HEAD_STATIC(entry_list, entry);

This would define struct entry_list, intended to hold a list of type struct entry.

Definition at line 1618 of file extconf.c.

◆ AST_RWLIST_INSERT_AFTER

#define AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER

Definition at line 1948 of file extconf.c.

◆ AST_RWLIST_INSERT_BEFORE_CURRENT

#define AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT

Definition at line 1870 of file extconf.c.

◆ AST_RWLIST_INSERT_HEAD

#define AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD

Definition at line 1964 of file extconf.c.

Referenced by ast_add_hint().

◆ AST_RWLIST_INSERT_TAIL

#define AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL

Definition at line 1987 of file extconf.c.

◆ AST_RWLIST_LAST

#define AST_RWLIST_LAST AST_LIST_LAST

Definition at line 1716 of file extconf.c.

◆ AST_RWLIST_NEXT

#define AST_RWLIST_NEXT AST_LIST_NEXT

Definition at line 1726 of file extconf.c.

◆ AST_RWLIST_RDLOCK

#define AST_RWLIST_RDLOCK ( head ) ast_rwlock_rdlock(&(head)->lock)

Read locks a list.

Parameters

head	This is a pointer to the list head structure

This macro attempts to place a read lock in the list head structure pointed to by head. Returns non-zero on success, 0 on failure

Definition at line 1425 of file extconf.c.

◆ AST_RWLIST_REMOVE

#define AST_RWLIST_REMOVE AST_LIST_REMOVE

Definition at line 2056 of file extconf.c.

◆ AST_RWLIST_REMOVE_CURRENT

#define AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT

Definition at line 1847 of file extconf.c.

Referenced by ast_remove_hint().

◆ AST_RWLIST_REMOVE_HEAD

#define AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD

Definition at line 2028 of file extconf.c.

◆ AST_RWLIST_TRAVERSE

#define AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE

Definition at line 1777 of file extconf.c.

Referenced by ast_add_hint(), ast_change_hint(), and ast_check_timing().

◆ AST_RWLIST_TRAVERSE_SAFE_BEGIN

#define AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN

Definition at line 1824 of file extconf.c.

Referenced by ast_remove_hint().

◆ AST_RWLIST_TRAVERSE_SAFE_END

#define AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END

Definition at line 1877 of file extconf.c.

Referenced by ast_remove_hint().

◆ AST_RWLIST_UNLOCK

#define AST_RWLIST_UNLOCK ( head ) ast_rwlock_unlock(&(head)->lock)

Attempts to unlock a read/write based list.

Parameters

head	This is a pointer to the list head structure

This macro attempts to remove a read or write lock from the list head structure pointed to by head. If the list was not locked by this thread, this macro has no effect.

Definition at line 1436 of file extconf.c.

◆ AST_RWLIST_WRLOCK

#define AST_RWLIST_WRLOCK ( head ) ast_rwlock_wrlock(&(head)->lock)

Write locks a list.

Parameters

head	This is a pointer to the list head structure

This macro attempts to place an exclusive write lock in the list head structure pointed to by head. Returns non-zero on success, 0 on failure

Definition at line 1414 of file extconf.c.

◆ AST_RWLOCK_DEFINE_STATIC

#define AST_RWLOCK_DEFINE_STATIC ( rwlock ) __AST_RWLOCK_DEFINE(static, rwlock)

Definition at line 568 of file extconf.c.

◆ AST_RWLOCK_INIT_VALUE

#define AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER

Definition at line 563 of file extconf.c.

◆ ast_set2_flag

#define ast_set2_flag	(	p,
		value,
		flag
	)

Definition at line 684 of file extconf.c.

◆ ast_test_flag

#define ast_test_flag	(	p,
		flag
	)

Definition at line 677 of file extconf.c.

◆ ASTMM_LIBC

#define ASTMM_LIBC ASTMM_IGNORE

Definition at line 46 of file extconf.c.

◆ BACKGROUND_MATCHEXTEN

#define BACKGROUND_MATCHEXTEN (1 << 2)

Definition at line 2328 of file extconf.c.

◆ BACKGROUND_NOANSWER

#define BACKGROUND_NOANSWER (1 << 1)

Definition at line 2327 of file extconf.c.

◆ BACKGROUND_PLAYBACK

#define BACKGROUND_PLAYBACK (1 << 3)

Definition at line 2329 of file extconf.c.

◆ BACKGROUND_SKIP

#define BACKGROUND_SKIP (1 << 0)

Definition at line 2326 of file extconf.c.

◆ CB_INCR

#define CB_INCR 250

Definition at line 711 of file extconf.c.

Referenced by CB_ADD(), CB_ADD_LEN(), CB_INIT(), and LLB_ADD().

◆ COMMENT_END

#define COMMENT_END "--;"

Definition at line 698 of file extconf.c.

◆ COMMENT_META

#define COMMENT_META ';'

Definition at line 699 of file extconf.c.

Referenced by config_text_file_load().

◆ COMMENT_START

#define COMMENT_START ";--"

Definition at line 697 of file extconf.c.

◆ COMMENT_TAG

#define COMMENT_TAG '-'

Definition at line 700 of file extconf.c.

Referenced by config_text_file_load().

◆ DEBUG_M

#define DEBUG_M ( a )

Value:

{ \
   a; \
}

Definition at line 96 of file extconf.c.

◆ EVENTLOG

#define EVENTLOG "event_log"

Definition at line 93 of file extconf.c.

◆ EXT_DATA_SIZE

#define EXT_DATA_SIZE 8192

Definition at line 3605 of file extconf.c.

◆ gethostbyname

#define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__

Definition at line 508 of file extconf.c.

◆ LOG_DEBUG

#define LOG_DEBUG __LOG_DEBUG, _A_

Definition at line 121 of file extconf.c.

Referenced by __ast_context_create(), __ast_context_destroy(), ast_add_extension2(), ast_add_hint(), ast_merge_contexts_and_delete(), config_text_file_load(), localized_config_text_file_save(), pbx_extension_helper(), and pbx_substitute_variables_helper_full().

◆ LOG_DTMF

#define LOG_DTMF __LOG_DTMF, _A_

Definition at line 157 of file extconf.c.

◆ LOG_ERROR

#define LOG_ERROR __LOG_ERROR, _A_

Definition at line 145 of file extconf.c.

Referenced by ast_func_read(), config_text_file_load(), and process_text_line().

◆ LOG_EVENT

#define LOG_EVENT __LOG_EVENT, _A_

Definition at line 127 of file extconf.c.

◆ LOG_NOTICE

#define LOG_NOTICE __LOG_NOTICE, _A_

Definition at line 133 of file extconf.c.

Referenced by pbx_extension_helper(), and pbx_substitute_variables_helper_full().

◆ LOG_VERBOSE

#define LOG_VERBOSE __LOG_VERBOSE, _A_

Definition at line 151 of file extconf.c.

◆ LOG_WARNING

#define LOG_WARNING __LOG_WARNING, _A_

◆ MAX_INCLUDE_LEVEL

#define MAX_INCLUDE_LEVEL 10

Definition at line 895 of file extconf.c.

Referenced by ast_config_new().

◆ MAX_NESTED_COMMENTS

#define MAX_NESTED_COMMENTS 128

Definition at line 696 of file extconf.c.

Referenced by config_text_file_load().

◆ ONE_MILLION

#define ONE_MILLION 1000000

Definition at line 2262 of file extconf.c.

Referenced by ast_tvadd(), ast_tvsub(), and tvfix().

◆ PRIORITY_HINT

#define PRIORITY_HINT -1

Special Priority for a hint

Definition at line 2083 of file extconf.c.

Referenced by add_pri(), ast_add_extension2(), destroy_exten(), and pbx_load_config().

◆ pthread_cond_t

#define pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t

Definition at line 502 of file extconf.c.

◆ pthread_create

#define pthread_create __use_ast_pthread_create_instead__

Definition at line 511 of file extconf.c.

◆ pthread_mutex_init

#define pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init

Definition at line 501 of file extconf.c.

Referenced by ast_mutex_init().

◆ PTHREAD_MUTEX_INIT_VALUE

#define PTHREAD_MUTEX_INIT_VALUE PTHREAD_MUTEX_INITIALIZER

Definition at line 193 of file extconf.c.

◆ pthread_mutex_t

#define pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t

Definition at line 500 of file extconf.c.

◆ QUEUELOG

#define QUEUELOG "queue_log"

Definition at line 94 of file extconf.c.

◆ S_OR

#define S_OR	(	a,
		b
	)	(!ast_strlen_zero(a) ? (a) : (b))

Definition at line 957 of file extconf.c.

Referenced by pbx_load_config().

◆ STATUS_NO_CONTEXT

#define STATUS_NO_CONTEXT 1

Definition at line 2450 of file extconf.c.

Referenced by pbx_extension_helper(), and pbx_find_extension().

◆ STATUS_NO_EXTENSION

#define STATUS_NO_EXTENSION 2

Definition at line 2451 of file extconf.c.

Referenced by pbx_extension_helper(), and pbx_find_extension().

◆ STATUS_NO_LABEL

#define STATUS_NO_LABEL 4

Definition at line 2453 of file extconf.c.

Referenced by pbx_extension_helper(), and pbx_find_extension().

◆ STATUS_NO_PRIORITY

#define STATUS_NO_PRIORITY 3

Definition at line 2452 of file extconf.c.

Referenced by pbx_extension_helper(), and pbx_find_extension().

◆ STATUS_SUCCESS

#define STATUS_SUCCESS 5

Definition at line 2454 of file extconf.c.

Referenced by pbx_find_extension().

◆ SWITCH_DATA_LENGTH

#define SWITCH_DATA_LENGTH 256

Definition at line 3612 of file extconf.c.

Referenced by ast_context_add_switch2().

◆ VAR_BUF_SIZE

#define VAR_BUF_SIZE 4096

Definition at line 2320 of file extconf.c.

Referenced by pbx_substitute_variables_helper_full().

◆ VAR_HARDTRAN

#define VAR_HARDTRAN 3

Definition at line 2324 of file extconf.c.

◆ VAR_NORMAL

#define VAR_NORMAL 1

Definition at line 2322 of file extconf.c.

◆ VAR_SOFTTRAN

#define VAR_SOFTTRAN 2

Definition at line 2323 of file extconf.c.

◆ VERBOSE_PREFIX_1

#define VERBOSE_PREFIX_1 " "

Definition at line 100 of file extconf.c.

◆ VERBOSE_PREFIX_2

#define VERBOSE_PREFIX_2 " == "

Definition at line 101 of file extconf.c.

Referenced by config_text_file_load(), localized_config_text_file_save(), and pbx_builtin_setvar_helper().

◆ VERBOSE_PREFIX_3

#define VERBOSE_PREFIX_3 " -- "

Definition at line 102 of file extconf.c.

Referenced by __ast_context_create(), ast_add_extension2(), ast_context_add_include2(), and ast_context_add_switch2().

◆ VERBOSE_PREFIX_4

#define VERBOSE_PREFIX_4 " > "

Definition at line 103 of file extconf.c.

Typedef Documentation

◆ ast_cond_t

typedef pthread_cond_t ast_cond_t

Definition at line 481 of file extconf.c.

◆ ast_mutex_t

typedef pthread_mutex_t ast_mutex_t

Definition at line 465 of file extconf.c.

◆ ast_rwlock_t

typedef pthread_rwlock_t ast_rwlock_t

Definition at line 514 of file extconf.c.

◆ ast_state_cb_type

typedef int(* ast_state_cb_type) (char *context, char *id, enum ast_extension_states state, void *data)

Definition at line 2354 of file extconf.c.

◆ ast_switch_f

typedef int() ast_switch_f(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)

Definition at line 2106 of file extconf.c.

◆ config_load_func

typedef struct ast_config* config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, int withcomments, const char *suggested_include_file)

Definition at line 933 of file extconf.c.

◆ realtime_multi_get

typedef struct ast_config* realtime_multi_get(const char *database, const char *table, va_list ap)

Definition at line 935 of file extconf.c.

◆ realtime_update

typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)

Definition at line 936 of file extconf.c.

◆ realtime_var_get

typedef struct ast_variable* realtime_var_get(const char *database, const char *table, va_list ap)

Definition at line 934 of file extconf.c.

Enumeration Type Documentation

◆ ast_extension_states

enum ast_extension_states

Enumerator
AST_EXTENSION_REMOVED	Extension removed
AST_EXTENSION_DEACTIVATED	Extension hint removed
AST_EXTENSION_NOT_INUSE	No device INUSE or BUSY
AST_EXTENSION_INUSE	One or more devices INUSE
AST_EXTENSION_BUSY	All devices BUSY
AST_EXTENSION_UNAVAILABLE	All devices UNAVAILABLE/UNREGISTERED
AST_EXTENSION_RINGING	All devices RINGING
AST_EXTENSION_ONHOLD	All devices ONHOLD
AST_EXTENSION_REMOVED	Extension removed
AST_EXTENSION_DEACTIVATED	Extension hint removed
AST_EXTENSION_NOT_INUSE	No device INUSE or BUSY
AST_EXTENSION_INUSE	One or more devices INUSE
AST_EXTENSION_BUSY	All devices BUSY
AST_EXTENSION_UNAVAILABLE	All devices UNAVAILABLE/UNREGISTERED
AST_EXTENSION_RINGING	All devices RINGING
AST_EXTENSION_ONHOLD	All devices ONHOLD

Definition at line 2085 of file extconf.c.

                           {
    AST_EXTENSION_REMOVED = -2,   /*!< Extension removed */
    AST_EXTENSION_DEACTIVATED = -1,  /*!< Extension hint removed */
    AST_EXTENSION_NOT_INUSE = 0,  /*!< No device INUSE or BUSY  */
    AST_EXTENSION_INUSE = 1 << 0, /*!< One or more devices INUSE */
    AST_EXTENSION_BUSY = 1 << 1,  /*!< All devices BUSY */
    AST_EXTENSION_UNAVAILABLE = 1 << 2, /*!< All devices UNAVAILABLE/UNREGISTERED */
    AST_EXTENSION_RINGING = 1 << 3,  /*!< All devices RINGING */
    AST_EXTENSION_ONHOLD = 1 << 4,   /*!< All devices ONHOLD */
 };

◆ ast_option_flags

enum ast_option_flags

Enumerator
AST_OPT_FLAG_EXEC_INCLUDES	Allow #exec in config files
AST_OPT_FLAG_NO_FORK	Do not fork()
AST_OPT_FLAG_QUIET	Keep quiet
AST_OPT_FLAG_CONSOLE	Console mode
AST_OPT_FLAG_HIGH_PRIORITY	Run in realtime Linux priority
AST_OPT_FLAG_INIT_KEYS	Initialize keys for RSA authentication
AST_OPT_FLAG_REMOTE	Remote console
AST_OPT_FLAG_EXEC	Execute an asterisk CLI command upon startup
AST_OPT_FLAG_NO_COLOR	Don't use termcap colors
AST_OPT_FLAG_FULLY_BOOTED	Are we fully started yet?
AST_OPT_FLAG_TRANSCODE_VIA_SLIN	Trascode via signed linear
AST_OPT_FLAG_STDEXTEN_MACRO	Invoke the stdexten using the legacy macro method.
AST_OPT_FLAG_DUMP_CORE	Dump core on a seg fault
AST_OPT_FLAG_CACHE_RECORD_FILES	Cache sound files
AST_OPT_FLAG_TIMESTAMP	Display timestamp in CLI verbose output
AST_OPT_FLAG_CACHE_MEDIA_FRAMES	Cache media frames for performance
AST_OPT_FLAG_RECONNECT	Reconnect
AST_OPT_FLAG_TRANSMIT_SILENCE	Transmit Silence during Record() and DTMF Generation
AST_OPT_FLAG_DONT_WARN	Suppress some warnings
AST_OPT_FLAG_REF_DEBUG	Reference Debugging
AST_OPT_FLAG_ALWAYS_FORK	Always fork, even if verbose or debug settings are non-zero
AST_OPT_FLAG_MUTE	Disable log/verbose output to remote consoles
AST_OPT_FLAG_DEBUG_MODULE	There is a per-module debug setting
AST_OPT_FLAG_TRACE_MODULE	There is a per-module trace setting
AST_OPT_FLAG_LIGHT_BACKGROUND	Terminal colors should be adjusted for a light-colored background
AST_OPT_FLAG_HIDE_MESSAGING_AMI_EVENTS	Make the global Message channel an internal channel to suppress AMI events
AST_OPT_FLAG_FORCE_BLACK_BACKGROUND	Force black background
AST_OPT_FLAG_HIDE_CONSOLE_CONNECT	Hide remote console connect messages on console
AST_OPT_FLAG_LOCK_CONFIG_DIR	Protect the configuration file path with a lock
AST_OPT_FLAG_GENERIC_PLC	Generic PLC
AST_OPT_FLAG_GENERIC_PLC_ON_EQUAL_CODECS	Generic PLC onm equal codecs
AST_OPT_FLAG_EXEC_INCLUDES	Allow #exec in config files
AST_OPT_FLAG_NO_FORK	Do not fork()
AST_OPT_FLAG_QUIET	Keep quiet
AST_OPT_FLAG_CONSOLE	Console mode
AST_OPT_FLAG_HIGH_PRIORITY	Run in realtime Linux priority
AST_OPT_FLAG_INIT_KEYS	Initialize keys for RSA authentication
AST_OPT_FLAG_REMOTE	Remote console
AST_OPT_FLAG_EXEC	Execute an asterisk CLI command upon startup
AST_OPT_FLAG_NO_COLOR	Don't use termcap colors
AST_OPT_FLAG_FULLY_BOOTED	Are we fully started yet?
AST_OPT_FLAG_TRANSCODE_VIA_SLIN	Trascode via signed linear
AST_OPT_FLAG_DUMP_CORE	Dump core on a seg fault
AST_OPT_FLAG_CACHE_RECORD_FILES	Cache sound files
AST_OPT_FLAG_TIMESTAMP	Display timestamp in CLI verbose output
AST_OPT_FLAG_OVERRIDE_CONFIG	Override config
AST_OPT_FLAG_RECONNECT	Reconnect
AST_OPT_FLAG_TRANSMIT_SILENCE	Transmit Silence during Record() and DTMF Generation
AST_OPT_FLAG_DONT_WARN	Suppress some warnings
AST_OPT_FLAG_ALWAYS_FORK	Always fork, even if verbose or debug settings are non-zero
AST_OPT_FLAG_MUTE	Disable log/verbose output to remote consoles
AST_OPT_FLAG_DEBUG_FILE	There is a per-file debug setting
AST_OPT_FLAG_LIGHT_BACKGROUND	Terminal colors should be adjusted for a light-colored background
AST_OPT_FLAG_FORCE_BLACK_BACKGROUND	Force black background

Definition at line 1309 of file extconf.c.

                       {
    /*! Allow \#exec in config files */
    AST_OPT_FLAG_EXEC_INCLUDES = (1 << 0),
    /*! Do not fork() */
    AST_OPT_FLAG_NO_FORK = (1 << 1),
    /*! Keep quiet */
    AST_OPT_FLAG_QUIET = (1 << 2),
    /*! Console mode */
    AST_OPT_FLAG_CONSOLE = (1 << 3),
    /*! Run in realtime Linux priority */
    AST_OPT_FLAG_HIGH_PRIORITY = (1 << 4),
    /*! Initialize keys for RSA authentication */
    AST_OPT_FLAG_INIT_KEYS = (1 << 5),
    /*! Remote console */
    AST_OPT_FLAG_REMOTE = (1 << 6),
    /*! Execute an asterisk CLI command upon startup */
    AST_OPT_FLAG_EXEC = (1 << 7),
    /*! Don't use termcap colors */
    AST_OPT_FLAG_NO_COLOR = (1 << 8),
    /*! Are we fully started yet? */
    AST_OPT_FLAG_FULLY_BOOTED = (1 << 9),
    /*! Trascode via signed linear */
    AST_OPT_FLAG_TRANSCODE_VIA_SLIN = (1 << 10),
    /*! Dump core on a seg fault */
    AST_OPT_FLAG_DUMP_CORE = (1 << 12),
    /*! Cache sound files */
    AST_OPT_FLAG_CACHE_RECORD_FILES = (1 << 13),
    /*! Display timestamp in CLI verbose output */
    AST_OPT_FLAG_TIMESTAMP = (1 << 14),
    /*! Override config */
    AST_OPT_FLAG_OVERRIDE_CONFIG = (1 << 15),
    /*! Reconnect */
    AST_OPT_FLAG_RECONNECT = (1 << 16),
    /*! Transmit Silence during Record() and DTMF Generation */
    AST_OPT_FLAG_TRANSMIT_SILENCE = (1 << 17),
    /*! Suppress some warnings */
    AST_OPT_FLAG_DONT_WARN = (1 << 18),
    /*! Always fork, even if verbose or debug settings are non-zero */
    AST_OPT_FLAG_ALWAYS_FORK = (1 << 21),
    /*! Disable log/verbose output to remote consoles */
    AST_OPT_FLAG_MUTE = (1 << 22),
    /*! There is a per-file debug setting */
    AST_OPT_FLAG_DEBUG_FILE = (1 << 23),
    /*! Terminal colors should be adjusted for a light-colored background */
    AST_OPT_FLAG_LIGHT_BACKGROUND = (1 << 25),
    /*! Force black background */
    AST_OPT_FLAG_FORCE_BLACK_BACKGROUND = (1 << 27),
 };

Function Documentation

◆ __ast_context_create()

static struct ast_context* __ast_context_create	(	struct ast_context **	extcontexts,
		const char *	name,
		const char *	registrar,
		int	existsokay
	)

static

Definition at line 4708 of file extconf.c.

References ast_calloc, ast_log(), ast_mutex_init(), ast_rwlock_init(), ast_unlock_contexts(), ast_verbose(), ast_wrlock_contexts(), contexts, ast_context::ignorepats, ast_context::includes, ast_context::lock, LOG_DEBUG, LOG_WARNING, ast_context::macrolock, ast_context::name, ast_context::next, NULL, registrar, ast_context::registrar, ast_context::root, tmp(), and VERBOSE_PREFIX_3.

Referenced by ast_context_find_or_create(), and localized_context_find_or_create().

 {
    struct ast_context *tmp, **loc_contexts;
    int length = sizeof(struct ast_context) + strlen(name) + 1;
 
    if (!extcontexts) {
       ast_wrlock_contexts();
       loc_contexts = &contexts;
    } else
       loc_contexts = extcontexts;
 
    for (tmp = *loc_contexts; tmp; tmp = tmp->next) {
       if (!strcasecmp(tmp->name, name)) {
          if (!existsokay) {
             ast_log(LOG_WARNING, "Tried to register context '%s', already in use\n", name);
             tmp = NULL;
          }
          if (!extcontexts)
             ast_unlock_contexts();
          return tmp;
       }
    }
    if ((tmp = ast_calloc(1, length))) {
       ast_rwlock_init(&tmp->lock);
       ast_mutex_init(&tmp->macrolock);
       strcpy(tmp->name, name);
       tmp->root = NULL;
       tmp->registrar = registrar;
       tmp->next = *loc_contexts;
       tmp->includes = NULL;
       tmp->ignorepats = NULL;
       *loc_contexts = tmp;
       if (option_debug)
          ast_log(LOG_DEBUG, "Registered context '%s'\n", tmp->name);
       if (option_verbose > 2)
          ast_verbose( VERBOSE_PREFIX_3 "Registered extension context '%s'\n", tmp->name);
    }
 
    if (!extcontexts)
       ast_unlock_contexts();
    return tmp;
 }

◆ __ast_context_destroy()

static void __ast_context_destroy	(	struct ast_context *	con,
		const char *	registrar
	)

static

Definition at line 5504 of file extconf.c.

References AST_LIST_REMOVE_HEAD, ast_log(), ast_rwlock_destroy(), ast_unlock_context(), ast_wrlock_context(), destroy_exten(), el, free(), localized_context_destroy(), LOG_DEBUG, ast_context::name, ast_include::next, ast_ignorepat::next, ast_exten::next, ast_context::next, NULL, ast_exten::peer, and tmp().

Referenced by ast_merge_contexts_and_delete(), and localized_context_destroy().

 {
    struct ast_context *tmp, *tmpl=NULL;
    struct ast_include *tmpi;
    struct ast_sw *sw;
    struct ast_exten *e, *el, *en;
    struct ast_ignorepat *ipi;
 
    for (tmp = contexts; tmp; ) {
       struct ast_context *next;  /* next starting point */
       for (; tmp; tmpl = tmp, tmp = tmp->next) {
          if (option_debug)
             ast_log(LOG_DEBUG, "check ctx %s %s\n", tmp->name, tmp->registrar);
          if ( (!registrar || !strcasecmp(registrar, tmp->registrar)) &&
               (!con || !strcasecmp(tmp->name, con->name)) )
             break;   /* found it */
       }
       if (!tmp)   /* not found, we are done */
          break;
       ast_wrlock_context(tmp);
       if (option_debug)
          ast_log(LOG_DEBUG, "delete ctx %s %s\n", tmp->name, tmp->registrar);
       next = tmp->next;
       if (tmpl)
          tmpl->next = next;
       else
          contexts = next;
       /* Okay, now we're safe to let it go -- in a sense, we were
          ready to let it go as soon as we locked it. */
       ast_unlock_context(tmp);
       for (tmpi = tmp->includes; tmpi; ) { /* Free includes */
          struct ast_include *tmpil = tmpi;
          tmpi = tmpi->next;
          free(tmpil);
       }
       for (ipi = tmp->ignorepats; ipi; ) { /* Free ignorepats */
          struct ast_ignorepat *ipl = ipi;
          ipi = ipi->next;
          free(ipl);
       }
       while ((sw = AST_LIST_REMOVE_HEAD(&tmp->alts, list)))
          free(sw);
       for (e = tmp->root; e;) {
          for (en = e->peer; en;) {
             el = en;
             en = en->peer;
             destroy_exten(el);
          }
          el = e;
          e = e->next;
          destroy_exten(el);
       }
       ast_rwlock_destroy(&tmp->lock);
       free(tmp);
       /* if we have a specific match, we are done, otherwise continue */
       tmp = con ? NULL : next;
    }
 }

◆ _extension_match_core()

static int _extension_match_core	(	const char *	pattern,
		const char *	data,
		enum ext_match_t	mode
	)

static

Definition at line 4193 of file extconf.c.

References ast_log(), E_MATCH, E_MATCH_MASK, E_MATCHMORE, end, LOG_WARNING, and NULL.

Referenced by extension_match_core().

 {
    mode &= E_MATCH_MASK;   /* only consider the relevant bits */
 
    if ( (mode == E_MATCH) && (pattern[0] == '_') && (strcasecmp(pattern,data)==0) ) /* note: if this test is left out, then _x. will not match _x. !!! */
       return 1;
 
    if (pattern[0] != '_') { /* not a pattern, try exact or partial match */
       int ld = strlen(data), lp = strlen(pattern);
 
       if (lp < ld)      /* pattern too short, cannot match */
          return 0;
       /* depending on the mode, accept full or partial match or both */
       if (mode == E_MATCH)
          return !strcmp(pattern, data); /* 1 on match, 0 on fail */
       if (ld == 0 || !strncasecmp(pattern, data, ld)) /* partial or full match */
          return (mode == E_MATCHMORE) ? lp > ld : 1; /* XXX should consider '!' and '/' ? */
       else
          return 0;
    }
    pattern++; /* skip leading _ */
    /*
     * XXX below we stop at '/' which is a separator for the CID info. However we should
     * not store '/' in the pattern at all. When we insure it, we can remove the checks.
     */
    while (*data && *pattern && *pattern != '/') {
       const char *end;
 
       if (*data == '-') { /* skip '-' in data (just a separator) */
          data++;
          continue;
       }
       switch (toupper(*pattern)) {
       case '[':   /* a range */
          end = strchr(pattern+1, ']'); /* XXX should deal with escapes ? */
          if (end == NULL) {
             ast_log(LOG_WARNING, "Wrong usage of [] in the extension\n");
             return 0;   /* unconditional failure */
          }
          for (pattern++; pattern != end; pattern++) {
             if (pattern+2 < end && pattern[1] == '-') { /* this is a range */
                if (*data >= pattern[0] && *data <= pattern[2])
                   break;   /* match found */
                else {
                   pattern += 2; /* skip a total of 3 chars */
                   continue;
                }
             } else if (*data == pattern[0])
                break;   /* match found */
          }
          if (pattern == end)
             return 0;
          pattern = end; /* skip and continue */
          break;
       case 'N':
          if (*data < '2' || *data > '9')
             return 0;
          break;
       case 'X':
          if (*data < '0' || *data > '9')
             return 0;
          break;
       case 'Z':
          if (*data < '1' || *data > '9')
             return 0;
          break;
       case '.':   /* Must match, even with more digits */
          return 1;
       case '!':   /* Early match */
          return 2;
       case ' ':
       case '-':   /* Ignore these in patterns */
          data--; /* compensate the final data++ */
          break;
       default:
          if (*data != *pattern)
             return 0;
       }
       data++;
       pattern++;
    }
    if (*data)        /* data longer than pattern, no match */
       return 0;
    /*
     * match so far, but ran off the end of the data.
     * Depending on what is next, determine match or not.
     */
    if (*pattern == '\0' || *pattern == '/')  /* exact match */
       return (mode == E_MATCHMORE) ? 0 : 1;  /* this is a failure for E_MATCHMORE */
    else if (*pattern == '!')        /* early match */
       return 2;
    else                 /* partial match */
       return (mode == E_MATCH) ? 0 : 1;   /* this is a failure for E_MATCH */
 }

◆ _null_sig_handler()

static void _null_sig_handler ( int sig )

static

NULL handler so we can collect the child exit status.

Definition at line 789 of file extconf.c.

 {
 
 }

◆ add_pri()

static int add_pri	(	struct ast_context *	con,
		struct ast_exten *	tmp,
		struct ast_exten *	el,
		struct ast_exten *	e,
		int	replace
	)

static

add the extension in the priority chain. returns 0 on success, -1 on failure

Definition at line 3677 of file extconf.c.

References ast_add_hint(), ast_change_hint(), ast_log(), ast_exten::data, ast_exten::datad, ast_exten::exten, free(), LOG_WARNING, ast_context::name, ast_exten::next, NULL, ast_exten::peer, ast_exten::priority, PRIORITY_HINT, ast_context::root, and tmp().

Referenced by ast_add_extension2().

 {
    struct ast_exten *ep;
 
    for (ep = NULL; e ; ep = e, e = e->peer) {
       if (e->priority >= tmp->priority)
          break;
    }
    if (!e) {   /* go at the end, and ep is surely set because the list is not empty */
       ep->peer = tmp;
       return 0;   /* success */
    }
    if (e->priority == tmp->priority) {
       /* Can't have something exactly the same.  Is this a
          replacement?  If so, replace, otherwise, bonk. */
       if (!replace) {
          ast_log(LOG_WARNING, "Unable to register extension '%s', priority %d in '%s', already in use\n", tmp->exten, tmp->priority, con->name);
          tmp->datad(tmp->data);
          free(tmp);
          return -1;
       }
       /* we are replacing e, so copy the link fields and then update
        * whoever pointed to e to point to us
        */
       tmp->next = e->next; /* not meaningful if we are not first in the peer list */
       tmp->peer = e->peer; /* always meaningful */
       if (ep)        /* We're in the peer list, just insert ourselves */
          ep->peer = tmp;
       else if (el)      /* We're the first extension. Take over e's functions */
          el->next = tmp;
       else        /* We're the very first extension.  */
          con->root = tmp;
       if (tmp->priority == PRIORITY_HINT)
          ast_change_hint(e,tmp);
       /* Destroy the old one */
       e->datad(e->data);
       free(e);
    } else { /* Slip ourselves in just before e */
       tmp->peer = e;
       tmp->next = e->next; /* extension chain, or NULL if e is not the first extension */
       if (ep)        /* Easy enough, we're just in the peer list */
          ep->peer = tmp;
       else {         /* we are the first in some peer list, so link in the ext list */
          if (el)
             el->next = tmp;   /* in the middle... */
          else
             con->root = tmp; /* ... or at the head */
          e->next = NULL;   /* e is no more at the head, so e->next must be reset */
       }
       /* And immediately return success. */
       if (tmp->priority == PRIORITY_HINT)
           ast_add_hint(tmp);
    }
    return 0;
 }

◆ ALLOC_COMMENT()

static struct ast_comment* ALLOC_COMMENT ( const char * buffer )

static

Definition at line 877 of file extconf.c.

References ast_calloc, ast_comment::cmt, ast_config_map::next, and ast_channel::x.

Referenced by process_text_line().

 {
    struct ast_comment *x = ast_calloc(1,sizeof(struct ast_comment)+strlen(buffer)+1);
    strcpy(x->cmt, buffer);
    return x;
 }

◆ ast_add_extension2()

static int ast_add_extension2	(	struct ast_context *	con,
		int	replace,
		const char *	extension,
		int	priority,
		const char *	label,
		const char *	callerid,
		const char *	application,
		void *	data,
		void()(void )	datad,
		const char *	registrar
	)

static

Main interface to add extensions to the list for out context.

We sort extensions in order of matching preference, so that we can stop the search as soon as we find a suitable match. This ordering also takes care of wildcards such as '.' (meaning "one or more of any character") and '!' (which is 'earlymatch', meaning "zero or more of any character" but also impacts the return value from CANMATCH and EARLYMATCH.

The extension match rules defined in the devmeeting 2006.05.05 are quite simple: WE SELECT THE LONGEST MATCH. In detail, "longest" means the number of matched characters in the extension. In case of ties (e.g. _XXX and 333) in the length of a pattern, we give priority to entries with the smallest cardinality (e.g, [5-9] comes before [2-8] before the former has only 5 elements, while the latter has 7, etc. In case of same cardinality, the first element in the range counts. If we still have a tie, any final '!' will make this as a possibly less specific pattern.

EBUSY - can't lock EEXIST - extension with the same priority exist and no replace is set

Definition at line 4776 of file extconf.c.

References add_pri(), ast_exten::app, ast_add_hint(), ast_calloc, ast_log(), ast_verbose(), ast_exten::cidmatch, ast_channel::data, ast_exten::data, ast_exten::datad, el, errno, ext_cmp(), ext_strncpy(), ast_exten::exten, ast_exten::label, localized_add_extension2(), LOG_DEBUG, ast_exten::matchcid, ast_context::name, ast_exten::next, NULL, null_datad(), ast_exten::parent, priority, ast_exten::priority, PRIORITY_HINT, registrar, ast_exten::registrar, ast_context::root, ast_exten::stuff, tmp(), and VERBOSE_PREFIX_3.

Referenced by localized_add_extension2(), and pbx_load_config().

 {
    /*
     * Sort extensions (or patterns) according to the rules indicated above.
     * These are implemented by the function ext_cmp()).
     * All priorities for the same ext/pattern/cid are kept in a list,
     * using the 'peer' field  as a link field..
     */
    struct ast_exten *tmp, *e, *el = NULL;
    int res;
    int length;
    char *p;
 
    /* if we are adding a hint, and there are global variables, and the hint
       contains variable references, then expand them --- NOT In this situation!!!
    */
 
    length = sizeof(struct ast_exten);
    length += strlen(extension) + 1;
    length += strlen(application) + 1;
    if (label)
       length += strlen(label) + 1;
    if (callerid)
       length += strlen(callerid) + 1;
    else
       length ++;  /* just the '\0' */
 
    /* Be optimistic:  Build the extension structure first */
    if (datad == NULL)
       datad = null_datad;
    if (!(tmp = ast_calloc(1, length)))
       return -1;
 
    /* use p as dst in assignments, as the fields are const char * */
    p = tmp->stuff;
    if (label) {
       tmp->label = p;
       strcpy(p, label);
       p += strlen(label) + 1;
    }
    tmp->exten = p;
    p += ext_strncpy(p, extension, strlen(extension) + 1) + 1;
    tmp->priority = priority;
    tmp->cidmatch = p;   /* but use p for assignments below */
    if (callerid) {
       p += ext_strncpy(p, callerid, strlen(callerid) + 1) + 1;
       tmp->matchcid = 1;
    } else {
       *p++ = '\0';
       tmp->matchcid = 0;
    }
    tmp->app = p;
    strcpy(p, application);
    tmp->parent = con;
    tmp->data = data;
    tmp->datad = datad;
    tmp->registrar = registrar;
 
    res = 0; /* some compilers will think it is uninitialized otherwise */
    for (e = con->root; e; el = e, e = e->next) {   /* scan the extension list */
       res = ext_cmp(e->exten, extension);
       if (res == 0) { /* extension match, now look at cidmatch */
          if (!e->matchcid && !tmp->matchcid)
             res = 0;
          else if (tmp->matchcid && !e->matchcid)
             res = 1;
          else if (e->matchcid && !tmp->matchcid)
             res = -1;
          else
             res = strcasecmp(e->cidmatch, tmp->cidmatch);
       }
       if (res >= 0)
          break;
    }
    if (e && res == 0) { /* exact match, insert in the pri chain */
       res = add_pri(con, tmp, el, e, replace);
       if (res < 0) {
          errno = EEXIST;   /* XXX do we care ? */
          return 0; /* XXX should we return -1 maybe ? */
       }
    } else {
       /*
        * not an exact match, this is the first entry with this pattern,
        * so insert in the main list right before 'e' (if any)
        */
       tmp->next = e;
       if (el)
          el->next = tmp;
       else
          con->root = tmp;
       if (tmp->priority == PRIORITY_HINT)
          ast_add_hint(tmp);
    }
    if (option_debug) {
       if (tmp->matchcid) {
          ast_log(LOG_DEBUG, "Added extension '%s' priority %d (CID match '%s') to %s\n",
             tmp->exten, tmp->priority, tmp->cidmatch, con->name);
       } else {
          ast_log(LOG_DEBUG, "Added extension '%s' priority %d to %s\n",
             tmp->exten, tmp->priority, con->name);
       }
    }
    if (option_verbose > 2) {
       if (tmp->matchcid) {
          ast_verbose( VERBOSE_PREFIX_3 "Added extension '%s' priority %d (CID match '%s')to %s\n",
             tmp->exten, tmp->priority, tmp->cidmatch, con->name);
       } else {
          ast_verbose( VERBOSE_PREFIX_3 "Added extension '%s' priority %d to %s\n",
             tmp->exten, tmp->priority, con->name);
       }
    }
    return 0;
 }

◆ ast_add_hint()

static int ast_add_hint ( struct ast_exten * e )

static

ast_add_hint: Add hint to hint list, check initial extension state

Definition at line 3644 of file extconf.c.

References ast_calloc, ast_get_extension_app(), ast_get_extension_name(), ast_log(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, ast_hint::exten, and LOG_DEBUG.

Referenced by add_pri(), and ast_add_extension2().

 {
    struct ast_hint *hint;
 
    if (!e)
       return -1;
 
 
    /* Search if hint exists, do nothing */
    AST_RWLIST_TRAVERSE(&hints, hint, list) {
       if (hint->exten == e) {
          if (option_debug > 1)
             ast_log(LOG_DEBUG, "HINTS: Not re-adding existing hint %s: %s\n", ast_get_extension_name(e), ast_get_extension_app(e));
          return -1;
       }
    }
 
    if (option_debug > 1)
       ast_log(LOG_DEBUG, "HINTS: Adding hint %s: %s\n", ast_get_extension_name(e), ast_get_extension_app(e));
 
    if (!(hint = ast_calloc(1, sizeof(*hint)))) {
       return -1;
    }
    /* Initialize and insert new item at the top */
    hint->exten = e;
    AST_RWLIST_INSERT_HEAD(&hints, hint, list);
 
    return 0;
 }

◆ ast_app_separate_args()

static unsigned int ast_app_separate_args	(	char *	buf,
		char	delim,
		char **	array,
		int	arraylen
	)

static

Definition at line 2488 of file extconf.c.

References buf, paren, and quote().

Referenced by pbx_builtin_setvar().

 {
    int argc;
    char *scan;
    int paren = 0, quote = 0;
 
    if (!buf || !array || !arraylen)
       return 0;
 
    memset(array, 0, arraylen * sizeof(*array));
 
    scan = buf;
 
    for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
       array[argc] = scan;
       for (; *scan; scan++) {
          if (*scan == '(')
             paren++;
          else if (*scan == ')') {
             if (paren)
                paren--;
          } else if (*scan == '"' && delim != '"') {
             quote = quote ? 0 : 1;
             /* Remove quote character from argument */
             memmove(scan, scan + 1, strlen(scan));
             scan--;
          } else if (*scan == '\\') {
             /* Literal character, don't parse */
             memmove(scan, scan + 1, strlen(scan));
          } else if ((*scan == delim) && !paren && !quote) {
             *scan++ = '\0';
             break;
          }
       }
    }
 
    if (*scan)
       array[argc++] = scan;
 
    return argc;
 }

◆ ast_atomic_dec_and_test()

int ast_atomic_dec_and_test ( volatile int * p )

decrement *p by 1 and return true if the variable has reached 0. Useful e.g. to check if a refcount has reached 0.

Definition at line 634 of file extconf.c.

References a, ast_atomic_fetchadd_int(), ast_channel_lock, ast_channel_trylock, ast_channel_unlock, AST_INLINE_API, and SIZEOF_INT.

Referenced by ast_atomic_fetchadd_int().

637 {

◆ ast_atomic_fetchadd_int()

int ast_atomic_fetchadd_int	(	volatile int *	p,
		int	v
	)

Atomically add v to *p and return * the previous value of *p. This can be used to handle reference counts, and the return value can be used to generate unique identifiers.

Definition at line 593 of file extconf.c.

References ast_atomic_dec_and_test(), AST_INLINE_API, HAVE_GCC_ATOMICS, and SIZEOF_INT.

Referenced by ast_atomic_dec_and_test().

596 {

◆ ast_build_timing()

int ast_build_timing	(	struct ast_timing *	i,
		const char *	info_in
	)

Construct a timing bitmap, for use in time-based conditionals.

Parameters

i	Pointer to an ast_timing structure.
info	Standard string containing a timerange, weekday range, monthday range, and month range, as well as an optional timezone.

Return values

Returns 1 on success or 0 on failure.

/brief Build timing

/param i info /param info_in

Definition at line 3808 of file extconf.c.

References ast_strdup, ast_strdupa, ast_strlen_zero(), ast_timing::daymask, ast_timing::dowmask, get_range(), get_timerange(), sip_to_pjsip::info(), ast_timing::monthmask, NULL, strsep(), and ast_timing::timezone.

Referenced by ast_context_add_include2(), iftime(), include_alloc(), pbx_builtin_execiftime(), and pbx_builtin_gotoiftime().

 {
    char *info;
    int j, num_fields, last_sep = -1;
 
    i->timezone = NULL;
 
    /* Check for empty just in case */
    if (ast_strlen_zero(info_in)) {
       return 0;
    }
 
    /* make a copy just in case we were passed a static string */
    info = ast_strdupa(info_in);
 
    /* count the number of fields in the timespec */
    for (j = 0, num_fields = 1; info[j] != '\0'; j++) {
       if (info[j] == ',') {
          last_sep = j;
          num_fields++;
       }
    }
 
    /* save the timezone, if it is specified */
    if (num_fields == 5) {
       i->timezone = ast_strdup(info + last_sep + 1);
    }
 
    /* Assume everything except time */
    i->monthmask = 0xfff;   /* 12 bits */
    i->daymask = 0x7fffffffU; /* 31 bits */
    i->dowmask = 0x7f; /* 7 bits */
    /* on each call, use strsep() to move info to the next argument */
    get_timerange(i, strsep(&info, "|,"));
    if (info)
       i->dowmask = get_range(strsep(&info, "|,"), 7, days, "day of week");
    if (info)
       i->daymask = get_range(strsep(&info, "|,"), 31, NULL, "day");
    if (info)
       i->monthmask = get_range(strsep(&info, "|,"), 12, months, "month");
    return 1;
 }

◆ ast_category_append()

static void ast_category_append	(	struct ast_config *	config,
		struct ast_category *	category
	)

static

Definition at line 2835 of file extconf.c.

References ast_category_destroy(), ast_config::current, ast_config::last, ast_category::next, and ast_config::root.

Referenced by inherit_category(), and process_text_line().

 {
    if (config->last)
       config->last->next = category;
    else
       config->root = category;
    config->last = category;
    config->current = category;
 }

◆ ast_category_browse()

static char* ast_category_browse	(	struct ast_config *	config,
		const char *	prev
	)

static

Definition at line 3328 of file extconf.c.

References ast_config_set_current_category(), ast_config::last_browse, ast_category::name, ast_category::next, next_available_category(), NULL, and ast_config::root.

Referenced by pbx_load_config().

 {
    struct ast_category *cat = NULL;
 
    if (prev && config->last_browse && (config->last_browse->name == prev))
       cat = config->last_browse->next;
    else if (!prev && config->root)
       cat = config->root;
    else if (prev) {
       for (cat = config->root; cat; cat = cat->next) {
          if (cat->name == prev) {
             cat = cat->next;
             break;
          }
       }
       if (!cat) {
          for (cat = config->root; cat; cat = cat->next) {
             if (!strcasecmp(cat->name, prev)) {
                cat = cat->next;
                break;
             }
          }
       }
    }
 
    if (cat)
       cat = next_available_category(cat);
 
    config->last_browse = cat;
    return (cat) ? cat->name : NULL;
 }

◆ ast_category_destroy()

static void ast_category_destroy ( struct ast_category * cat )

static

Definition at line 2847 of file extconf.c.

References ast_variables_destroy(), ast_category::file, free(), and ast_category::root.

Referenced by ast_category_append(), and process_text_line().

 {
    ast_variables_destroy(cat->root);
    if (cat->file)
       free(cat->file);
 
    free(cat);
 }

◆ ast_category_get()

static struct ast_category* ast_category_get	(	const struct ast_config *	config,
		const char *	category_name
	)

static

Definition at line 1211 of file extconf.c.

References category_get().

Referenced by ast_variable_browse().

 {
    return category_get(config, category_name, 0);
 }

◆ ast_category_new()

static struct ast_category* ast_category_new	(	const char *	name,
		const char *	in_file,
		int	lineno
	)

static

Definition at line 2790 of file extconf.c.

References ast_calloc, ast_copy_string(), ast_category::file, ast_category::lineno, localized_category_get(), ast_category::name, and strdup.

Referenced by ast_config_get_current_category(), and process_text_line().

 {
    struct ast_category *category;
 
    if ((category = ast_calloc(1, sizeof(*category))))
       ast_copy_string(category->name, name, sizeof(category->name));
    category->file = strdup(in_file);
    category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
    return category;
 }

◆ ast_change_hint()

static int ast_change_hint	(	struct ast_exten *	oe,
		struct ast_exten *	ne
	)

static

ast_change_hint: Change hint for an extension

Definition at line 3627 of file extconf.c.

References AST_RWLIST_TRAVERSE, and ast_hint::exten.

Referenced by add_pri().

 {
    struct ast_hint *hint;
    int res = -1;
 
    AST_RWLIST_TRAVERSE(&hints, hint, list) {
       if (hint->exten == oe) {
             hint->exten = ne;
          res = 0;
          break;
       }
    }
 
    return res;
 }

◆ ast_check_timing()

int ast_check_timing ( const struct ast_timing * i )

Evaluate a pre-constructed bitmap as to whether the current time falls within the range specified.

Parameters

i	Pointer to an ast_timing structure.

Return values

Returns 1, if the time matches or 0, if the current time falls outside of the specified range.

Definition at line 4002 of file extconf.c.

References AST_RWLIST_TRAVERSE, ast_walk_contexts(), ast_switch::list, ast_switch::name, and pbx_findswitch().

Referenced by ext_strncpy(), iftime(), include_valid(), and pbx_builtin_execiftime().

 {
    /* sorry, but this feature will NOT be available
       in the standalone version */
    return 0;
 }

◆ ast_config_destroy()

static void ast_config_destroy ( struct ast_config * cfg )

static

Definition at line 1290 of file extconf.c.

References ast_includes_destroy(), ast_variables_destroy(), free(), ast_config::includes, ast_category::next, ast_category::root, and ast_config::root.

Referenced by localized_config_load(), localized_config_load_with_comments(), pbx_load_config(), and process_text_line().

 {
    struct ast_category *cat, *catn;
 
    if (!cfg)
       return;
 
    ast_includes_destroy(cfg->includes);
 
    cat = cfg->root;
    while (cat) {
       ast_variables_destroy(cat->root);
       catn = cat;
       cat = cat->next;
       free(catn);
    }
    free(cfg);
 }

◆ ast_config_get_current_category()

struct ast_category* ast_config_get_current_category ( const struct ast_config * cfg )

Retrieve the current category name being built.

API for backend configuration engines while building a configuration set.

Definition at line 2783 of file extconf.c.

References ast_category_new(), ast_config::current, and ast_channel::name.

Referenced by config_curl(), config_odbc(), config_text_file_load(), and find_engine().

 {
    return cfg->current;
 }

◆ ast_config_internal_load()

static struct ast_config * ast_config_internal_load	(	const char *	filename,
		struct ast_config *	cfg,
		int	withcomments,
		const char *	suggested_incl_file
	)

static

Definition at line 2864 of file extconf.c.

References ast_log(), db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, NULL, result, table, and text_file_engine.

Referenced by localized_config_load(), localized_config_load_with_comments(), and process_text_line().

 {
    char db[256];
    char table[256];
    struct ast_config_engine *loader = &text_file_engine;
    struct ast_config *result;
 
    if (cfg->include_level == cfg->max_include_level) {
       ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
       return NULL;
    }
 
    cfg->include_level++;
    /*  silence is golden!
       ast_log(LOG_WARNING, "internal loading file %s level=%d\n", filename, cfg->include_level);
    */
 
    if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) {
       struct ast_config_engine *eng;
 
       eng = find_engine(filename, db, sizeof(db), table, sizeof(table));
 
 
       if (eng && eng->load_func) {
          loader = eng;
       } else {
          eng = find_engine("global", db, sizeof(db), table, sizeof(table));
          if (eng && eng->load_func)
             loader = eng;
       }
    }
 
    result = loader->load_func(db, table, filename, cfg, withcomments, suggested_incl_file);
    /* silence is golden
       ast_log(LOG_WARNING, "finished internal loading file %s level=%d\n", filename, cfg->include_level);
    */
 
    if (result)
       result->include_level--;
 
    return result;
 }

◆ ast_config_new()

static struct ast_config* ast_config_new ( void )

static

Definition at line 3276 of file extconf.c.

References ast_calloc, config, localized_config_load(), ast_config::max_include_level, and MAX_INCLUDE_LEVEL.

Referenced by config_text_file_load(), localized_config_load(), and localized_config_load_with_comments().

 {
    struct ast_config *config;
 
    if ((config = ast_calloc(1, sizeof(*config))))
       config->max_include_level = MAX_INCLUDE_LEVEL;
    return config;
 }

◆ ast_config_set_current_category()

void ast_config_set_current_category	(	struct ast_config *	cfg,
		const struct ast_category *	cat
	)

Set the category within the configuration as being current.

API for backend configuration engines while building a configuration set.

Definition at line 3364 of file extconf.c.

References ast_config::current.

Referenced by ast_category_browse().

 {
    /* cast below is just to silence compiler warning about dropping "const" */
    cfg->current = (struct ast_category *) cat;
 }

◆ 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 1314 of file asterisk.c.

References ast_network_puts().

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

◆ ast_context_add_ignorepat2()

static int ast_context_add_ignorepat2	(	struct ast_context *	con,
		const char *	value,
		const char *	registrar
	)

static

Definition at line 4569 of file extconf.c.

References ast_calloc, errno, ast_context::ignorepats, localized_context_add_ignorepat2(), ast_ignorepat::next, NULL, ast_ignorepat::pattern, ast_ignorepat::registrar, and registrar.

Referenced by localized_context_add_ignorepat2(), localized_context_add_include2(), and pbx_load_config().

 {
    struct ast_ignorepat *ignorepat, *ignorepatc, *ignorepatl = NULL;
    int length;
    length = sizeof(struct ast_ignorepat);
    length += strlen(value) + 1;
    if (!(ignorepat = ast_calloc(1, length)))
       return -1;
    /* The cast to char * is because we need to write the initial value.
     * The field is not supposed to be modified otherwise
     */
    strcpy((char *)ignorepat->pattern, value);
    ignorepat->next = NULL;
    ignorepat->registrar = registrar;
    for (ignorepatc = con->ignorepats; ignorepatc; ignorepatc = ignorepatc->next) {
       ignorepatl = ignorepatc;
       if (!strcasecmp(ignorepatc->pattern, value)) {
          /* Already there */
          errno = EEXIST;
          return -1;
       }
    }
    if (ignorepatl)
       ignorepatl->next = ignorepat;
    else
       con->ignorepats = ignorepat;
    return 0;
 
 }

◆ ast_context_add_include2()

static int ast_context_add_include2	(	struct ast_context *	con,
		const char *	value,
		const char *	registrar
	)

static

Definition at line 4503 of file extconf.c.

References ast_build_timing(), ast_calloc, ast_get_context_name(), ast_verbose(), c, errno, free(), ast_include::hastime, ast_context::includes, localized_context_add_include2(), ast_include::name, ast_include::next, NULL, ast_include::registrar, registrar, ast_include::rname, ast_include::stuff, ast_include::timing, and VERBOSE_PREFIX_3.

Referenced by ast_get_context_name(), localized_context_add_include2(), and pbx_load_config().

 {
    struct ast_include *new_include;
    char *c;
    struct ast_include *i, *il = NULL; /* include, include_last */
    int length;
    char *p;
 
    length = sizeof(struct ast_include);
    length += 2 * (strlen(value) + 1);
 
    /* allocate new include structure ... */
    if (!(new_include = ast_calloc(1, length)))
       return -1;
    /* Fill in this structure. Use 'p' for assignments, as the fields
     * in the structure are 'const char *'
     */
    p = new_include->stuff;
    new_include->name = p;
    strcpy(p, value);
    p += strlen(value) + 1;
    new_include->rname = p;
    strcpy(p, value);
    /* Strip off timing info, and process if it is there */
    if ( (c = strchr(p, '|')) ) {
       *c++ = '\0';
       new_include->hastime = ast_build_timing(&(new_include->timing), c);
    }
    new_include->next      = NULL;
    new_include->registrar = registrar;
 
 
    /* ... go to last include and check if context is already included too... */
    for (i = con->includes; i; i = i->next) {
       if (!strcasecmp(i->name, new_include->name)) {
          free(new_include);
          errno = EEXIST;
          return -1;
       }
       il = i;
    }
 
    /* ... include new context into context list, unlock, return */
    if (il)
       il->next = new_include;
    else
       con->includes = new_include;
    if (option_verbose > 2)
       ast_verbose(VERBOSE_PREFIX_3 "Including context '%s' in context '%s'\n", new_include->name, ast_get_context_name(con));
 
    return 0;
 }

◆ ast_context_add_switch2()

static int ast_context_add_switch2	(	struct ast_context *	con,
		const char *	value,
		const char *	data,
		int	eval,
		const char *	registrar
	)

static

Definition at line 4641 of file extconf.c.

References ast_context::alts, ast_calloc, ast_get_context_name(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_verbose(), ast_sw::data, errno, ast_sw::eval, free(), ast_sw::list, localized_context_add_switch2(), ast_sw::name, ast_sw::registrar, registrar, ast_sw::stuff, SWITCH_DATA_LENGTH, ast_sw::tmpdata, and VERBOSE_PREFIX_3.

Referenced by ast_unlock_context(), localized_context_add_switch2(), and pbx_load_config().

 {
    struct ast_sw *new_sw;
    struct ast_sw *i;
    int length;
    char *p;
 
    length = sizeof(struct ast_sw);
    length += strlen(value) + 1;
    if (data)
       length += strlen(data);
    length++;
    if (eval) {
       /* Create buffer for evaluation of variables */
       length += SWITCH_DATA_LENGTH;
       length++;
    }
 
    /* allocate new sw structure ... */
    if (!(new_sw = ast_calloc(1, length)))
       return -1;
    /* ... fill in this structure ... */
    p = new_sw->stuff;
    new_sw->name = p;
    strcpy(new_sw->name, value);
    p += strlen(value) + 1;
    new_sw->data = p;
    if (data) {
       strcpy(new_sw->data, data);
       p += strlen(data) + 1;
    } else {
       strcpy(new_sw->data, "");
       p++;
    }
    if (eval)
       new_sw->tmpdata = p;
    new_sw->eval     = eval;
    new_sw->registrar = registrar;
 
    /* ... go to last sw and check if context is already swd too... */
    AST_LIST_TRAVERSE(&con->alts, i, list) {
       if (!strcasecmp(i->name, new_sw->name) && !strcasecmp(i->data, new_sw->data)) {
          free(new_sw);
          errno = EEXIST;
          return -1;
       }
    }
 
    /* ... sw new context into context list, unlock, return */
    AST_LIST_INSERT_TAIL(&con->alts, new_sw, list);
 
    if (option_verbose > 2)
       ast_verbose(VERBOSE_PREFIX_3 "Including switch '%s/%s' in context '%s'\n", new_sw->name, new_sw->data, ast_get_context_name(con));
 
    return 0;
 }

◆ ast_context_find()

static struct ast_context* ast_context_find ( const char * name )

static

Definition at line 4174 of file extconf.c.

References ast_walk_contexts(), ast_context::name, NULL, and tmp().

Referenced by ast_context_switches_count(), and ast_context_verify_includes().

 {
    struct ast_context *tmp = NULL;
    while ( (tmp = ast_walk_contexts(tmp)) ) {
       if (!name || !strcasecmp(name, tmp->name))
          break;
    }
    return tmp;
 }

◆ ast_context_find_or_create()

static struct ast_context* ast_context_find_or_create	(	struct ast_context **	extcontexts,
		void *	tab,
		const char *	name,
		const char *	registrar
	)

static

Definition at line 4983 of file extconf.c.

References __ast_context_create(), and localized_context_find_or_create().

Referenced by pbx_load_config().

 {
    return __ast_context_create(extcontexts, name, registrar, 1);
 }

◆ ast_context_ignorepats_count()

int ast_context_ignorepats_count ( struct ast_context * con )

Definition at line 4125 of file extconf.c.

References ast_walk_context_ignorepats(), ast_walk_context_switches(), c, and NULL.

Referenced by ast_walk_context_ignorepats().

 {
    int c = 0;
    struct ast_ignorepat *ip = NULL;
 
    while ((ip = ast_walk_context_ignorepats(con, ip))) {
       c++;
    }
 
    return c;
 }

◆ ast_context_includes_count()

int ast_context_includes_count ( struct ast_context * con )

Definition at line 4092 of file extconf.c.

References ast_walk_context_includes(), c, localized_walk_context_includes(), and NULL.

Referenced by ast_walk_context_includes().

 {
    int c = 0;
    struct ast_include *inc = NULL;
 
    while ((inc = ast_walk_context_includes(con, inc))) {
       c++;
    }
 
    return c;
 }

◆ ast_context_switches_count()

int ast_context_switches_count ( struct ast_context * con )

Definition at line 4159 of file extconf.c.

References ast_context_find(), ast_walk_context_switches(), c, and NULL.

Referenced by localized_walk_context_switches().

 {
    int c = 0;
    struct ast_sw *sw = NULL;
 
    while ((sw = ast_walk_context_switches(con, sw))) {
       c++;
    }
 
    return c;
 }

◆ ast_context_verify_includes()

static int ast_context_verify_includes ( struct ast_context * con )

static

Definition at line 5623 of file extconf.c.

References ast_context_find(), ast_get_context_name(), ast_log(), ast_walk_context_includes(), localized_context_verify_includes(), LOG_WARNING, NULL, and ast_include::rname.

Referenced by localized_context_verify_includes(), and localized_pbx_load_module().

 {
    struct ast_include *inc = NULL;
    int res = 0;
 
    while ( (inc = ast_walk_context_includes(con, inc)) )
       if (!ast_context_find(inc->rname)) {
          res = -1;
          if (strcasecmp(inc->rname,"parkedcalls")!=0)
             ast_log(LOG_WARNING, "Context '%s' tries to include the nonexistent context '%s'\n",
                   ast_get_context_name(con), inc->rname);
       }
    return res;
 }

◆ ast_copy_string()

void ast_copy_string	(	char *	dst,
		const char *	src,
		size_t	size
	)

Definition at line 970 of file extconf.c.

Referenced by ast_category_new(), ast_var_assign(), ast_variable_new(), config_text_file_load(), find_engine(), gen_header(), pbx_load_config(), pbx_retrieve_variable(), pbx_substitute_variables_helper_full(), set_fn(), and substring().

974 {

◆ ast_extension_match()

static int ast_extension_match	(	const char *	pattern,
		const char *	data
	)

static

Definition at line 4297 of file extconf.c.

References E_MATCH, and extension_match_core().

Referenced by extension_match_core(), and matchcid().

 {
    return extension_match_core(pattern, data, E_MATCH);
 }

◆ ast_findlabel_extension2()

static int ast_findlabel_extension2	(	struct ast_channel *	c,
		struct ast_context *	con,
		const char *	exten,
		const char *	label,
		const char *	callerid
	)

static

Definition at line 4978 of file extconf.c.

References E_FINDLABEL, NULL, and pbx_extension_helper().

Referenced by pbx_extension_helper(), and pbx_load_config().

 {
    return pbx_extension_helper(c, con, NULL, exten, 0, label, callerid, E_FINDLABEL);
 }

◆ ast_func_read()

static int ast_func_read	(	struct ast_channel *	chan,
		const char *	function,
		char *	workspace,
		size_t	len
	)

static

Definition at line 4996 of file extconf.c.

References ast_log(), and LOG_ERROR.

Referenced by pbx_substitute_variables_helper_full().

 {
    ast_log(LOG_ERROR, "Function %s not registered\n", function);
    return -1;
 }

◆ ast_func_write()

static int ast_func_write	(	struct ast_channel *	chan,
		const char *	function,
		const char *	value
	)

static

Definition at line 2480 of file extconf.c.

Referenced by pbx_builtin_setvar_helper().

 {
 
    /* ast_log(LOG_ERROR, "Function %s not registered\n", function); we are not interested in the details here */
 
    return -1;
 }

◆ ast_get_context_name()

static const char* ast_get_context_name ( struct ast_context * con )

static

Definition at line 4488 of file extconf.c.

References ast_context_add_include2(), ast_context::name, NULL, registrar, and value.

Referenced by ast_context_add_include2(), ast_context_add_switch2(), and ast_context_verify_includes().

 {
    return con ? con->name : NULL;
 }

◆ ast_get_extension_app()

static const char* ast_get_extension_app ( struct ast_exten * e )

static

Definition at line 3614 of file extconf.c.

References ast_exten::app, and NULL.

Referenced by ast_add_hint().

 {
    return e ? e->app : NULL;
 }

◆ ast_get_extension_name()

static const char* ast_get_extension_name ( struct ast_exten * exten )

static

Definition at line 3619 of file extconf.c.

References ast_exten::exten, and NULL.

Referenced by ast_add_hint().

 {
    return exten ? exten->exten : NULL;
 }

◆ ast_include_find()

static struct ast_config_include* ast_include_find	(	struct ast_config *	conf,
		const char *	included_file
	)

static

Definition at line 1164 of file extconf.c.

References ast_variable_append(), ast_config_include::included_file, ast_config::includes, ast_config_include::next, and ast_channel::x.

Referenced by ast_include_new().

 {
    struct ast_config_include *x;
    for (x=conf->includes;x;x=x->next)
    {
       if (strcmp(x->included_file,included_file) == 0)
          return x;
    }
    return 0;
 }

◆ ast_include_new()

static struct ast_config_include* ast_include_new	(	struct ast_config *	conf,
		const char *	from_file,
		const char *	included_file,
		int	is_exec,
		const char *	exec_file,
		int	from_lineno,
		char *	real_included_file_name,
		int	real_included_file_name_size
	)

static

Definition at line 1075 of file extconf.c.

References ast_calloc, ast_include_find(), ast_log(), ast_strdup, ast_strlen_zero(), ast_config_include::exec, ast_config_include::exec_file, ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::included_file, ast_config::includes, ast_config_include::inclusion_count, LOG_WARNING, and ast_config_include::next.

Referenced by process_text_line().

 {
    /* a file should be included ONCE. Otherwise, if one of the instances is changed,
        then all be changed. -- how do we know to include it? -- Handling modified
        instances is possible, I'd have
        to create a new master for each instance. */
    struct ast_config_include *inc;
 
    inc = ast_include_find(conf, included_file);
    if (inc)
    {
       inc->inclusion_count++;
       snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
       ast_log(LOG_WARNING,"'%s', line %d:  Same File included more than once! This data will be saved in %s if saved back to disk.\n", from_file, from_lineno, real_included_file_name);
    } else
       *real_included_file_name = 0;
 
    inc = ast_calloc(1,sizeof(struct ast_config_include));
    inc->include_location_file = ast_strdup(from_file);
    inc->include_location_lineno = from_lineno;
    if (!ast_strlen_zero(real_included_file_name))
       inc->included_file = ast_strdup(real_included_file_name);
    else
       inc->included_file = ast_strdup(included_file);
 
    inc->exec = is_exec;
    if (is_exec)
       inc->exec_file = ast_strdup(exec_file);
 
    /* attach this new struct to the conf struct */
    inc->next = conf->includes;
    conf->includes = inc;
 
    return inc;
 }

◆ ast_includes_destroy()

static void ast_includes_destroy ( struct ast_config_include * incls )

static

Definition at line 1274 of file extconf.c.

References ast_config_include::exec_file, free(), ast_config_include::include_location_file, ast_config_include::included_file, and ast_config_include::next.

Referenced by ast_config_destroy().

 {
    struct ast_config_include *incl,*inclnext;
 
    for (incl=incls; incl; incl = inclnext) {
       inclnext = incl->next;
       if (incl->include_location_file)
          free(incl->include_location_file);
       if (incl->exec_file)
          free(incl->exec_file);
       if (incl->included_file)
          free(incl->included_file);
       free(incl);
    }
 }

◆ ast_log()

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

static

Definition at line 2195 of file extconf.c.

Referenced by __ast_context_create(), __ast_context_destroy(), _extension_match_core(), add_pri(), ast_add_extension2(), ast_add_hint(), ast_config_internal_load(), ast_context_verify_includes(), ast_func_read(), ast_include_new(), ast_merge_contexts_and_delete(), ast_safe_system(), config_text_file_load(), ext_cmp1(), find_engine(), get_range(), get_timerange(), localized_config_text_file_save(), pbx_builtin_setvar(), pbx_extension_helper(), pbx_find_extension(), pbx_load_config(), pbx_substitute_variables_helper_full(), process_text_line(), and tvfix().

 {
    va_list vars;
    va_start(vars,fmt);
 
    printf("LOG: lev:%d file:%s  line:%d func: %s  ",
          level, file, line, function);
    vprintf(fmt, vars);
    fflush(stdout);
    va_end(vars);
 }

◆ ast_log_backtrace()

void ast_log_backtrace ( void )

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

Definition at line 2158 of file logger.c.

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

 {
 #ifdef HAVE_BKTR
    struct ast_bt *bt;
    int i = 0;
    struct ast_vector_string *strings;
 
    if (!(bt = ast_bt_create())) {
       ast_log(LOG_WARNING, "Unable to allocate space for backtrace structure\n");
       return;
    }
 
    if ((strings = ast_bt_get_symbols(bt->addresses, bt->num_frames))) {
       int count = AST_VECTOR_SIZE(strings);
       struct ast_str *buf = ast_str_create(bt->num_frames * 64);
 
       if (buf) {
          ast_str_append(&buf, 0, "Got %d backtrace record%c\n", count - 3, count - 3 != 1 ? 's' : ' ');
          for (i = 3; i < AST_VECTOR_SIZE(strings); i++) {
             ast_str_append(&buf, 0, "#%2d: %s\n", i - 3, AST_VECTOR_GET(strings, i));
          }
          ast_log_safe(__LOG_ERROR, NULL, 0, NULL, "%s\n", ast_str_buffer(buf));
          ast_free(buf);
       }
 
       ast_bt_free_symbols(strings);
    } else {
       ast_log(LOG_ERROR, "Could not allocate memory for backtrace\n");
    }
    ast_bt_destroy(bt);
 #else
    ast_log(LOG_WARNING, "Must run configure with '--with-execinfo' for stack backtraces.\n");
 #endif /* defined(HAVE_BKTR) */
 }

◆ ast_mark_lock_failed()

void ast_mark_lock_failed ( void * lock_addr )

Mark the last lock as failed (trylock)

Definition at line 2314 of file extconf.c.

Referenced by __ast_pthread_mutex_trylock(), __ast_rwlock_tryrdlock(), __ast_rwlock_trywrlock(), and ast_tvsub().

 {
    /* Pretend to do something. */
 }

◆ ast_merge_contexts_and_delete()

static void ast_merge_contexts_and_delete	(	struct ast_context **	extcontexts,
		const char *	registrar
	)

static

Definition at line 5573 of file extconf.c.

References __ast_context_destroy(), ast_log(), ast_unlock_contexts(), ast_wrlock_contexts(), contexts, LOG_DEBUG, LOG_WARNING, ast_context::name, ast_context::next, NULL, ast_context::registrar, and tmp().

Referenced by localized_merge_contexts_and_delete(), and localized_pbx_load_module().

 {
    struct ast_context *tmp, *lasttmp = NULL;
 
    /* it is very important that this function hold the hint list lock _and_ the conlock
       during its operation; not only do we need to ensure that the list of contexts
       and extensions does not change, but also that no hint callbacks (watchers) are
       added or removed during the merge/delete process
 
       in addition, the locks _must_ be taken in this order, because there are already
       other code paths that use this order
    */
    ast_wrlock_contexts();
 
    tmp = *extcontexts;
    if (registrar) {
       /* XXX remove previous contexts from same registrar */
       if (option_debug)
          ast_log(LOG_DEBUG, "must remove any reg %s\n", registrar);
       __ast_context_destroy(NULL,registrar);
       while (tmp) {
          lasttmp = tmp;
          tmp = tmp->next;
       }
    } else {
       /* XXX remove contexts with the same name */
       while (tmp) {
          ast_log(LOG_WARNING, "must remove %s  reg %s\n", tmp->name, tmp->registrar);
          __ast_context_destroy(tmp,tmp->registrar);
          lasttmp = tmp;
          tmp = tmp->next;
       }
    }
    if (lasttmp) {
       lasttmp->next = contexts;
       contexts = *extcontexts;
       *extcontexts = NULL;
    } else
       ast_log(LOG_WARNING, "Requested contexts didn't get merged\n");
 
    ast_unlock_contexts();
 
    return;
 }

◆ ast_mutex_init()

static int ast_mutex_init ( ast_mutex_t * pmutex )

inlinestatic

Definition at line 469 of file extconf.c.

References AST_MUTEX_KIND, and pthread_mutex_init.

Referenced by __ast_context_create().

 {
    pthread_mutexattr_t attr;
 
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
 
    return pthread_mutex_init(pmutex, &attr);
 }

◆ ast_process_quotes_and_slashes()

static char* ast_process_quotes_and_slashes	(	char *	start,
		char	find,
		char	replace_with
	)

static

Definition at line 2219 of file extconf.c.

Referenced by pbx_load_config().

 {
    char *dataPut = start;
    int inEscape = 0;
    int inQuotes = 0;
 
    for (; *start; start++) {
       if (inEscape) {
          *dataPut++ = *start;       /* Always goes verbatim */
          inEscape = 0;
       } else {
          if (*start == '\\') {
             inEscape = 1;      /* Do not copy \ into the data */
          } else if (*start == '\'') {
             inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
          } else {
             /* Replace , with |, unless in quotes */
             *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
          }
       }
    }
    if (start != dataPut)
       *dataPut = 0;
    return dataPut;
 }

◆ ast_queue_log()

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

Definition at line 894 of file logger.c.

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

Referenced by logger_queue_start(), and reload_logger().

 {
    va_list ap;
    struct timeval tv;
    struct ast_tm tm;
    char qlog_msg[8192];
    int qlog_len;
    char time_str[30];
 
    if (!logger_initialized) {
       /* You are too early.  We are not open yet! */
       return;
    }
    if (!queuelog_init) {
       /* We must initialize now since someone is trying to log something. */
       logger_queue_start();
    }
 
    if (ast_check_realtime("queue_log")) {
       tv = ast_tvnow();
       ast_localtime(&tv, &tm, logfiles.queue_log_realtime_use_gmt ? "GMT" : NULL);
       ast_strftime(time_str, sizeof(time_str), "%F %T.%6q", &tm);
       va_start(ap, fmt);
       vsnprintf(qlog_msg, sizeof(qlog_msg), fmt, ap);
       va_end(ap);
       if (logfiles.queue_adaptive_realtime) {
          AST_DECLARE_APP_ARGS(args,
             AST_APP_ARG(data)[5];
          );
          AST_NONSTANDARD_APP_ARGS(args, qlog_msg, '|');
          /* Ensure fields are large enough to receive data */
          ast_realtime_require_field("queue_log",
             "data1", RQ_CHAR, strlen(S_OR(args.data[0], "")),
             "data2", RQ_CHAR, strlen(S_OR(args.data[1], "")),
             "data3", RQ_CHAR, strlen(S_OR(args.data[2], "")),
             "data4", RQ_CHAR, strlen(S_OR(args.data[3], "")),
             "data5", RQ_CHAR, strlen(S_OR(args.data[4], "")),
             SENTINEL);
 
          /* Store the log */
          ast_store_realtime("queue_log", "time", time_str,
             "callid", callid,
             "queuename", queuename,
             "agent", agent,
             "event", event,
             "data1", S_OR(args.data[0], ""),
             "data2", S_OR(args.data[1], ""),
             "data3", S_OR(args.data[2], ""),
             "data4", S_OR(args.data[3], ""),
             "data5", S_OR(args.data[4], ""),
             SENTINEL);
       } else {
          ast_store_realtime("queue_log", "time", time_str,
             "callid", callid,
             "queuename", queuename,
             "agent", agent,
             "event", event,
             "data", qlog_msg,
             SENTINEL);
       }
 
       if (!logfiles.queue_log_to_file) {
          return;
       }
    }
 
    if (qlog) {
       va_start(ap, fmt);
       qlog_len = snprintf(qlog_msg, sizeof(qlog_msg), "%ld|%s|%s|%s|%s|", (long)time(NULL), callid, queuename, agent, event);
       vsnprintf(qlog_msg + qlog_len, sizeof(qlog_msg) - qlog_len, fmt, ap);
       va_end(ap);
       AST_RWLIST_RDLOCK(&logchannels);
       if (qlog) {
          fprintf(qlog, "%s\n", qlog_msg);
          fflush(qlog);
       }
       AST_RWLIST_UNLOCK(&logchannels);
    }
 }

◆ ast_remove_hint()

static int ast_remove_hint ( struct ast_exten * e )

static

ast_remove_hint: Remove hint from extension

Definition at line 3735 of file extconf.c.

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, ast_hint::callbacks, ast_hint::exten, free(), ast_state_cb::next, and NULL.

Referenced by destroy_exten().

 {
    /* Cleanup the Notifys if hint is removed */
    struct ast_hint *hint;
    struct ast_state_cb *cblist, *cbprev;
    int res = -1;
 
    if (!e)
       return -1;
 
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&hints, hint, list) {
       if (hint->exten == e) {
          cbprev = NULL;
          cblist = hint->callbacks;
          while (cblist) {
             /* Notify with -1 and remove all callbacks */
             cbprev = cblist;
             cblist = cblist->next;
             free(cbprev);
          }
          hint->callbacks = NULL;
          AST_RWLIST_REMOVE_CURRENT(&hints, list);
          free(hint);
             res = 0;
          break;
       }
    }
    AST_RWLIST_TRAVERSE_SAFE_END
 
    return res;
 }

◆ 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 801 of file extconf.c.

References ast_unreplace_sigchld(), and safe_system_prev_handler.

Referenced by ast_safe_fork(), and ast_safe_system().

 {
    unsigned int level;
 
    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_rwlock_destroy()

static int ast_rwlock_destroy ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 529 of file extconf.c.

Referenced by __ast_context_destroy().

 {
    return pthread_rwlock_destroy(prwlock);
 }

◆ ast_rwlock_init()

static int ast_rwlock_init ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 516 of file extconf.c.

Referenced by __ast_context_create().

 {
    pthread_rwlockattr_t attr;
 
    pthread_rwlockattr_init(&attr);
 
 #ifdef HAVE_PTHREAD_RWLOCK_PREFER_WRITER_NP
    pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);
 #endif
 
    return pthread_rwlock_init(prwlock, &attr);
 }

◆ ast_rwlock_rdlock()

static int ast_rwlock_rdlock ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 539 of file extconf.c.

Referenced by pbx_retrieve_variable().

 {
    return pthread_rwlock_rdlock(prwlock);
 }

◆ ast_rwlock_unlock()

static int ast_rwlock_unlock ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 534 of file extconf.c.

Referenced by ast_unlock_context(), ast_unlock_contexts(), and pbx_retrieve_variable().

 {
    return pthread_rwlock_unlock(prwlock);
 }

◆ ast_rwlock_wrlock()

static int ast_rwlock_wrlock ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 544 of file extconf.c.

Referenced by ast_wrlock_context(), and ast_wrlock_contexts().

 {
    return pthread_rwlock_wrlock(prwlock);
 }

◆ 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 829 of file extconf.c.

References ast_log(), ast_replace_sigchld(), ast_unreplace_sigchld(), errno, LOG_WARNING, NULL, status, WEXITSTATUS, WIFEXITED, and ast_channel::x.

Referenced by add_email_attachment(), alarmreceiver_exec(), ast_monitor_stop(), AST_TEST_DEFINE(), ast_unreplace_sigchld(), convert_bdb_to_sqlite3(), mixmonitor_thread(), notify_message(), process_text_line(), rotate_file(), run_externnotify(), sendmail(), sendpage(), system_exec_helper(), and vm_change_password_shell().

 {
    pid_t pid;
 #ifdef HAVE_WORKING_FORK
    int x;
 #endif
    int res;
    int status;
 
 #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_WORKING_FORK
       /* Close file descriptors and launch system command */
       for (x = STDERR_FILENO + 1; x < 4096; x++)
          close(x);
 #endif
       execl("/bin/sh", "/bin/sh", "-c", s, (char *) NULL);
       _exit(1);
    } else if (pid > 0) {
       for(;;) {
          res = waitpid(pid, &status, 0);
          if (res > -1) {
             res = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
             break;
          } else if (errno != EINTR)
             break;
       }
    } else {
       ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
       res = -1;
    }
 
    ast_unreplace_sigchld();
 #else
    res = -1;
 #endif
 
    return res;
 }

◆ ast_shrink_phone_number()

static void ast_shrink_phone_number ( char * n )

static

Clean up phone string remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets. Basically, remove anything that could be invalid in a pattern.

Definition at line 2137 of file extconf.c.

References ast_channel::x.

Referenced by pbx_load_config().

 {
    int x, y=0;
    int bracketed = 0;
 
    for (x=0; n[x]; x++) {
       switch(n[x]) {
       case '[':
          bracketed++;
          n[y++] = n[x];
          break;
       case ']':
          bracketed--;
          n[y++] = n[x];
          break;
       case '-':
          if (bracketed)
             n[y++] = n[x];
          break;
       case '.':
          if (!n[x+1])
             n[y++] = n[x];
          break;
       default:
          if (!strchr("()", n[x]))
             n[y++] = n[x];
       }
    }
    n[y] = '\0';
 }

◆ ast_skip_blanks()

char* ast_skip_blanks ( const char * str )

Definition at line 979 of file extconf.c.

References str.

Referenced by ast_trim_blanks(), pbx_load_config(), and process_text_line().

989 {

◆ ast_strip()

char* ast_strip ( char * s )

Strip leading/trailing whitespace from a string.

Parameters

s	The string to be stripped (will be modified).

Returns: The stripped string.

This functions strips all leading and trailing whitespace characters from the input string, and returns a pointer to the resulting string. The string is modified in place.

Definition at line 1024 of file extconf.c.

Referenced by config_text_file_load(), and process_text_line().

1029 {

◆ ast_strlen_zero()

static force_inline int ast_strlen_zero ( const char * s )

static

Definition at line 952 of file extconf.c.

Referenced by ast_build_timing(), ast_include_new(), ast_true(), config_text_file_load(), get_range(), get_timerange(), matchcid(), pbx_builtin_setvar(), pbx_substitute_variables_helper_full(), and process_text_line().

 {
    return (!s || (*s == '\0'));
 }

◆ ast_trim_blanks()

char* ast_trim_blanks ( char * str )

Trims trailing whitespace characters from a string.

Parameters

ast_trim_blanks	function being used
str	the input string

Returns: a pointer to the modified string

Definition at line 1005 of file extconf.c.

References ast_skip_blanks().

1018 {

◆ ast_true()

static int ast_true ( const char * s )

static

Definition at line 2245 of file extconf.c.

References ast_strlen_zero().

Referenced by pbx_load_config().

 {
    if (ast_strlen_zero(s))
       return 0;
 
    /* Determine if this is a true value */
    if (!strcasecmp(s, "yes") ||
        !strcasecmp(s, "true") ||
        !strcasecmp(s, "y") ||
        !strcasecmp(s, "t") ||
        !strcasecmp(s, "1") ||
        !strcasecmp(s, "on"))
       return -1;
 
    return 0;
 }

◆ ast_tvadd()

struct timeval ast_tvadd	(	struct timeval	a,
		struct timeval	b
	)

Returns the sum of two timevals a + b.

Definition at line 2283 of file extconf.c.

References a, ONE_MILLION, and tvfix().

Referenced by __get_from_jb(), acf_jabberreceive_read(), ast_audiohook_trigger_wait(), ast_bridge_channel_feature_digit(), ast_bridge_interval_hook(), ast_channel_cmpwhentohangup_tv(), ast_channel_setwhentohangup_tv(), ast_poll2(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_end_with_duration(), ast_rtp_ice_turn_request(), ast_rtp_sendcng(), ast_sched_runq(), ast_sip_sched_task_get_times2(), ast_sip_schedule_task(), ast_smoother_read(), AST_TEST_DEFINE(), ast_translate(), bridge_builtin_set_limits(), bridge_channel_handle_interval(), bridge_sync_wait(), calc_rxstamp(), calc_timestamp(), cli_show_tasks(), cli_tps_ping(), conf_run(), consumer_should_stay(), dial_exec_full(), do_cdr(), do_timing(), drop_packets_data_update(), expire_objects_from_cache(), handle_keepalive_message(), handler_wait_for_message(), hook_event_cb(), iax2_process_thread(), ice_reset_session(), jb_get_and_deliver(), jitterbuffer_frame_get_ntp_timestamp(), make_deadline(), mb_poll_thread(), monmp3thread(), mp3_exec(), mwi_monitor_handler(), NBScat_exec(), register_aor_core(), rtp_deallocate_transport(), run_task(), sched_run(), sched_settime(), schedule_cache_expiration(), schedule_delivery(), set_timeout(), sla_process_timers(), smdi_message_wait(), sorcery_memory_cache_print_object(), subscription_persistence_update(), timeout_write(), user_event_wait_for_events(), and wait_for_stimulus().

 {
    /* consistency checks to guarantee usec in 0..999999 */
    a = tvfix(a);
    b = tvfix(b);
    a.tv_sec += b.tv_sec;
    a.tv_usec += b.tv_usec;
    if (a.tv_usec >= ONE_MILLION) {
       a.tv_sec++;
       a.tv_usec -= ONE_MILLION;
    }
    return a;
 }

◆ ast_tvnow()

struct timeval ast_tvnow ( void )

Definition at line 5674 of file extconf.c.

References NULL.

 {
    struct timeval t;
    gettimeofday(&t, NULL);
    return t;
 }

◆ ast_tvsub()

struct timeval ast_tvsub	(	struct timeval	a,
		struct timeval	b
	)

Returns the difference of two timevals a - b.

Definition at line 2298 of file extconf.c.

References a, ast_mark_lock_failed(), ONE_MILLION, and tvfix().

Referenced by action_login(), ast_poll2(), ast_sched_dump(), AST_TEST_DEFINE(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_timestamp(), cli_tps_ping(), conf_run(), debug_check_frame_for_silence(), handle_showcalls(), handle_showuptime(), jitterbuffer_frame_get_ntp_timestamp(), memory_cache_stale_check_object(), object_stale_callback(), and publish_fully_booted().

 {
    /* consistency checks to guarantee usec in 0..999999 */
    a = tvfix(a);
    b = tvfix(b);
    a.tv_sec -= b.tv_sec;
    a.tv_usec -= b.tv_usec;
    if (a.tv_usec < 0) {
       a.tv_sec-- ;
       a.tv_usec += ONE_MILLION;
    }
    return a;
 }

◆ ast_unlock_context()

static int ast_unlock_context ( struct ast_context * con )

static

Definition at line 4626 of file extconf.c.

References ast_context_add_switch2(), ast_rwlock_unlock(), and ast_context::lock.

Referenced by __ast_context_destroy().

 {
    return ast_rwlock_unlock(&con->lock);
 }

◆ ast_unlock_contexts()

static int ast_unlock_contexts ( void )

static

Definition at line 4616 of file extconf.c.

References ast_rwlock_unlock(), and conlock.

Referenced by __ast_context_create(), ast_merge_contexts_and_delete(), and localized_context_destroy().

 {
    return ast_rwlock_unlock(&conlock);
 }

◆ 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 815 of file extconf.c.

References ast_safe_system(), NULL, safe_system_level, and safe_system_prev_handler.

Referenced by ast_replace_sigchld(), ast_safe_fork_cleanup(), ast_safe_system(), and AST_TEST_DEFINE().

 {
    unsigned int level;
 
    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_var_assign()

static struct ast_var_t * ast_var_assign	(	const char *	name,
		const char *	value
	)

static

Definition at line 2456 of file extconf.c.

References ast_calloc, ast_copy_string(), ast_var_t::name, NULL, ast_var_t::value, and var.

Referenced by pbx_builtin_setvar_helper().

 {
    struct ast_var_t *var;
    int name_len = strlen(name) + 1;
    int value_len = strlen(value) + 1;
 
    if (!(var = ast_calloc(sizeof(*var) + name_len + value_len, sizeof(char)))) {
       return NULL;
    }
 
    ast_copy_string(var->name, name, name_len);
    var->value = var->name + name_len;
    ast_copy_string(var->value, value, value_len);
 
    return var;
 }

◆ ast_var_delete()

static void ast_var_delete ( struct ast_var_t * var )

static

Definition at line 2473 of file extconf.c.

References free().

Referenced by pbx_builtin_setvar_helper().

 {
    free(var);
 }

◆ ast_var_name()

static const char* ast_var_name ( const struct ast_var_t * var )

static

Definition at line 2171 of file extconf.c.

References ast_var_t::name, ast_channel::name, and NULL.

Referenced by pbx_builtin_setvar_helper(), and pbx_retrieve_variable().

 {
    const char *name;
 
    if (var == NULL || (name = var->name) == NULL)
       return NULL;
    /* Return the name without the initial underscores */
    if (name[0] == '_') {
       name++;
       if (name[0] == '_')
          name++;
    }
    return name;
 }

◆ ast_var_value()

static const char* ast_var_value ( const struct ast_var_t * var )

static

Definition at line 5028 of file extconf.c.

References NULL, and ast_var_t::value.

Referenced by pbx_retrieve_variable().

 {
    return (var ? var->value : NULL);
 }

◆ ast_variable_append()

static void ast_variable_append	(	struct ast_category *	category,
		struct ast_variable *	variable
	)

static

Definition at line 1178 of file extconf.c.

References category_get(), config, ast_category::ignored, ast_category::last, ast_variable::next, and ast_category::root.

Referenced by ast_include_find(), inherit_category(), move_variables(), and process_text_line().

 {
    if (!variable)
       return;
    if (category->last)
       category->last->next = variable;
    else
       category->root = variable;
    category->last = variable;
    while (category->last->next)
       category->last = category->last->next;
 }

◆ ast_variable_browse()

static struct ast_variable* ast_variable_browse	(	const struct ast_config *	config,
		const char *	category
	)

static

Definition at line 1216 of file extconf.c.

References ast_category_get(), ast_config::last_browse, ast_category::name, NULL, and ast_category::root.

Referenced by ast_variable_retrieve(), and pbx_load_config().

 {
    struct ast_category *cat = NULL;
 
    if (category && config->last_browse && (config->last_browse->name == category))
       cat = config->last_browse;
    else
       cat = ast_category_get(config, category);
 
    return (cat) ? cat->root : NULL;
 }

◆ ast_variable_new()

static struct ast_variable * ast_variable_new	(	const char *	name,
		const char *	value,
		const char *	filename
	)

static

Definition at line 1056 of file extconf.c.

References ast_calloc, ast_copy_string(), ast_variable::file, ast_variable::name, ast_variable::stuff, and ast_variable::value.

Referenced by process_text_line(), and variable_clone().

 {
    struct ast_variable *variable;
    int name_len = strlen(name) + 1;
    size_t value_len = strlen(value) + 1;
    size_t filename_len = strlen(filename) + 1;
 
    if ((variable = ast_calloc(1, name_len + value_len + filename_len + sizeof(*variable)))) {
       variable->name = variable->stuff;
       variable->value = variable->stuff + name_len;
       variable->file = variable->value + value_len;
       strcpy(variable->name,name);
       ast_copy_string(variable->value, value, value_len);
       ast_copy_string(variable->file, filename, filename_len);
    }
 
    return variable;
 }

◆ ast_variable_retrieve()

static const char * ast_variable_retrieve	(	const struct ast_config *	config,
		const char *	category,
		const char *	variable
	)

static

Definition at line 1228 of file extconf.c.

References ast_variable_browse(), ast_variable::name, ast_variable::next, ast_category::next, NULL, ast_category::root, ast_config::root, and ast_variable::value.

Referenced by pbx_load_config().

 {
    struct ast_variable *v;
 
    if (category) {
       for (v = ast_variable_browse(config, category); v; v = v->next) {
          if (!strcasecmp(variable, v->name))
             return v->value;
       }
    } else {
       struct ast_category *cat;
 
       for (cat = config->root; cat; cat = cat->next)
          for (v = cat->root; v; v = v->next)
             if (!strcasecmp(variable, v->name))
                return v->value;
    }
 
    return NULL;
 }

◆ ast_variables_destroy()

static void ast_variables_destroy ( struct ast_variable * v )

static

Definition at line 1263 of file extconf.c.

References free(), and ast_variable::next.

Referenced by ast_category_destroy(), and ast_config_destroy().

 {
    struct ast_variable *vn;
 
    while (v) {
       vn = v;
       v = v->next;
       free(vn);
    }
 }

◆ ast_verbose()

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

Definition at line 2207 of file extconf.c.

Referenced by __ast_context_create(), acl_change_stasis_cb(), add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), add_tcodec_to_sdp(), add_vcodec_to_sdp(), alsa_answer(), alsa_call(), alsa_digit(), alsa_hangup(), alsa_indicate(), alsa_text(), ao2_weakproxy_unsubscribe(), ast_add_extension2(), ast_agi_send(), ast_ari_callback(), ast_context_add_include2(), ast_context_add_switch2(), ast_remotecontrol(), ast_rtcp_calculate_sr_rr_statistics(), ast_rtcp_interpret(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_continuation(), ast_rtp_dtmf_end_with_duration(), ast_rtp_read(), ast_rtp_sendcng(), ast_stun_handle_packet(), astman_append(), astman_flush(), bridge_p2p_rtp_write(), can_safely_quit(), chan_misdn_log(), check_peer_ok(), check_via(), conf_run(), config_text_file_load(), console_answer(), dahdi_softhangup_all(), do_register_auth(), dundi_debug_output(), get_also_info(), get_destination(), get_rdnis(), get_refer_info(), handle_clear_alarms(), handle_cli_misdn_send_facility(), handle_incoming(), handle_request_do(), handle_request_info(), handle_request_invite(), handle_request_message(), handle_request_refer(), handle_request_subscribe(), handle_response(), handle_transfer_button(), hook_event_cb(), iax_debug_output(), initialize_initreq(), ivr_demo_func(), jb_debug_output(), load_module(), localized_config_text_file_save(), log_action(), logging_on_rx_msg(), logging_on_tx_msg(), match_filter(), mgcp_reload(), oss_answer(), oss_call(), oss_digit_end(), oss_hangup(), oss_indicate(), oss_text(), pbx_builtin_setvar_helper(), phone_check_exception(), phone_exception(), print_frame(), print_intro_message(), process_dtmf_rfc2833(), process_sdp(), process_sdp_a_audio(), process_sdp_a_text(), process_sdp_a_video(), process_sdp_o(), receive_message(), retrans_pkt(), rtp_raw_write(), run_agi(), send_request(), send_response(), set_destination(), sip_auth_headers(), sip_pvt_dtor(), sip_reload(), sip_route_dump(), sip_scheddestroy_full(), sip_sendtext(), stasis_app_message_handler(), stun_process_attr(), timing_read(), transmit_register(), use_reason_header(), xmpp_log_hook(), and xmpp_pubsub_receive_node_list().

 {
    va_list vars;
    va_start(vars,fmt);
 
    printf("VERBOSE: ");
    vprintf(fmt, vars);
    fflush(stdout);
    va_end(vars);
 }

◆ ast_walk_context_extensions()

static struct ast_exten* ast_walk_context_extensions	(	struct ast_context *	con,
		struct ast_exten *	exten
	)

static

Definition at line 4042 of file extconf.c.

References localized_walk_context_extensions(), ast_exten::next, NULL, and ast_context::root.

Referenced by localized_walk_context_extensions(), localized_walk_contexts(), and pbx_find_extension().

 {
    if (!exten)
       return con ? con->root : NULL;
    else
       return exten->next;
 }

◆ ast_walk_context_ignorepats()

static struct ast_ignorepat* ast_walk_context_ignorepats	(	struct ast_context *	con,
		struct ast_ignorepat *	ip
	)

static

Definition at line 4115 of file extconf.c.

References ast_context_ignorepats_count(), ast_context::ignorepats, ast_ignorepat::next, and NULL.

Referenced by ast_context_ignorepats_count(), and localized_walk_context_includes().

 {
    if (!ip)
       return con ? con->ignorepats : NULL;
    else
       return ip->next;
 }

◆ ast_walk_context_includes()

static struct ast_include* ast_walk_context_includes	(	struct ast_context *	con,
		struct ast_include *	inc
	)

static

Definition at line 4082 of file extconf.c.

References ast_context_includes_count(), ast_context::includes, ast_include::next, and NULL.

Referenced by ast_context_includes_count(), ast_context_verify_includes(), localized_walk_context_includes(), and localized_walk_extension_priorities().

 {
    if (!inc)
       return con ? con->includes : NULL;
    else
       return inc->next;
 }

◆ ast_walk_context_switches()

static struct ast_sw* ast_walk_context_switches	(	struct ast_context *	con,
		struct ast_sw *	sw
	)

static

Definition at line 4141 of file extconf.c.

References ast_context::alts, AST_LIST_FIRST, AST_LIST_NEXT, ast_sw::list, localized_walk_context_switches(), and NULL.

Referenced by ast_context_ignorepats_count(), ast_context_switches_count(), and localized_walk_context_switches().

 {
    if (!sw)
       return con ? AST_LIST_FIRST(&con->alts) : NULL;
    else
       return AST_LIST_NEXT(sw, list);
 }

◆ ast_walk_contexts()

static struct ast_context* ast_walk_contexts ( struct ast_context * con )

static

Definition at line 4026 of file extconf.c.

References contexts, localized_walk_contexts(), and ast_context::next.

Referenced by ast_check_timing(), ast_context_find(), localized_pbx_load_module(), localized_walk_contexts(), and pbx_find_extension().

 {
    return con ? con->next : contexts;
 }

◆ ast_walk_extension_priorities()

static struct ast_exten* ast_walk_extension_priorities	(	struct ast_exten *	exten,
		struct ast_exten *	priority
	)

static

Definition at line 4063 of file extconf.c.

References exten, localized_walk_extension_priorities(), and ast_exten::peer.

Referenced by localized_walk_context_extensions(), localized_walk_extension_priorities(), and pbx_find_extension().

 {
    return priority ? priority->peer : exten;
 }

◆ ast_wrlock_context()

static int ast_wrlock_context ( struct ast_context * con )

static

Definition at line 4621 of file extconf.c.

References ast_rwlock_wrlock(), and ast_context::lock.

Referenced by __ast_context_destroy().

 {
    return ast_rwlock_wrlock(&con->lock);
 }

◆ ast_wrlock_contexts()

static int ast_wrlock_contexts ( void )

static

Definition at line 4611 of file extconf.c.

References ast_rwlock_wrlock(), and conlock.

Referenced by __ast_context_create(), ast_merge_contexts_and_delete(), and localized_context_destroy().

 {
    return ast_rwlock_wrlock(&conlock);
 }

◆ category_get()

static struct ast_category * category_get	(	const struct ast_config *	config,
		const char *	category_name,
		int	ignored
	)

static

Definition at line 1193 of file extconf.c.

References ast_category::ignored, ast_category::name, ast_category::next, NULL, and ast_config::root.

Referenced by ast_category_get(), ast_variable_append(), localized_category_get(), and process_text_line().

 {
    struct ast_category *cat;
 
    /* try exact match first, then case-insensitive match */
    for (cat = config->root; cat; cat = cat->next) {
       if (cat->name == category_name && (ignored || !cat->ignored))
          return cat;
    }
 
    for (cat = config->root; cat; cat = cat->next) {
       if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored))
          return cat;
    }
 
    return NULL;
 }

◆ CB_ADD()

static void CB_ADD ( char * str )

static

Definition at line 737 of file extconf.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

 {
    int rem = comment_buffer_size - strlen(comment_buffer) - 1;
    int siz = strlen(str);
    if (rem < siz+1) {
       comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + siz + 1);
       if (!comment_buffer)
          return;
       comment_buffer_size += CB_INCR+siz+1;
    }
    strcat(comment_buffer,str);
 }

◆ CB_ADD_LEN()

static void CB_ADD_LEN	(	char *	str,
		int	len
	)

static

Definition at line 750 of file extconf.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

 {
    int cbl = strlen(comment_buffer) + 1;
    int rem = comment_buffer_size - cbl;
    if (rem < len+1) {
       comment_buffer = ast_realloc(comment_buffer, comment_buffer_size + CB_INCR + len + 1);
       if (!comment_buffer)
          return;
       comment_buffer_size += CB_INCR+len+1;
    }
    strncat(comment_buffer,str,len); /* safe */
    comment_buffer[cbl+len-1] = 0;
 }

◆ CB_INIT()

static void CB_INIT ( void )

static

Definition at line 718 of file extconf.c.

References ast_malloc, and CB_INCR.

Referenced by config_text_file_load().

 {
    if (!comment_buffer) {
       comment_buffer = ast_malloc(CB_INCR);
       if (!comment_buffer)
          return;
       comment_buffer[0] = 0;
       comment_buffer_size = CB_INCR;
       lline_buffer = ast_malloc(CB_INCR);
       if (!lline_buffer)
          return;
       lline_buffer[0] = 0;
       lline_buffer_size = CB_INCR;
    } else {
       comment_buffer[0] = 0;
       lline_buffer[0] = 0;
    }
 }

◆ CB_RESET()

static void CB_RESET ( void )

static

Definition at line 777 of file extconf.c.

Referenced by process_text_line().

 {
    comment_buffer[0] = 0;
    lline_buffer[0] = 0;
 }

◆ config_text_file_load()

static struct ast_config * config_text_file_load	(	const char *	database,
		const char *	table,
		const char *	filename,
		struct ast_config *	cfg,
		int	withcomments,
		const char *	suggested_include_file
	)

static

Definition at line 3121 of file extconf.c.

References ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_config_new(), ast_copy_string(), ast_log(), ast_strip(), ast_strlen_zero(), ast_verbose(), buf, CB_ADD(), CB_ADD_LEN(), CB_INIT(), comment, COMMENT_META, COMMENT_TAG, errno, free(), ast_config::include_level, LLB_ADD(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, NULL, process_text_line(), and VERBOSE_PREFIX_2.

 {
    char fn[256];
    char buf[8192];
    char *new_buf, *comment_p, *process_buf;
    FILE *f;
    int lineno=0;
    int comment = 0, nest[MAX_NESTED_COMMENTS];
    struct ast_category *cat = NULL;
    int count = 0;
    struct stat statbuf;
 
    cat = ast_config_get_current_category(cfg);
 
    if (filename[0] == '/') {
       ast_copy_string(fn, filename, sizeof(fn));
    } else {
       if (use_local_dir)
          snprintf(fn, sizeof(fn), "./%s", filename);
       else
          snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, filename);
    }
 
    if (withcomments && cfg && cfg->include_level < 2 ) {
       CB_INIT();
    }
 
    do {
       if (stat(fn, &statbuf))
          continue;
 
       if (!S_ISREG(statbuf.st_mode)) {
          ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn);
          continue;
       }
       if (option_verbose > 1) {
          ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn);
          fflush(stdout);
       }
       if (!(f = fopen(fn, "r"))) {
          if (option_debug)
             ast_log(LOG_DEBUG, "No file to parse: %s\n", fn);
          if (option_verbose > 1)
             ast_verbose( "Not found (%s)\n", strerror(errno));
          continue;
       }
       count++;
       if (option_debug)
          ast_log(LOG_DEBUG, "Parsing %s\n", fn);
       if (option_verbose > 1)
          ast_verbose("Found\n");
       while(!feof(f)) {
          lineno++;
          if (fgets(buf, sizeof(buf), f)) {
             if ( withcomments ) {
                CB_ADD(lline_buffer);       /* add the current lline buffer to the comment buffer */
                lline_buffer[0] = 0;        /* erase the lline buffer */
             }
 
             new_buf = buf;
             if (comment)
                process_buf = NULL;
             else
                process_buf = buf;
 
             while ((comment_p = strchr(new_buf, COMMENT_META))) {
                if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) {
                   /* Yuck, gotta memmove */
                   memmove(comment_p - 1, comment_p, strlen(comment_p) + 1);
                   new_buf = comment_p;
                } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) {
                   /* Meta-Comment start detected ";--" */
                   if (comment < MAX_NESTED_COMMENTS) {
                      *comment_p = '\0';
                      new_buf = comment_p + 3;
                      comment++;
                      nest[comment-1] = lineno;
                   } else {
                      ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS);
                   }
                } else if ((comment_p >= new_buf + 2) &&
                      (*(comment_p - 1) == COMMENT_TAG) &&
                      (*(comment_p - 2) == COMMENT_TAG)) {
                   /* Meta-Comment end detected */
                   comment--;
                   new_buf = comment_p + 1;
                   if (!comment) {
                      /* Back to non-comment now */
                      if (process_buf) {
                         /* Actually have to move what's left over the top, then continue */
                         char *oldptr;
                         oldptr = process_buf + strlen(process_buf);
                         if ( withcomments ) {
                            CB_ADD(";");
                            CB_ADD_LEN(oldptr+1,new_buf-oldptr-1);
                         }
 
                         memmove(oldptr, new_buf, strlen(new_buf) + 1);
                         new_buf = oldptr;
                      } else
                         process_buf = new_buf;
                   }
                } else {
                   if (!comment) {
                      /* If ; is found, and we are not nested in a comment,
                         we immediately stop all comment processing */
                      if ( withcomments ) {
                         LLB_ADD(comment_p);
                      }
                      *comment_p = '\0';
                      new_buf = comment_p;
                   } else
                      new_buf = comment_p + 1;
                }
             }
             if( withcomments && comment && !process_buf )
             {
                CB_ADD(buf);  /* the whole line is a comment, store it */
             }
 
             if (process_buf) {
                char *stripped_process_buf = ast_strip(process_buf);
                if (!ast_strlen_zero(stripped_process_buf)) {
                   if (process_text_line(cfg, &cat, stripped_process_buf, lineno, filename, withcomments, suggested_include_file)) {
                      cfg = NULL;
                      break;
                   }
                }
             }
          }
       }
       fclose(f);
    } while(0);
    if (comment) {
       ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment]);
    }
    if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) {
       if (comment_buffer) {
          free(comment_buffer);
          free(lline_buffer);
          comment_buffer=0;
          lline_buffer=0;
          comment_buffer_size=0;
          lline_buffer_size=0;
       }
    }
    if (count == 0)
       return NULL;
 
    return cfg;
 }

◆ destroy_exten()

static void destroy_exten ( struct ast_exten * e )

static

Definition at line 3767 of file extconf.c.

References ast_remove_hint(), ast_exten::data, ast_exten::datad, free(), ast_exten::priority, and PRIORITY_HINT.

Referenced by __ast_context_destroy().

 {
    if (e->priority == PRIORITY_HINT)
       ast_remove_hint(e);
 
    if (e->datad)
       e->datad(e->data);
    free(e);
 }

◆ ext_cmp()

static int ext_cmp	(	const char *	a,
		const char *	b
	)

static

the full routine to compare extensions in rules.

Definition at line 3946 of file extconf.c.

References ext_cmp1().

Referenced by ast_add_extension2().

 {
    /* make sure non-patterns come first.
     * If a is not a pattern, it either comes first or
     * we use strcmp to compare the strings.
     */
    int ret = 0;
 
    if (a[0] != '_')
       return (b[0] == '_') ? -1 : strcmp(a, b);
 
    /* Now we know a is a pattern; if b is not, a comes first */
    if (b[0] != '_')
       return 1;
 #if 0 /* old mode for ext matching */
    return strcmp(a, b);
 #endif
    /* ok we need full pattern sorting routine */
    while (!ret && a && b)
       ret = ext_cmp1(&a) - ext_cmp1(&b);
    if (ret == 0)
       return 0;
    else
       return (ret > 0) ? 1 : -1;
 }

◆ ext_cmp1()

static int ext_cmp1 ( const char ** p )

static

helper functions to sort extensions and patterns in the desired way, so that more specific patterns appear first.

ext_cmp1 compares individual characters (or sets of), returning an int where bits 0-7 are the ASCII code of the first char in the set, while bit 8-15 are the cardinality of the set minus 1. This way more specific patterns (smaller cardinality) appear first. Wildcards have a special value, so that we can directly compare them to sets by subtracting the two values. In particular: 0x000xx one character, xx 0x0yyxx yy character set starting with xx 0x10000 '.' (one or more of anything) 0x20000 '!' (zero or more of anything) 0x30000 NUL (end of string) 0x40000 error in set. The pointer to the string is advanced according to needs. NOTES:

the empty set is equivalent to NUL.
given that a full set has always 0 as the first element, we could encode the special cases as 0xffXX where XX is 1, 2, 3, 4 as used above.

Definition at line 3874 of file extconf.c.

References ast_log(), c, end, LOG_WARNING, and NULL.

Referenced by ext_cmp().

 {
    uint32_t chars[8];
    int c, cmin = 0xff, count = 0;
    const char *end;
 
    /* load, sign extend and advance pointer until we find
     * a valid character.
     */
    while ( (c = *(*p)++) && (c == ' ' || c == '-') )
       ;  /* ignore some characters */
 
    /* always return unless we have a set of chars */
    switch (c) {
    default: /* ordinary character */
       return 0x0000 | (c & 0xff);
 
    case 'N':   /* 2..9 */
       return 0x0700 | '2' ;
 
    case 'X':   /* 0..9 */
       return 0x0900 | '0';
 
    case 'Z':   /* 1..9 */
       return 0x0800 | '1';
 
    case '.':   /* wildcard */
       return 0x10000;
 
    case '!':   /* earlymatch */
       return 0x20000;   /* less specific than NULL */
 
    case '\0':  /* empty string */
       *p = NULL;
       return 0x30000;
 
    case '[':   /* pattern */
       break;
    }
    /* locate end of set */
    end = strchr(*p, ']');
 
    if (end == NULL) {
       ast_log(LOG_WARNING, "Wrong usage of [] in the extension\n");
       return 0x40000;   /* XXX make this entry go last... */
    }
 
    memset(chars, '\0', sizeof(chars)); /* clear all chars in the set */
    for (; *p < end  ; (*p)++) {
       unsigned char c1, c2;   /* first-last char in range */
       c1 = (unsigned char)((*p)[0]);
       if (*p + 2 < end && (*p)[1] == '-') { /* this is a range */
          c2 = (unsigned char)((*p)[2]);
          *p += 2; /* skip a total of 3 chars */
       } else         /* individual character */
          c2 = c1;
       if (c1 < cmin)
          cmin = c1;
       for (; c1 <= c2; c1++) {
          uint32_t mask = 1 << (c1 % 32);
          if ( (chars[ c1 / 32 ] & mask) == 0)
             count += 0x100;
          chars[ c1 / 32 ] |= mask;
       }
    }
    (*p)++;
    return count == 0 ? 0x30000 : (count | cmin);
 }

◆ ext_strncpy()

static int ext_strncpy	(	char *	dst,
		const char *	src,
		int	len
	)

static

copy a string skipping whitespace

Definition at line 3973 of file extconf.c.

References ast_check_timing().

Referenced by ast_add_extension2().

 {
    int count=0;
 
    while (*src && (count < len - 1)) {
       switch(*src) {
       case ' ':
          /* otherwise exten => [a-b],1,... doesn't work */
          /*    case '-': */
          /* Ignore */
          break;
       default:
          *dst = *src;
          dst++;
       }
       src++;
       count++;
    }
    *dst = '\0';
 
    return count;
 }

◆ extension_match_core()

static int extension_match_core	(	const char *	pattern,
		const char *	data,
		enum ext_match_t	mode
	)

static

Definition at line 4288 of file extconf.c.

References _extension_match_core(), and ast_extension_match().

Referenced by ast_extension_match(), and pbx_find_extension().

 {
    int i;
    i = _extension_match_core(pattern, data, mode);
    return i;
 }

◆ find_engine()

static struct ast_config_engine* find_engine	(	const char *	family,
		char *	database,
		int	dbsiz,
		char *	table,
		int	tabsiz
	)

static

Find realtime engine for realtime family.

Definition at line 2749 of file extconf.c.

References ast_config_get_current_category(), ast_copy_string(), ast_log(), config_maps, ast_config_map::database, ast_config_map::driver, LOG_WARNING, map, ast_config_map::name, ast_config_engine::next, ast_config_map::next, NULL, and ast_config_map::table.

Referenced by ast_config_internal_load().

 {
    struct ast_config_engine *eng, *ret = NULL;
    struct ast_config_map *map;
 
 
    for (map = config_maps; map; map = map->next) {
       if (!strcasecmp(family, map->name)) {
          if (database)
             ast_copy_string(database, map->database, dbsiz);
          if (table)
             ast_copy_string(table, map->table ? map->table : family, tabsiz);
          break;
       }
    }
 
    /* Check if the required driver (engine) exist */
    if (map) {
       for (eng = config_engine_list; !ret && eng; eng = eng->next) {
          if (!strcasecmp(eng->name, map->driver))
             ret = eng;
       }
    }
 
 
    /* if we found a mapping, but the engine is not available, then issue a warning */
    if (map && !ret)
       ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver);
 
    return ret;
 }

◆ gen_header()

static void gen_header	(	FILE *	f1,
		const char *	configfile,
		const char *	fn,
		const char *	generator
	)

static

Definition at line 3390 of file extconf.c.

References ast_copy_string().

Referenced by localized_config_text_file_save().

 {
    char date[256]="";
    time_t t;
    time(&t);
    ast_copy_string(date, ctime(&t), sizeof(date));
 
    fprintf(f1, ";!\n");
    fprintf(f1, ";! Automatically generated configuration file\n");
    if (strcmp(configfile, fn))
       fprintf(f1, ";! Filename: %s (%s)\n", configfile, fn);
    else
       fprintf(f1, ";! Filename: %s\n", configfile);
    fprintf(f1, ";! Generator: %s\n", generator);
    fprintf(f1, ";! Creation Date: %s", date);
    fprintf(f1, ";!\n");
 }

◆ get_range()

static unsigned get_range	(	char *	src,
		int	max,
		char *const	names[],
		const char *	msg
	)

static

helper function to return a range up to max (7, 12, 31 respectively). names, if supplied, is an array of names that should be mapped to numbers.

Definition at line 2640 of file extconf.c.

References ast_log(), ast_strlen_zero(), end, LOG_WARNING, lookup_name(), and strsep().

Referenced by ast_build_timing().

 {
    int start, end; /* start and ending position */
    unsigned int mask = 0;
    char *part;
 
    /* Check for whole range */
    if (ast_strlen_zero(src) || !strcmp(src, "*")) {
       return (1 << max) - 1;
    }
 
    while ((part = strsep(&src, "&"))) {
       /* Get start and ending position */
       char *endpart = strchr(part, '-');
       if (endpart) {
          *endpart++ = '\0';
       }
       /* Find the start */
       if ((start = lookup_name(part, names, max)) < 0) {
          ast_log(LOG_WARNING, "Invalid %s '%s', skipping element\n", msg, part);
          continue;
       }
       if (endpart) { /* find end of range */
          if ((end = lookup_name(endpart, names, max)) < 0) {
             ast_log(LOG_WARNING, "Invalid end %s '%s', skipping element\n", msg, endpart);
             continue;
          }
       } else {
          end = start;
       }
       /* Fill the mask. Remember that ranges are cyclic */
       mask |= (1 << end);   /* initialize with last element */
       while (start != end) {
          if (start >= max) {
             start = 0;
          }
          mask |= (1 << start);
          start++;
       }
    }
    return mask;
 }

◆ get_timerange()

static void get_timerange	(	struct ast_timing *	i,
		char *	times
	)

static

store a bitmask of valid times, one bit each 2 minute

Definition at line 2684 of file extconf.c.

References ast_log(), ast_strlen_zero(), LOG_WARNING, ast_timing::minmask, strsep(), and ast_channel::x.

Referenced by ast_build_timing().

 {
    char *endpart, *part;
    int x;
    int st_h, st_m;
    int endh, endm;
    int minute_start, minute_end;
 
    /* start disabling all times, fill the fields with 0's, as they may contain garbage */
    memset(i->minmask, 0, sizeof(i->minmask));
 
    /* 1-minute per bit */
    /* Star is all times */
    if (ast_strlen_zero(times) || !strcmp(times, "*")) {
       /* 48, because each hour takes 2 integers; 30 bits each */
       for (x = 0; x < 48; x++) {
          i->minmask[x] = 0x3fffffff; /* 30 bits */
       }
       return;
    }
    /* Otherwise expect a range */
    while ((part = strsep(&times, "&"))) {
       if (!(endpart = strchr(part, '-'))) {
          if (sscanf(part, "%2d:%2d", &st_h, &st_m) != 2 || st_h < 0 || st_h > 23 || st_m < 0 || st_m > 59) {
             ast_log(LOG_WARNING, "%s isn't a valid time.\n", part);
             continue;
          }
          i->minmask[st_h * 2 + (st_m >= 30 ? 1 : 0)] |= (1 << (st_m % 30));
          continue;
       }
       *endpart++ = '\0';
       /* why skip non digits? Mostly to skip spaces */
       while (*endpart && !isdigit(*endpart)) {
          endpart++;
       }
       if (!*endpart) {
          ast_log(LOG_WARNING, "Invalid time range starting with '%s-'.\n", part);
          continue;
       }
       if (sscanf(part, "%2d:%2d", &st_h, &st_m) != 2 || st_h < 0 || st_h > 23 || st_m < 0 || st_m > 59) {
          ast_log(LOG_WARNING, "'%s' isn't a valid start time.\n", part);
          continue;
       }
       if (sscanf(endpart, "%2d:%2d", &endh, &endm) != 2 || endh < 0 || endh > 23 || endm < 0 || endm > 59) {
          ast_log(LOG_WARNING, "'%s' isn't a valid end time.\n", endpart);
          continue;
       }
       minute_start = st_h * 60 + st_m;
       minute_end = endh * 60 + endm;
       /* Go through the time and enable each appropriate bit */
       for (x = minute_start; x != minute_end; x = (x + 1) % (24 * 60)) {
          i->minmask[x / 30] |= (1 << (x % 30));
       }
       /* Do the last one */
       i->minmask[x / 30] |= (1 << (x % 30));
    }
    /* All done */
    return;
 }

◆ include_valid()

static int include_valid ( struct ast_include * i )

inlinestatic

Definition at line 4313 of file extconf.c.

References ast_check_timing(), ast_include::hastime, ast_exten::label, pbx_find_extension(), and ast_include::timing.

Referenced by pbx_find_extension().

 {
    if (!i->hastime)
       return 1;
 
    return ast_check_timing(&(i->timing));
 }

◆ inherit_category()

static void inherit_category	(	struct ast_category *	new,
		const struct ast_category *	base
	)

static

Definition at line 2825 of file extconf.c.

References ast_category_append(), ast_variable_append(), ast_variable::next, ast_category::root, var, and variable_clone().

Referenced by process_text_line().

 {
    struct ast_variable *var;
 
    for (var = base->root; var; var = var->next)
       ast_variable_append(new, variable_clone(var));
 }

◆ LLB_ADD()

static void LLB_ADD ( char * str )

static

Definition at line 764 of file extconf.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

 {
    int rem = lline_buffer_size - strlen(lline_buffer) - 1;
    int siz = strlen(str);
    if (rem < siz+1) {
       lline_buffer = ast_realloc(lline_buffer, lline_buffer_size + CB_INCR + siz + 1);
       if (!lline_buffer)
          return;
       lline_buffer_size += CB_INCR + siz + 1;
    }
    strcat(lline_buffer,str);
 }

◆ localized_add_extension2()

int localized_add_extension2	(	struct ast_context *	con,
		int	replace,
		const char *	extension,
		int	priority,
		const char *	label,
		const char *	callerid,
		const char *	application,
		void *	data,
		void()(void )	datad,
		const char *	registrar
	)

Definition at line 4898 of file extconf.c.

References ast_add_extension2(), and ast_exten::datad.

Referenced by ast_add_extension2().

 {
    return ast_add_extension2(con, replace, extension, priority, label, callerid, application, data, datad, registrar);
 }

◆ localized_ast_include_rename()

void localized_ast_include_rename	(	struct ast_config *	conf,
		const char *	from_file,
		const char *	to_file
	)

Definition at line 1111 of file extconf.c.

References ast_variable::file, ast_category::file, free(), ast_config_include::include_location_file, ast_config::includes, ast_variable::next, ast_category::next, ast_config_include::next, ast_category::root, ast_config::root, and strdup.

 {
    struct ast_config_include *incl;
    struct ast_category *cat;
    struct ast_variable *v;
 
    int from_len = strlen(from_file);
    int to_len = strlen(to_file);
 
    if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */
       return;
 
    /* the manager code allows you to read in one config file, then
        write it back out under a different name. But, the new arrangement
       ties output lines to the file name. So, before you try to write
        the config file to disk, better riffle thru the data and make sure
        the file names are changed.
    */
    /* file names are on categories, includes (of course), and on variables. So,
       traverse all this and swap names */
 
    for (incl = conf->includes; incl; incl=incl->next) {
       if (strcmp(incl->include_location_file,from_file) == 0) {
          if (from_len >= to_len)
             strcpy(incl->include_location_file, to_file);
          else {
             free(incl->include_location_file);
             incl->include_location_file = strdup(to_file);
          }
       }
    }
    for (cat = conf->root; cat; cat = cat->next) {
       if (strcmp(cat->file,from_file) == 0) {
          if (from_len >= to_len)
             strcpy(cat->file, to_file);
          else {
             free(cat->file);
             cat->file = strdup(to_file);
          }
       }
       for (v = cat->root; v; v = v->next) {
          if (strcmp(v->file,from_file) == 0) {
             if (from_len >= to_len)
                strcpy(v->file, to_file);
             else {
                free(v->file);
                v->file = strdup(to_file);
             }
          }
       }
    }
 }

◆ localized_category_get()

struct ast_category* localized_category_get	(	const struct ast_config *	config,
		const char *	category_name
	)

Definition at line 2803 of file extconf.c.

References category_get().

Referenced by ast_category_new().

 {
    return category_get(config, category_name, 0);
 }

◆ localized_config_load()

struct ast_config* localized_config_load ( const char * filename )

Definition at line 3287 of file extconf.c.

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), localized_config_load_with_comments(), NULL, and result.

Referenced by ast_config_new(), and pbx_load_config().

 {
    struct ast_config *cfg;
    struct ast_config *result;
 
    cfg = ast_config_new();
    if (!cfg)
       return NULL;
 
    result = ast_config_internal_load(filename, cfg, 0, "");
    if (!result)
       ast_config_destroy(cfg);
 
    return result;
 }

◆ localized_config_load_with_comments()

struct ast_config* localized_config_load_with_comments ( const char * filename )

Definition at line 3305 of file extconf.c.

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), NULL, and result.

Referenced by localized_config_load().

 {
    struct ast_config *cfg;
    struct ast_config *result;
 
    cfg = ast_config_new();
    if (!cfg)
       return NULL;
 
    result = ast_config_internal_load(filename, cfg, 1, "");
    if (!result)
       ast_config_destroy(cfg);
 
    return result;
 }

◆ localized_config_text_file_save()

int localized_config_text_file_save	(	const char *	configfile,
		const struct ast_config *	cfg,
		const char *	generator
	)

Definition at line 3423 of file extconf.c.

References ast_log(), ast_verbose(), ast_variable::blanklines, ast_comment::cmt, errno, ast_config_include::exec, ast_config_include::exec_file, ast_variable::file, ast_category::file, gen_header(), ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::included_file, ast_config::includes, ast_variable::lineno, ast_category::lineno, LOG_DEBUG, ast_variable::name, ast_category::name, ast_comment::next, ast_variable::next, ast_category::next, ast_config_include::next, ast_variable::object, ast_config_include::output, ast_variable::precomments, ast_category::precomments, ast_category::root, ast_config::root, ast_variable::sameline, ast_category::sameline, set_fn(), ast_variable::value, var, and VERBOSE_PREFIX_2.

Referenced by set_fn().

 {
    FILE *f;
    char fn[256];
    struct ast_variable *var;
    struct ast_category *cat;
    struct ast_comment *cmt;
    struct ast_config_include *incl;
    int blanklines = 0;
 
    /* reset all the output flags, in case this isn't our first time saving this data */
 
    for (incl=cfg->includes; incl; incl = incl->next)
       incl->output = 0;
 
    /* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions)
       are all truncated to zero bytes and have that nice header*/
 
    for (incl=cfg->includes; incl; incl = incl->next)
    {
       if (!incl->exec) { /* leave the execs alone -- we'll write out the #exec directives, but won't zero out the include files or exec files*/
          FILE *f1;
 
          set_fn(fn, sizeof(fn), incl->included_file, configfile); /* normally, fn is just set to incl->included_file, prepended with config dir if relative */
          f1 = fopen(fn,"w");
          if (f1) {
             gen_header(f1, configfile, fn, generator);
             fclose(f1); /* this should zero out the file */
          } else {
             ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
          }
       }
    }
 
    set_fn(fn, sizeof(fn), 0, configfile); /* just set fn to absolute ver of configfile */
 #ifdef __CYGWIN__
    if ((f = fopen(fn, "w+"))) {
 #else
    if ((f = fopen(fn, "w"))) {
 #endif
       if (option_verbose > 1)
          ast_verbose(VERBOSE_PREFIX_2 "Saving '%s': ", fn);
 
       gen_header(f, configfile, fn, generator);
       cat = cfg->root;
       fclose(f);
 
       /* from here out, we open each involved file and concat the stuff we need to add to the end and immediately close... */
       /* since each var, cat, and associated comments can come from any file, we have to be
          mobile, and open each file, print, and close it on an entry-by-entry basis */
 
       while(cat) {
          set_fn(fn, sizeof(fn), cat->file, configfile);
          f = fopen(fn, "a");
          if (!f)
          {
             ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
             return -1;
          }
 
          /* dump any includes that happen before this category header */
          for (incl=cfg->includes; incl; incl = incl->next) {
             if (strcmp(incl->include_location_file, cat->file) == 0){
                if (cat->lineno > incl->include_location_lineno && !incl->output) {
                   if (incl->exec)
                      fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                   else
                      fprintf(f,"#include \"%s\"\n", incl->included_file);
                   incl->output = 1;
                }
             }
          }
 
          /* Dump section with any appropriate comment */
          for (cmt = cat->precomments; cmt; cmt=cmt->next) {
             if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                fprintf(f,"%s", cmt->cmt);
          }
          if (!cat->precomments)
             fprintf(f,"\n");
          fprintf(f, "[%s]", cat->name);
          for(cmt = cat->sameline; cmt; cmt=cmt->next) {
             fprintf(f,"%s", cmt->cmt);
          }
          if (!cat->sameline)
             fprintf(f,"\n");
          fclose(f);
 
          var = cat->root;
          while(var) {
             set_fn(fn, sizeof(fn), var->file, configfile);
             f = fopen(fn, "a");
             if (!f)
             {
                ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
                return -1;
             }
 
             /* dump any includes that happen before this category header */
             for (incl=cfg->includes; incl; incl = incl->next) {
                if (strcmp(incl->include_location_file, var->file) == 0){
                   if (var->lineno > incl->include_location_lineno && !incl->output) {
                      if (incl->exec)
                         fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                      else
                         fprintf(f,"#include \"%s\"\n", incl->included_file);
                      incl->output = 1;
                   }
                }
             }
 
             for (cmt = var->precomments; cmt; cmt=cmt->next) {
                if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                   fprintf(f,"%s", cmt->cmt);
             }
             if (var->sameline)
                fprintf(f, "%s %s %s  %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt);
             else
                fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value);
             if (var->blanklines) {
                blanklines = var->blanklines;
                while (blanklines--)
                   fprintf(f, "\n");
             }
 
             fclose(f);
 
 
             var = var->next;
          }
          cat = cat->next;
       }
       if ((option_verbose > 1) && !option_debug)
          ast_verbose("Saved\n");
    } else {
       if (option_debug)
          ast_log(LOG_DEBUG, "Unable to open for writing: %s\n", fn);
       if (option_verbose > 1)
          ast_verbose(VERBOSE_PREFIX_2 "Unable to write (%s)", strerror(errno));
       return -1;
    }
 
    /* Now, for files with trailing #include/#exec statements,
       we have to make sure every entry is output */
 
    for (incl=cfg->includes; incl; incl = incl->next) {
       if (!incl->output) {
          /* open the respective file */
          set_fn(fn, sizeof(fn), incl->include_location_file, configfile);
          f = fopen(fn, "a");
          if (!f)
          {
             ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
             return -1;
          }
 
          /* output the respective include */
          if (incl->exec)
             fprintf(f,"#exec \"%s\"\n", incl->exec_file);
          else
             fprintf(f,"#include \"%s\"\n", incl->included_file);
          fclose(f);
          incl->output = 1;
       }
    }
 
    return 0;
 }

◆ localized_context_add_ignorepat2()

int localized_context_add_ignorepat2	(	struct ast_context *	con,
		const char *	value,
		const char *	registrar
	)

Definition at line 4601 of file extconf.c.

References ast_context_add_ignorepat2().

Referenced by ast_context_add_ignorepat2().

 {
    return ast_context_add_ignorepat2(con, value, registrar);
 }

◆ localized_context_add_include2()

int localized_context_add_include2	(	struct ast_context *	con,
		const char *	value,
		const char *	registrar
	)

Definition at line 4559 of file extconf.c.

References ast_context_add_ignorepat2(), and ast_context_add_include2().

Referenced by ast_context_add_include2().

 {
    return  ast_context_add_include2(con, value, registrar);
 }

◆ localized_context_add_switch2()

int localized_context_add_switch2	(	struct ast_context *	con,
		const char *	value,
		const char *	data,
		int	eval,
		const char *	registrar
	)

Definition at line 4702 of file extconf.c.

References ast_context_add_switch2().

Referenced by ast_context_add_switch2().

 {
    return ast_context_add_switch2(con, value, data, eval, registrar);
 }

◆ localized_context_destroy()

void localized_context_destroy	(	struct ast_context *	con,
		const char *	registrar
	)

Definition at line 5565 of file extconf.c.

References __ast_context_destroy(), ast_unlock_contexts(), and ast_wrlock_contexts().

Referenced by __ast_context_destroy(), and ast_context_destroy().

 {
    ast_wrlock_contexts();
    __ast_context_destroy(con,registrar);
    ast_unlock_contexts();
 }

◆ localized_context_find_or_create()

struct ast_context* localized_context_find_or_create	(	struct ast_context **	extcontexts,
		void *	tab,
		const char *	name,
		const char *	registrar
	)

Version: 1.6.1 added tab parameter; 1.6.1 renamed function from localized_context_create to localized_context_find_or_create

Definition at line 4989 of file extconf.c.

References __ast_context_create().

Referenced by ast_context_find_or_create().

 {
    return __ast_context_create(extcontexts, name, registrar, 1);
 }

◆ localized_context_verify_includes()

int localized_context_verify_includes ( struct ast_context * con )

Definition at line 5640 of file extconf.c.

References ast_context_verify_includes(), and localized_pbx_load_module().

Referenced by ast_context_verify_includes().

 {
    return ast_context_verify_includes(con);
 }

◆ localized_find_extension()

struct ast_exten* localized_find_extension	(	struct ast_context *	bypass,
		struct pbx_find_info *	q,
		const char *	context,
		const char *	exten,
		int	priority,
		const char *	label,
		const char *	callerid,
		enum ext_match_t	action
	)

Definition at line 4470 of file extconf.c.

References NULL, and pbx_find_extension().

Referenced by pbx_find_extension().

 {
    return pbx_find_extension(NULL, bypass, q, context, exten, priority, label, callerid, action);
 }

◆ localized_merge_contexts_and_delete()

void localized_merge_contexts_and_delete	(	struct ast_context **	extcontexts,
		void *	tab,
		const char *	registrar
	)

Version: 1.6.1 added tab parameter

Definition at line 5618 of file extconf.c.

References ast_merge_contexts_and_delete().

Referenced by ast_merge_contexts_and_delete().

 {
    ast_merge_contexts_and_delete(extcontexts, registrar);
 }

◆ localized_pbx_builtin_setvar()

int localized_pbx_builtin_setvar	(	struct ast_channel *	chan,
		const void *	data
	)

Definition at line 2607 of file extconf.c.

References pbx_builtin_setvar().

Referenced by pbx_builtin_setvar().

 {
    return pbx_builtin_setvar(chan, data);
 }

◆ localized_pbx_load_module()

int localized_pbx_load_module ( void )

Definition at line 5647 of file extconf.c.

References ast_context_verify_includes(), ast_merge_contexts_and_delete(), ast_walk_contexts(), ast_context::name, NULL, and pbx_load_config().

Referenced by check_goto(), check_pval_item(), localized_context_verify_includes(), and main().

 {
    struct ast_context *con;
 
    if(!pbx_load_config(config_filename))
       return -1 /* AST_MODULE_LOAD_DECLINE*/;
 
    /* pbx_load_users(); */ /* does this affect the dialplan? */
 
    ast_merge_contexts_and_delete(&local_contexts, global_registrar);
 
    for (con = NULL; (con = ast_walk_contexts(con));)
       ast_context_verify_includes(con);
 
    printf("=== Loading extensions.conf ===\n");
    con = 0;
    while ((con = ast_walk_contexts(con)) ) {
       printf("Context: %s\n", con->name);
    }
    printf("=========\n");
 
    return 0;
 }

◆ localized_use_conf_dir()

void localized_use_conf_dir ( void )

Definition at line 3115 of file extconf.c.

Referenced by main().

 {
    use_local_dir = 0;
 }

◆ localized_use_local_dir()

void localized_use_local_dir ( void )

Definition at line 3110 of file extconf.c.

Referenced by main().

 {
    use_local_dir = 1;
 }

◆ localized_walk_context_extensions()

struct ast_exten* localized_walk_context_extensions	(	struct ast_context *	con,
		struct ast_exten *	exten
	)

Definition at line 4053 of file extconf.c.

References ast_walk_context_extensions(), and ast_walk_extension_priorities().

Referenced by ast_walk_context_extensions(), and main().

 {
    return ast_walk_context_extensions(con,exten);
 }

◆ localized_walk_context_includes()

struct ast_include* localized_walk_context_includes	(	struct ast_context *	con,
		struct ast_include *	inc
	)

Definition at line 4106 of file extconf.c.

References ast_walk_context_ignorepats(), and ast_walk_context_includes().

Referenced by ast_context_includes_count().

 {
    return ast_walk_context_includes(con, inc);
 }

◆ localized_walk_context_switches()

struct ast_sw* localized_walk_context_switches	(	struct ast_context *	con,
		struct ast_sw *	sw
	)

Definition at line 4152 of file extconf.c.

References ast_context_switches_count(), and ast_walk_context_switches().

Referenced by ast_walk_context_switches(), and main().

 {
    return ast_walk_context_switches(con, sw);
 }

◆ localized_walk_contexts()

struct ast_context* localized_walk_contexts ( struct ast_context * con )

Definition at line 4032 of file extconf.c.

References ast_walk_context_extensions(), and ast_walk_contexts().

Referenced by ast_walk_contexts(), and main().

 {
    return ast_walk_contexts(con);
 }

◆ localized_walk_extension_priorities()

struct ast_exten* localized_walk_extension_priorities	(	struct ast_exten *	exten,
		struct ast_exten *	priority
	)

Definition at line 4071 of file extconf.c.

References ast_walk_context_includes(), and ast_walk_extension_priorities().

Referenced by ast_walk_extension_priorities(), and main().

 {
    return ast_walk_extension_priorities(exten, priority);
 }

◆ lookup_name()

static int lookup_name	(	const char *	s,
		char *const	names[],
		int	max
	)

static

Helper for get_range. return the index of the matching entry, starting from 1. If names is not supplied, try numeric values.

Definition at line 2617 of file extconf.c.

Referenced by get_range().

 {
    int i;
 
    if (names && *s > '9') {
       for (i = 0; names[i]; i++) {
          if (!strcasecmp(s, names[i])) {
             return i;
          }
       }
    }
 
    /* Allow months and weekdays to be specified as numbers, as well */
    if (sscanf(s, "%2d", &i) == 1 && i >= 1 && i <= max) {
       /* What the array offset would have been: "1" would be at offset 0 */
       return i - 1;
    }
    return -1; /* error return */
 }

◆ matchcid()

static int matchcid	(	const char *	cidpattern,
		const char *	callerid
	)

static

Definition at line 4302 of file extconf.c.

References ast_extension_match(), and ast_strlen_zero().

Referenced by pbx_find_extension().

 {
    /* If the Caller*ID pattern is empty, then we're matching NO Caller*ID, so
       failing to get a number should count as a match, otherwise not */
 
    if (ast_strlen_zero(callerid))
       return ast_strlen_zero(cidpattern) ? 1 : 0;
 
    return ast_extension_match(cidpattern, callerid);
 }

◆ move_variables()

static void move_variables	(	struct ast_category *	old,
		struct ast_category *	new
	)

static

Definition at line 2808 of file extconf.c.

References ast_variable_append(), ast_variable::next, NULL, ast_category::root, and var.

Referenced by process_text_line().

 {
    struct ast_variable *var = old->root;
    old->root = NULL;
 #if 1
    /* we can just move the entire list in a single op */
    ast_variable_append(new, var);
 #else
    while (var) {
       struct ast_variable *next = var->next;
       var->next = NULL;
       ast_variable_append(new, var);
       var = next;
    }
 #endif
 }

◆ next_available_category()

static struct ast_category* next_available_category ( struct ast_category * cat )

static

Definition at line 3321 of file extconf.c.

References ast_category::ignored, and ast_category::next.

Referenced by ast_category_browse().

 {
    for (; cat && cat->ignored; cat = cat->next);
 
    return cat;
 }

◆ null_datad()

static void null_datad ( void * foo )

static

Definition at line 2744 of file extconf.c.

Referenced by ast_add_extension2().

2745 {

2746 }

◆ parse_variable_name()

static int parse_variable_name	(	char *	var,
		int *	offset,
		int *	length,
		int *	isfunc
	)

static

extract offset:length from variable name. Returns 1 if there is a offset:length part, which is trimmed off (values go into variables)

Definition at line 5006 of file extconf.c.

References var.

Referenced by pbx_retrieve_variable(), and pbx_substitute_variables_helper_full().

 {
    int parens=0;
 
    *offset = 0;
    *length = INT_MAX;
    *isfunc = 0;
    for (; *var; var++) {
       if (*var == '(') {
          (*isfunc)++;
          parens++;
       } else if (*var == ')') {
          parens--;
       } else if (*var == ':' && parens == 0) {
          *var++ = '\0';
          sscanf(var, "%30d:%30d", offset, length);
          return 1; /* offset:length valid */
       }
    }
    return 0;
 }

◆ pbx_builtin_setvar()

static int pbx_builtin_setvar	(	struct ast_channel *	chan,
		const void *	data
	)

static

Definition at line 2570 of file extconf.c.

References ast_app_separate_args(), ast_log(), ast_strdupa, ast_strlen_zero(), ast_channel::data, global, localized_pbx_builtin_setvar(), LOG_WARNING, ast_channel::name, NULL, pbx_builtin_setvar_helper(), value, and ast_channel::x.

Referenced by localized_pbx_builtin_setvar().

 {
    char *name, *value, *mydata;
    int argc;
    char *argv[24];      /* this will only support a maximum of 24 variables being set in a single operation */
    int global = 0;
    int x;
 
    if (ast_strlen_zero(data)) {
       ast_log(LOG_WARNING, "Set requires at least one variable name/value pair.\n");
       return 0;
    }
 
    mydata = ast_strdupa(data);
    argc = ast_app_separate_args(mydata, '|', argv, sizeof(argv) / sizeof(argv[0]));
 
    /* check for a trailing flags argument */
    if ((argc > 1) && !strchr(argv[argc-1], '=')) {
       argc--;
       if (strchr(argv[argc], 'g'))
          global = 1;
    }
 
    for (x = 0; x < argc; x++) {
       name = argv[x];
       if ((value = strchr(name, '='))) {
          *value++ = '\0';
          pbx_builtin_setvar_helper((global) ? NULL : chan, name, value);
       } else
          ast_log(LOG_WARNING, "Ignoring entry '%s' with no = (and not last 'options' entry)\n", name);
    }
 
    return(0);
 }

◆ pbx_builtin_setvar_helper()

static void pbx_builtin_setvar_helper	(	struct ast_channel *	chan,
		const char *	name,
		const char *	value
	)

static

Definition at line 2530 of file extconf.c.

References ast_func_write(), AST_LIST_INSERT_HEAD, AST_LIST_REMOVE, AST_LIST_TRAVERSE, ast_strdupa, ast_var_assign(), ast_var_delete(), ast_var_name(), ast_verbose(), globals, ast_channel::name, and VERBOSE_PREFIX_2.

Referenced by pbx_builtin_setvar(), and pbx_load_config().

 {
    struct ast_var_t *newvariable;
    struct varshead *headp;
    const char *nametail = name;
 
    /* XXX may need locking on the channel ? */
    if (name[strlen(name)-1] == ')') {
       char *function = ast_strdupa(name);
 
       ast_func_write(chan, function, value);
       return;
    }
 
    headp = &globals;
 
    /* For comparison purposes, we have to strip leading underscores */
    if (*nametail == '_') {
       nametail++;
       if (*nametail == '_')
          nametail++;
    }
 
    AST_LIST_TRAVERSE (headp, newvariable, entries) {
       if (strcasecmp(ast_var_name(newvariable), nametail) == 0) {
          /* there is already such a variable, delete it */
          AST_LIST_REMOVE(headp, newvariable, entries);
          ast_var_delete(newvariable);
          break;
       }
    }
 
    if (value && (newvariable = ast_var_assign(name, value))) {
       if ((option_verbose > 1) && (headp == &globals))
          ast_verbose(VERBOSE_PREFIX_2 "Setting global variable '%s' to '%s'\n", name, value);
       AST_LIST_INSERT_HEAD(headp, newvariable, entries);
    }
 
 }

◆ pbx_extension_helper()

static int pbx_extension_helper	(	struct ast_channel *	c,
		struct ast_context *	con,
		const char *	context,
		const char *	exten,
		int	priority,
		const char *	label,
		const char *	callerid,
		enum ext_match_t	action
	)

static

The return value depends on the action:

E_MATCH, E_CANMATCH, E_MATCHMORE require a real match, and return 0 on failure, -1 on match; E_FINDLABEL maps the label to a priority, and returns the priority on success, ... XXX E_SPAWN, spawn an application, and return 0 on success, -1 on failure.

Definition at line 4917 of file extconf.c.

References ast_findlabel_extension2(), ast_log(), c, pbx_find_info::data, E_CANMATCH, E_FINDLABEL, E_MATCH, E_MATCHMORE, ast_switch::exec, pbx_find_info::foundcontext, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, ast_switch::name, NULL, pbx_find_extension(), ast_exten::priority, pbx_find_info::stacklen, pbx_find_info::status, STATUS_NO_CONTEXT, STATUS_NO_EXTENSION, STATUS_NO_LABEL, STATUS_NO_PRIORITY, and pbx_find_info::swo.

Referenced by ast_findlabel_extension2().

 {
    struct ast_exten *e;
    int res;
    struct pbx_find_info q = { .stacklen = 0 }; /* the rest is reset in pbx_find_extension */
 
    int matching_action = (action == E_MATCH || action == E_CANMATCH || action == E_MATCHMORE);
 
    e = pbx_find_extension(NULL, con, &q, context, exten, priority, label, callerid, action);
    if (e) {
       if (matching_action) {
          return -1;  /* success, we found it */
       } else if (action == E_FINDLABEL) { /* map the label to a priority */
          res = e->priority;
          return res; /* the priority we were looking for */
       } else { /* spawn */
 
          /* NOT!!!!! */
          return 0;
       }
    } else if (q.swo) {  /* not found here, but in another switch */
       if (matching_action)
          return -1;
       else {
          if (!q.swo->exec) {
             ast_log(LOG_WARNING, "No execution engine for switch %s\n", q.swo->name);
             res = -1;
          }
          return q.swo->exec(c, q.foundcontext ? q.foundcontext : context, exten, priority, callerid, q.data);
       }
    } else { /* not found anywhere, see what happened */
       switch (q.status) {
       case STATUS_NO_CONTEXT:
          if (!matching_action)
             ast_log(LOG_NOTICE, "Cannot find extension context '%s'\n", context);
          break;
       case STATUS_NO_EXTENSION:
          if (!matching_action)
             ast_log(LOG_NOTICE, "Cannot find extension '%s' in context '%s'\n", exten, context);
          break;
       case STATUS_NO_PRIORITY:
          if (!matching_action)
             ast_log(LOG_NOTICE, "No such priority %d in extension '%s' in context '%s'\n", priority, exten, context);
          break;
       case STATUS_NO_LABEL:
          if (context)
             ast_log(LOG_NOTICE, "No such label '%s' in extension '%s' in context '%s'\n", label, exten, context);
          break;
       default:
          if (option_debug)
             ast_log(LOG_DEBUG, "Shouldn't happen!\n");
       }
 
       return (matching_action) ? 0 : -1;
    }
 }

◆ pbx_find_extension()

static struct ast_exten* pbx_find_extension	(	struct ast_channel *	chan,
		struct ast_context *	bypass,
		struct pbx_find_info *	q,
		const char *	context,
		const char *	exten,
		int	priority,
		const char *	label,
		const char *	callerid,
		enum ext_match_t	action
	)

static

Definition at line 4334 of file extconf.c.

References ast_context::alts, AST_LIST_TRAVERSE, ast_log(), AST_PBX_MAX_STACK, ast_walk_context_extensions(), ast_walk_contexts(), ast_walk_extension_priorities(), ast_switch::canmatch, ast_exten::cidmatch, context, ast_sw::data, pbx_find_info::data, E_CANMATCH, E_FINDLABEL, E_MATCHMORE, ast_sw::eval, ast_switch::exists, ast_exten::exten, extension_match_core(), pbx_find_info::foundcontext, include_valid(), ast_context::includes, pbx_find_info::incstack, ast_exten::label, localized_find_extension(), LOG_WARNING, match(), ast_exten::matchcid, matchcid(), ast_switch::matchmore, ast_sw::name, ast_context::name, ast_include::next, NULL, pbx_findswitch(), ast_exten::priority, ast_include::rname, pbx_find_info::stacklen, pbx_find_info::status, STATUS_NO_CONTEXT, STATUS_NO_EXTENSION, STATUS_NO_LABEL, STATUS_NO_PRIORITY, STATUS_SUCCESS, pbx_find_info::swo, tmp(), ast_sw::tmpdata, and ast_channel::x.

Referenced by include_valid(), localized_find_extension(), and pbx_extension_helper().

 {
    int x;
    struct ast_context *tmp;
    struct ast_exten *e, *eroot;
    struct ast_include *i;
 
    if (!context) {
       return NULL;
    }
 
    /* Initialize status if appropriate */
    if (q->stacklen == 0) {
       q->status = STATUS_NO_CONTEXT;
       q->swo = NULL;
       q->data = NULL;
       q->foundcontext = NULL;
    } else if (q->stacklen >= AST_PBX_MAX_STACK) {
       ast_log(LOG_WARNING, "Maximum PBX stack exceeded\n");
       return NULL;
    }
    /* Check first to see if we've already been checked */
    for (x = 0; x < q->stacklen; x++) {
       if (!strcasecmp(q->incstack[x], context))
          return NULL;
    }
    if (bypass) /* bypass means we only look there */
       tmp = bypass;
    else {   /* look in contexts */
       tmp = NULL;
       while ((tmp = ast_walk_contexts(tmp)) ) {
          if (!strcmp(tmp->name, context))
             break;
       }
       if (!tmp)
          return NULL;
    }
    if (q->status < STATUS_NO_EXTENSION)
       q->status = STATUS_NO_EXTENSION;
 
    /* scan the list trying to match extension and CID */
    eroot = NULL;
    while ( (eroot = ast_walk_context_extensions(tmp, eroot)) ) {
       int match = extension_match_core(eroot->exten, exten, action);
       /* 0 on fail, 1 on match, 2 on earlymatch */
 
       if (!match || (eroot->matchcid && !matchcid(eroot->cidmatch, callerid)))
          continue;   /* keep trying */
       if (match == 2 && action == E_MATCHMORE) {
          /* We match an extension ending in '!'.
           * The decision in this case is final and is NULL (no match).
           */
          return NULL;
       }
       /* found entry, now look for the right priority */
       if (q->status < STATUS_NO_PRIORITY)
          q->status = STATUS_NO_PRIORITY;
       e = NULL;
       while ( (e = ast_walk_extension_priorities(eroot, e)) ) {
          /* Match label or priority */
          if (action == E_FINDLABEL) {
             if (q->status < STATUS_NO_LABEL)
                q->status = STATUS_NO_LABEL;
             if (label && e->label && !strcmp(label, e->label))
                break;   /* found it */
          } else if (e->priority == priority) {
             break;   /* found it */
          } /* else keep searching */
       }
       if (e) { /* found a valid match */
          q->status = STATUS_SUCCESS;
          q->foundcontext = context;
          return e;
       }
    }
 #ifdef NOT_RIGHT_NOW
    /* Check alternative switches???  */
    AST_LIST_TRAVERSE(&tmp->alts, sw, list) {
       struct ast_switch *asw = pbx_findswitch(sw->name);
       ast_switch_f *aswf = NULL;
       char *datap;
 
       if (!asw) {
          ast_log(LOG_WARNING, "No such switch '%s'\n", sw->name);
          continue;
       }
       /* No need to Substitute variables now; we shouldn't be here if there's any  */
 
       /* equivalent of extension_match_core() at the switch level */
       if (action == E_CANMATCH)
          aswf = asw->canmatch;
       else if (action == E_MATCHMORE)
          aswf = asw->matchmore;
       else /* action == E_MATCH */
          aswf = asw->exists;
       datap = sw->eval ? sw->tmpdata : sw->data;
       res = !aswf ? 0 : aswf(chan, context, exten, priority, callerid, datap);
       if (res) {  /* Got a match */
          q->swo = asw;
          q->data = datap;
          q->foundcontext = context;
          /* XXX keep status = STATUS_NO_CONTEXT ? */
          return NULL;
       }
    }
 #endif
    q->incstack[q->stacklen++] = tmp->name;   /* Setup the stack */
    /* Now try any includes we have in this context */
    for (i = tmp->includes; i; i = i->next) {
       if (include_valid(i)) {
          if ((e = pbx_find_extension(NULL, bypass, q, i->rname, exten, priority, label, callerid, action)))
             return e;
          if (q->swo)
             return NULL;
       }
    }
    return NULL;
 }

◆ pbx_load_config()

static int pbx_load_config ( const char * config_file )

static

Definition at line 5339 of file extconf.c.

References ast_channel::appl, ast_add_extension2(), ast_category_browse(), ast_config_destroy(), ast_context_add_ignorepat2(), ast_context_add_include2(), ast_context_add_switch2(), ast_context_find_or_create(), ast_copy_string(), ast_findlabel_extension2(), ast_free_ptr(), ast_log(), ast_opt_dont_warn, ast_process_quotes_and_slashes(), ast_shrink_phone_number(), ast_skip_blanks(), ast_strdup, ast_true(), ast_variable_browse(), ast_variable_retrieve(), ast_channel::data, end, ext, free(), ast_variable::lineno, localized_config_load(), LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), PRIORITY_HINT, S_OR, strdup, strsep(), and ast_variable::value.

Referenced by localized_pbx_load_module(), and pbx_substitute_variables_helper().

 {
    struct ast_config *cfg;
    char *end;
    char *label;
    char realvalue[256];
    int lastpri = -2;
    struct ast_context *con;
    struct ast_variable *v;
    const char *cxt;
    const char *aft;
 
    cfg = localized_config_load(config_file);
    if (!cfg)
       return 0;
 
    /* Use existing config to populate the PBX table */
    static_config = ast_true(ast_variable_retrieve(cfg, "general", "static"));
    write_protect_config = ast_true(ast_variable_retrieve(cfg, "general", "writeprotect"));
    if ((aft = ast_variable_retrieve(cfg, "general", "autofallthrough")))
       autofallthrough_config = ast_true(aft);
    clearglobalvars_config = ast_true(ast_variable_retrieve(cfg, "general", "clearglobalvars"));
 
    if ((cxt = ast_variable_retrieve(cfg, "general", "userscontext")))
       ast_copy_string(userscontext, cxt, sizeof(userscontext));
    else
       ast_copy_string(userscontext, "default", sizeof(userscontext));
 
    for (v = ast_variable_browse(cfg, "globals"); v; v = v->next) {
       memset(realvalue, 0, sizeof(realvalue));
       pbx_substitute_variables_helper(NULL, v->value, realvalue, sizeof(realvalue) - 1);
       pbx_builtin_setvar_helper(NULL, v->name, realvalue);
    }
    for (cxt = NULL; (cxt = ast_category_browse(cfg, cxt)); ) {
       /* All categories but "general" or "globals" are considered contexts */
       if (!strcasecmp(cxt, "general") || !strcasecmp(cxt, "globals"))
          continue;
       con=ast_context_find_or_create(&local_contexts,NULL,cxt, global_registrar);
       if (con == NULL)
          continue;
 
       for (v = ast_variable_browse(cfg, cxt); v; v = v->next) {
          if (!strcasecmp(v->name, "exten")) {
             char *tc = ast_strdup(v->value);
             if (tc) {
                int ipri = -2;
                char realext[256]="";
                char *plus, *firstp, *firstc;
                char *pri, *appl, *data, *cidmatch;
                char *stringp = tc;
                char *ext = strsep(&stringp, ",");
                if (!ext)
                   ext="";
                pbx_substitute_variables_helper(NULL, ext, realext, sizeof(realext) - 1);
                cidmatch = strchr(realext, '/');
                if (cidmatch) {
                   *cidmatch++ = '\0';
                   ast_shrink_phone_number(cidmatch);
                }
                pri = strsep(&stringp, ",");
                if (!pri)
                   pri="";
                label = strchr(pri, '(');
                if (label) {
                   *label++ = '\0';
                   end = strchr(label, ')');
                   if (end)
                      *end = '\0';
                   else
                      ast_log(LOG_WARNING, "Label missing trailing ')' at line %d\n", v->lineno);
                }
                plus = strchr(pri, '+');
                if (plus)
                   *plus++ = '\0';
                if (!strcmp(pri,"hint"))
                   ipri=PRIORITY_HINT;
                else if (!strcmp(pri, "next") || !strcmp(pri, "n")) {
                   if (lastpri > -2)
                      ipri = lastpri + 1;
                   else
                      ast_log(LOG_WARNING, "Can't use 'next' priority on the first entry!\n");
                } else if (!strcmp(pri, "same") || !strcmp(pri, "s")) {
                   if (lastpri > -2)
                      ipri = lastpri;
                   else
                      ast_log(LOG_WARNING, "Can't use 'same' priority on the first entry!\n");
                } else if (sscanf(pri, "%30d", &ipri) != 1 &&
                    (ipri = ast_findlabel_extension2(NULL, con, realext, pri, cidmatch)) < 1) {
                   ast_log(LOG_WARNING, "Invalid priority/label '%s' at line %d\n", pri, v->lineno);
                   ipri = 0;
                }
                appl = S_OR(stringp, "");
                /* Find the first occurrence of either '(' or ',' */
                firstc = strchr(appl, ',');
                firstp = strchr(appl, '(');
                if (firstc && (!firstp || firstc < firstp)) {
                   /* comma found, no parenthesis */
                   /* or both found, but comma found first */
                   appl = strsep(&stringp, ",");
                   data = stringp;
                } else if (!firstc && !firstp) {
                   /* Neither found */
                   data = "";
                } else {
                   /* Final remaining case is parenthesis found first */
                   appl = strsep(&stringp, "(");
                   data = stringp;
                   end = strrchr(data, ')');
                   if ((end = strrchr(data, ')'))) {
                      *end = '\0';
                   } else {
                      ast_log(LOG_WARNING, "No closing parenthesis found? '%s(%s'\n", appl, data);
                   }
                   ast_process_quotes_and_slashes(data, ',', '|');
                }
 
                if (!data)
                   data="";
                appl = ast_skip_blanks(appl);
                if (ipri) {
                   if (plus)
                      ipri += atoi(plus);
                   lastpri = ipri;
                   if (!ast_opt_dont_warn && !strcmp(realext, "_."))
                      ast_log(LOG_WARNING, "The use of '_.' for an extension is strongly discouraged and can have unexpected behavior.  Please use '_X.' instead at line %d\n", v->lineno);
                   if (ast_add_extension2(con, 0, realext, ipri, label, cidmatch, appl, strdup(data), ast_free_ptr, global_registrar)) {
                      ast_log(LOG_WARNING, "Unable to register extension at line %d\n", v->lineno);
                   }
                }
                free(tc);
             }
          } else if (!strcasecmp(v->name, "include")) {
             memset(realvalue, 0, sizeof(realvalue));
             pbx_substitute_variables_helper(NULL, v->value, realvalue, sizeof(realvalue) - 1);
             if (ast_context_add_include2(con, realvalue, global_registrar))
                ast_log(LOG_WARNING, "Unable to include context '%s' in context '%s'\n", v->value, cxt);
          } else if (!strcasecmp(v->name, "ignorepat")) {
             memset(realvalue, 0, sizeof(realvalue));
             pbx_substitute_variables_helper(NULL, v->value, realvalue, sizeof(realvalue) - 1);
             if (ast_context_add_ignorepat2(con, realvalue, global_registrar))
                ast_log(LOG_WARNING, "Unable to include ignorepat '%s' in context '%s'\n", v->value, cxt);
          } else if (!strcasecmp(v->name, "switch") || !strcasecmp(v->name, "lswitch") || !strcasecmp(v->name, "eswitch")) {
             char *stringp= realvalue;
             char *appl, *data;
 
             memset(realvalue, 0, sizeof(realvalue));
             if (!strcasecmp(v->name, "switch"))
                pbx_substitute_variables_helper(NULL, v->value, realvalue, sizeof(realvalue) - 1);
             else
                ast_copy_string(realvalue, v->value, sizeof(realvalue));
             appl = strsep(&stringp, "/");
             data = strsep(&stringp, ""); /* XXX what for ? */
             if (!data)
                data = "";
             if (ast_context_add_switch2(con, appl, data, !strcasecmp(v->name, "eswitch"), global_registrar))
                ast_log(LOG_WARNING, "Unable to include switch '%s' in context '%s'\n", v->value, cxt);
          } else {
             ast_log(LOG_WARNING, "==!!== Unknown directive: %s at line %d -- IGNORING!!!\n", v->name, v->lineno);
          }
       }
    }
    ast_config_destroy(cfg);
    return 1;
 }

◆ pbx_retrieve_variable()

static void pbx_retrieve_variable	(	struct ast_channel *	c,
		const char *	var,
		char **	ret,
		char *	workspace,
		int	workspacelen,
		struct varshead *	headp
	)

static

Support for Asterisk built-in variables in the dialplan.

Note

◆ pbx_substitute_variables_helper()

static void pbx_substitute_variables_helper	(	struct ast_channel *	c,
		const char *	cp1,
		char *	cp2,
		int	count
	)

static

Definition at line 5331 of file extconf.c.

References config_file, NULL, pbx_load_config(), and pbx_substitute_variables_helper_full().

Referenced by pbx_load_config().

 {
    pbx_substitute_variables_helper_full(c, NULL, cp1, cp2, count);
 }

◆ pbx_substitute_variables_helper_full()

static void pbx_substitute_variables_helper_full	(	struct ast_channel *	c,
		struct varshead *	headp,
		const char *	cp1,
		char *	cp2,
		int	count
	)

static

Definition at line 5149 of file extconf.c.

References ast_copy_string(), ast_expr(), ast_func_read(), ast_log(), ast_strlen_zero(), len(), LOG_DEBUG, LOG_NOTICE, NULL, parse_variable_name(), pbx_retrieve_variable(), substring(), tmp(), var, and VAR_BUF_SIZE.

Referenced by pbx_substitute_variables_helper().

 {
    /* Substitutes variables into cp2, based on string cp1, and assuming cp2 to be
       zero-filled */
    char *cp4;
    const char *tmp, *whereweare;
    int length, offset, offset2, isfunction;
    char *workspace = NULL;
    char *ltmp = NULL, *var = NULL;
    char *nextvar, *nextexp, *nextthing;
    char *vars, *vare;
    int pos, brackets, needsub, len;
 
    *cp2 = 0; /* just in case there's nothing to do */
    whereweare=tmp=cp1;
    while (!ast_strlen_zero(whereweare) && count) {
       /* Assume we're copying the whole remaining string */
       pos = strlen(whereweare);
       nextvar = NULL;
       nextexp = NULL;
       nextthing = strchr(whereweare, '$');
       if (nextthing) {
          switch (nextthing[1]) {
          case '{':
             nextvar = nextthing;
             pos = nextvar - whereweare;
             break;
          case '[':
             nextexp = nextthing;
             pos = nextexp - whereweare;
             break;
          }
       }
 
       if (pos) {
          /* Can't copy more than 'count' bytes */
          if (pos > count)
             pos = count;
 
          /* Copy that many bytes */
          memcpy(cp2, whereweare, pos);
 
          count -= pos;
          cp2 += pos;
          whereweare += pos;
          *cp2 = 0;
       }
 
       if (nextvar) {
          /* We have a variable.  Find the start and end, and determine
             if we are going to have to recursively call ourselves on the
             contents */
          vars = vare = nextvar + 2;
          brackets = 1;
          needsub = 0;
 
          /* Find the end of it */
          while (brackets && *vare) {
             if ((vare[0] == '$') && (vare[1] == '{')) {
                needsub++;
             } else if (vare[0] == '{') {
                brackets++;
             } else if (vare[0] == '}') {
                brackets--;
             } else if ((vare[0] == '$') && (vare[1] == '['))
                needsub++;
             vare++;
          }
          if (brackets)
             ast_log(LOG_NOTICE, "Error in extension logic (missing '}' in '%s')\n", cp1);
          len = vare - vars - 1;
 
          /* Skip totally over variable string */
          whereweare += (len + 3);
 
          if (!var)
             var = alloca(VAR_BUF_SIZE);
 
          /* Store variable name (and truncate) */
          ast_copy_string(var, vars, len + 1);
 
          /* Substitute if necessary */
          if (needsub) {
             if (!ltmp)
                ltmp = alloca(VAR_BUF_SIZE);
 
             memset(ltmp, 0, VAR_BUF_SIZE);
             pbx_substitute_variables_helper_full(c, headp, var, ltmp, VAR_BUF_SIZE - 1);
             vars = ltmp;
          } else {
             vars = var;
          }
 
          if (!workspace)
             workspace = alloca(VAR_BUF_SIZE);
 
          workspace[0] = '\0';
 
          parse_variable_name(vars, &offset, &offset2, &isfunction);
          if (isfunction) {
             /* Evaluate function */
             cp4 = ast_func_read(c, vars, workspace, VAR_BUF_SIZE) ? NULL : workspace;
             if (option_debug)
                ast_log(LOG_DEBUG, "Function result is '%s'\n", cp4 ? cp4 : "(null)");
          } else {
             /* Retrieve variable value */
             pbx_retrieve_variable(c, vars, &cp4, workspace, VAR_BUF_SIZE, headp);
          }
          if (cp4) {
             cp4 = substring(cp4, offset, offset2, workspace, VAR_BUF_SIZE);
 
             length = strlen(cp4);
             if (length > count)
                length = count;
             memcpy(cp2, cp4, length);
             count -= length;
             cp2 += length;
             *cp2 = 0;
          }
       } else if (nextexp) {
          /* We have an expression.  Find the start and end, and determine
             if we are going to have to recursively call ourselves on the
             contents */
          vars = vare = nextexp + 2;
          brackets = 1;
          needsub = 0;
 
          /* Find the end of it */
          while (brackets && *vare) {
             if ((vare[0] == '$') && (vare[1] == '[')) {
                needsub++;
                brackets++;
                vare++;
             } else if (vare[0] == '[') {
                brackets++;
             } else if (vare[0] == ']') {
                brackets--;
             } else if ((vare[0] == '$') && (vare[1] == '{')) {
                needsub++;
                vare++;
             }
             vare++;
          }
          if (brackets)
             ast_log(LOG_NOTICE, "Error in extension logic (missing ']')\n");
          len = vare - vars - 1;
 
          /* Skip totally over expression */
          whereweare += (len + 3);
 
          if (!var)
             var = alloca(VAR_BUF_SIZE);
 
          /* Store variable name (and truncate) */
          ast_copy_string(var, vars, len + 1);
 
          /* Substitute if necessary */
          if (needsub) {
             if (!ltmp)
                ltmp = alloca(VAR_BUF_SIZE);
 
             memset(ltmp, 0, VAR_BUF_SIZE);
             pbx_substitute_variables_helper_full(c, headp, var, ltmp, VAR_BUF_SIZE - 1);
             vars = ltmp;
          } else {
             vars = var;
          }
 
          length = ast_expr(vars, cp2, count, NULL);
 
          if (length) {
             if (option_debug)
                ast_log(LOG_DEBUG, "Expression result is '%s'\n", cp2);
             count -= length;
             cp2 += length;
             *cp2 = 0;
          }
       } else
          break;
    }
 }

◆ process_text_line()

static int process_text_line	(	struct ast_config *	cfg,
		struct ast_category **	cat,
		char *	buf,
		int	lineno,
		const char *	configfile,
		int	withcomments,
		const char *	suggested_include_file
	)

static

Definition at line 2908 of file extconf.c.

References ALLOC_COMMENT(), ast_category_append(), ast_category_destroy(), ast_category_new(), ast_config_destroy(), ast_config_internal_load(), ast_include_new(), ast_log(), ast_opt_exec_includes, ast_safe_system(), ast_skip_blanks(), ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), ast_variable::blanklines, buf, c, category_get(), CB_RESET(), inherit_category(), ast_variable::lineno, ast_category::lineno, LOG_ERROR, LOG_WARNING, move_variables(), NULL, ast_variable::object, ast_variable::precomments, ast_category::precomments, ast_variable::sameline, ast_category::sameline, and strsep().

Referenced by config_text_file_load().

 {
    char *c;
    char *cur = buf;
    struct ast_variable *v;
    char exec_file[512];
    int object, do_exec, do_include;
 
    /* Actually parse the entry */
    if (cur[0] == '[') {
       struct ast_category *newcat = NULL;
       char *catname;
 
       /* A category header */
       c = strchr(cur, ']');
       if (!c) {
          ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile);
          return -1;
       }
       *c++ = '\0';
       cur++;
       if (*c++ != '(')
          c = NULL;
       catname = cur;
       if (!(*cat = newcat = ast_category_new(catname, ast_strlen_zero(suggested_include_file)?configfile:suggested_include_file, lineno))) {
          return -1;
       }
       (*cat)->lineno = lineno;
 
       /* add comments */
       if (withcomments && comment_buffer && comment_buffer[0] ) {
          newcat->precomments = ALLOC_COMMENT(comment_buffer);
       }
       if (withcomments && lline_buffer && lline_buffer[0] ) {
          newcat->sameline = ALLOC_COMMENT(lline_buffer);
       }
       if( withcomments )
          CB_RESET();
 
       /* If there are options or categories to inherit from, process them now */
       if (c) {
          if (!(cur = strchr(c, ')'))) {
             ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile);
             return -1;
          }
          *cur = '\0';
          while ((cur = strsep(&c, ","))) {
             if (!strcasecmp(cur, "!")) {
                (*cat)->ignored = 1;
             } else if (!strcasecmp(cur, "+")) {
                *cat = category_get(cfg, catname, 1);
                if (!*cat) {
                   ast_config_destroy(cfg);
                   if (newcat)
                      ast_category_destroy(newcat);
                   ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile);
                   return -1;
                }
                if (newcat) {
                   move_variables(newcat, *cat);
                   ast_category_destroy(newcat);
                   newcat = NULL;
                }
             } else {
                struct ast_category *base;
 
                base = category_get(cfg, cur, 1);
                if (!base) {
                   ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile);
                   return -1;
                }
                inherit_category(*cat, base);
             }
          }
       }
       if (newcat)
          ast_category_append(cfg, *cat);
    } else if (cur[0] == '#') {
       /* A directive */
       cur++;
       c = cur;
       while(*c && (*c > 32)) c++;
       if (*c) {
          *c = '\0';
          /* Find real argument */
          c = ast_skip_blanks(c + 1);
          if (!*c)
             c = NULL;
       } else
          c = NULL;
       do_include = !strcasecmp(cur, "include");
       if(!do_include)
          do_exec = !strcasecmp(cur, "exec");
       else
          do_exec = 0;
       if (do_exec && !ast_opt_exec_includes) {
          ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n");
          do_exec = 0;
       }
       if (do_include || do_exec) {
          if (c) {
             char *cur2;
             char real_inclusion_name[525];
 
             /* Strip off leading and trailing "'s and <>'s */
             while((*c == '<') || (*c == '>') || (*c == '\"')) c++;
             /* Get rid of leading mess */
             cur = c;
             cur2 = cur;
             while (!ast_strlen_zero(cur)) {
                c = cur + strlen(cur) - 1;
                if ((*c == '>') || (*c == '<') || (*c == '\"'))
                   *c = '\0';
                else
                   break;
             }
             /* #exec </path/to/executable>
                We create a tmp file, then we #include it, then we delete it. */
             if (do_exec) {
                char cmd[1024];
 
                snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self());
                if (snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file) >= sizeof(cmd)) {
                   ast_log(LOG_ERROR, "Failed to construct command string to execute %s.\n", cur);
 
                   return -1;
                }
                ast_safe_system(cmd);
                cur = exec_file;
             } else
                exec_file[0] = '\0';
             /* A #include */
             /* ast_log(LOG_WARNING, "Reading in included file %s withcomments=%d\n", cur, withcomments); */
 
             /* record this inclusion */
             ast_include_new(cfg, configfile, cur, do_exec, cur2, lineno, real_inclusion_name, sizeof(real_inclusion_name));
 
             do_include = ast_config_internal_load(cur, cfg, withcomments, real_inclusion_name) ? 1 : 0;
             if(!ast_strlen_zero(exec_file))
                unlink(exec_file);
             if(!do_include)
                return 0;
             /* ast_log(LOG_WARNING, "Done reading in included file %s withcomments=%d\n", cur, withcomments); */
 
          } else {
             ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n",
                   do_exec ? "exec" : "include",
                   do_exec ? "/path/to/executable" : "filename",
                   lineno,
                   configfile);
          }
       }
       else
          ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile);
    } else {
       /* Just a line (variable = value) */
       if (!*cat) {
          ast_log(LOG_WARNING,
             "parse error: No category context for line %d of %s\n", lineno, configfile);
          return -1;
       }
       c = strchr(cur, '=');
       if (c) {
          *c = 0;
          c++;
          /* Ignore > in => */
          if (*c== '>') {
             object = 1;
             c++;
          } else
             object = 0;
          if ((v = ast_variable_new(ast_strip(cur), ast_strip(c), configfile))) {
             v->lineno = lineno;
             v->object = object;
             /* Put and reset comments */
             v->blanklines = 0;
             ast_variable_append(*cat, v);
             /* add comments */
             if (withcomments && comment_buffer && comment_buffer[0] ) {
                v->precomments = ALLOC_COMMENT(comment_buffer);
             }
             if (withcomments && lline_buffer && lline_buffer[0] ) {
                v->sameline = ALLOC_COMMENT(lline_buffer);
             }
             if( withcomments )
                CB_RESET();
 
          } else {
             return -1;
          }
       } else {
          ast_log(LOG_WARNING, "EXTENSIONS.CONF: No '=' (equal sign) in line %d of %s\n", lineno, configfile);
       }
    }
    return 0;
 }

◆ set_fn()

static void set_fn	(	char *	fn,
		int	fn_size,
		const char *	file,
		const char *	configfile
	)

static

Definition at line 3408 of file extconf.c.

References ast_config_AST_CONFIG_DIR, ast_copy_string(), ast_channel::generator, and localized_config_text_file_save().

Referenced by localized_config_text_file_save().

 {
    if (!file || file[0] == 0) {
       if (configfile[0] == '/')
          ast_copy_string(fn, configfile, fn_size);
       else
          snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
    } else if (file[0] == '/')
       ast_copy_string(fn, file, fn_size);
    else
       snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, file);
 }

◆ substring()

static char* substring	(	const char *	value,
		int	offset,
		int	length,
		char *	workspace,
		size_t	workspace_len
	)

static

takes a substring. It is ok to call with value == workspace.

offset < 0 means start from the end of the string and set the beginning to be that many characters back. length is the length of the substring. A value less than 0 means to leave that many off the end. Always return a copy in workspace.

Definition at line 5041 of file extconf.c.

References ast_copy_string().

Referenced by pbx_retrieve_variable(), and pbx_substitute_variables_helper_full().

 {
    char *ret = workspace;
    int lr;  /* length of the input string after the copy */
 
    ast_copy_string(workspace, value, workspace_len); /* always make a copy */
 
    lr = strlen(ret); /* compute length after copy, so we never go out of the workspace */
 
    /* Quick check if no need to do anything */
    if (offset == 0 && length >= lr) /* take the whole string */
       return ret;
 
    if (offset < 0)   {  /* translate negative offset into positive ones */
       offset = lr + offset;
       if (offset < 0) /* If the negative offset was greater than the length of the string, just start at the beginning */
          offset = 0;
    }
 
    /* too large offset result in empty string so we know what to return */
    if (offset >= lr)
       return ret + lr;  /* the final '\0' */
 
    ret += offset;    /* move to the start position */
    if (length >= 0 && length < lr - offset)  /* truncate if necessary */
       ret[length] = '\0';
    else if (length < 0) {
       if (lr > offset - length) /* After we remove from the front and from the rear, is there anything left? */
          ret[lr + length - offset] = '\0';
       else
          ret[0] = '\0';
    }
 
    return ret;
 }

◆ tvfix()

static struct timeval tvfix ( struct timeval a )

static

Definition at line 2267 of file extconf.c.

References a, ast_log(), LOG_WARNING, and ONE_MILLION.

Referenced by ast_tvadd(), and ast_tvsub().

 {
    if (a.tv_usec >= ONE_MILLION) {
       ast_log(LOG_WARNING, "warning too large timestamp %ld.%ld\n",
          (long)a.tv_sec, (long int) a.tv_usec);
       a.tv_sec += a.tv_usec / ONE_MILLION;
       a.tv_usec %= ONE_MILLION;
    } else if (a.tv_usec < 0) {
       ast_log(LOG_WARNING, "warning negative timestamp %ld.%ld\n",
          (long)a.tv_sec, (long int) a.tv_usec);
       a.tv_usec = 0;
    }
    return a;
 }

◆ variable_clone()

static struct ast_variable* variable_clone ( const struct ast_variable * old )

static

Definition at line 1249 of file extconf.c.

References ast_variable_new(), ast_variable::blanklines, ast_variable::file, ast_variable::lineno, ast_variable::name, ast_variable::object, and ast_variable::value.

Referenced by inherit_category().

 {
    struct ast_variable *new = ast_variable_new(old->name, old->value, old->file);
 
    if (new) {
       new->lineno = old->lineno;
       new->object = old->object;
       new->blanklines = old->blanklines;
       /* TODO: clone comments? */
    }
 
    return new;
 }

Variable Documentation

◆ ast_defaultlanguage

char ast_defaultlanguage[]

Definition at line 98 of file options.c.

Referenced by load_asterisk_conf().

◆ ast_language_is_prefix

int ast_language_is_prefix

The following variable controls the layout of localized sound files. If 0, use the historical layout with prefix just before the filename (i.e. digits/en/1.gsm , digits/it/1.gsm or default to digits/1.gsm), if 1 put the prefix at the beginning of the filename (i.e. en/digits/1.gsm, it/digits/1.gsm or default to digits/1.gsm). The latter permits a language to be entirely in one directory.

This is settable in asterisk.conf.

Definition at line 67 of file file.c.

Referenced by fileexists_test().

◆ ast_mainpid

pid_t ast_mainpid

Definition at line 315 of file asterisk.c.

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

◆ autofallthrough_config

int autofallthrough_config = 0

static

Definition at line 2126 of file extconf.c.

◆ clearglobalvars_config

int clearglobalvars_config = 0

static

Definition at line 2127 of file extconf.c.

◆ comment_buffer

char* comment_buffer

static

Growable string buffer this will be a comment collector.

Definition at line 705 of file extconf.c.

Referenced by config_text_file_load().

◆ comment_buffer_size

int comment_buffer_size

static

the amount of storage so far alloc'd for the comment_buffer

Definition at line 706 of file extconf.c.

◆ config_engine_list

static struct ast_config_engine * config_engine_list

static

Definition at line 893 of file extconf.c.

◆ config_filename

char* config_filename = "extensions.conf"

static

Definition at line 2121 of file extconf.c.

Referenced by AST_TEST_DEFINE(), and parse_config().

◆ config_maps

struct ast_config_map * config_maps = NULL

static

Referenced by find_engine().

◆ conlock

ast_rwlock_t conlock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }

static

Lock for the ast_context list

Definition at line 4484 of file extconf.c.

Referenced by ast_unlock_contexts(), and ast_wrlock_contexts().

◆ contexts

struct ast_context* contexts = NULL

static

Definition at line 3599 of file extconf.c.

Referenced by __ast_context_create(), ast_merge_contexts_and_delete(), and ast_walk_contexts().

◆ days

char* days[]

Definition at line 3777 of file extconf.c.

Referenced by main().

◆ debug_filename

char debug_filename[AST_FILENAME_MAX]

◆ extconfig_conf

char* extconfig_conf = "extconfig.conf"

static

Definition at line 702 of file extconf.c.

◆ global_registrar

char* global_registrar = "conf2ael"

static

Definition at line 2122 of file extconf.c.

◆ globals

struct varshead globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE

static

Definition at line 2069 of file extconf.c.

Referenced by pbx_builtin_setvar_helper().

◆ globalslock

ast_rwlock_t globalslock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }

static

Definition at line 2068 of file extconf.c.

Referenced by pbx_retrieve_variable().

◆ hints

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

static

◆ lline_buffer

char* lline_buffer

static

A buffer for stuff behind the ;

Definition at line 708 of file extconf.c.

Referenced by config_text_file_load().

◆ lline_buffer_size

int lline_buffer_size

static

Definition at line 709 of file extconf.c.

◆ local_contexts

struct ast_context* local_contexts = NULL

static

Definition at line 3598 of file extconf.c.

◆ months

char* months[]

Definition at line 3789 of file extconf.c.

Referenced by main().

◆ null_sig_handler

struct sigaction null_sig_handler

static

Initial value:

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

Definition at line 794 of file extconf.c.

◆ record_cache_dir

char record_cache_dir[AST_CACHE_DIR_LEN]

Definition at line 96 of file options.c.

Referenced by load_asterisk_conf().

◆ 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 785 of file extconf.c.

Referenced by ast_unreplace_sigchld().

◆ safe_system_prev_handler

struct sigaction safe_system_prev_handler

static

Definition at line 786 of file extconf.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

◆ static_config

int static_config = 0

static

Definition at line 2124 of file extconf.c.

◆ text_file_engine

struct ast_config_engine text_file_engine

static

Initial value:

= {
   .name = "text",
   .load_func = config_text_file_load,
}

Definition at line 2856 of file extconf.c.

Referenced by ast_config_internal_load().

◆ use_local_dir

int use_local_dir = 1

static

Definition at line 3105 of file extconf.c.

◆ userscontext

char userscontext[AST_MAX_EXTENSION] = "default"

static

Definition at line 2123 of file extconf.c.

◆ write_protect_config

int write_protect_config = 1

static

Definition at line 2125 of file extconf.c.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ __AST_MUTEX_DEFINE

◆ __AST_RWLOCK_DEFINE

◆ __LOG_DEBUG

◆ __LOG_DTMF

◆ __LOG_ERROR

◆ __LOG_EVENT

◆ __LOG_NOTICE

◆ __LOG_VERBOSE

◆ __LOG_WARNING

◆ __MTX_PROF

◆ _A_

◆ _ASTERISK_LOCK_H

◆ AST_API_MODULE

◆ AST_CACHE_DIR_LEN

◆ AST_DEFAULT_OPTIONS

◆ AST_FILENAME_MAX

◆ ast_fully_booted

◆ AST_LIST_APPEND_LIST

◆ AST_LIST_EMPTY

◆ AST_LIST_ENTRY

◆ AST_LIST_FIRST

◆ AST_LIST_HEAD

◆ AST_LIST_HEAD_INIT

◆ AST_LIST_HEAD_INIT_NOLOCK

◆ AST_LIST_HEAD_INIT_VALUE

◆ AST_LIST_HEAD_NOLOCK

◆ AST_LIST_HEAD_NOLOCK_INIT_VALUE

◆ AST_LIST_HEAD_NOLOCK_STATIC

◆ AST_LIST_HEAD_SET

◆ AST_LIST_HEAD_SET_NOLOCK

◆ AST_LIST_HEAD_STATIC

◆ AST_LIST_INSERT_AFTER

◆ AST_LIST_INSERT_BEFORE_CURRENT

◆ AST_LIST_INSERT_HEAD

◆ AST_LIST_INSERT_TAIL

◆ AST_LIST_LAST

◆ AST_LIST_NEXT

◆ AST_LIST_REMOVE

◆ AST_LIST_REMOVE_CURRENT

◆ AST_LIST_REMOVE_HEAD

◆ AST_LIST_TRAVERSE

◆ AST_LIST_TRAVERSE_SAFE_BEGIN

◆ AST_LIST_TRAVERSE_SAFE_END

◆ AST_MAX_EXTENSION

◆ AST_MUTEX_DEFINE_STATIC

◆ AST_MUTEX_INIT_VALUE

◆ AST_MUTEX_INITIALIZER

◆ AST_MUTEX_KIND

◆ ast_opt_always_fork

◆ ast_opt_cache_record_files

◆ ast_opt_console

◆ ast_opt_dont_warn

◆ ast_opt_dump_core

◆ ast_opt_exec

◆ ast_opt_exec_includes

◆ ast_opt_high_priority

◆ ast_opt_init_keys

◆ ast_opt_mute

◆ ast_opt_no_color

◆ ast_opt_no_fork

◆ ast_opt_override_config

◆ ast_opt_priority_jumping

◆ ast_opt_quiet

◆ ast_opt_reconnect

◆ ast_opt_remote

◆ ast_opt_timestamp

◆ ast_opt_transcode_via_slin

◆ ast_opt_transmit_silence

◆ ast_pthread_mutex_init

◆ AST_PTHREADT_NULL

◆ AST_PTHREADT_STOP

◆ AST_RWLIST_APPEND_LIST