#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 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_flag64(&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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#define	AST_LIST_TRAVERSE_SAFE_END }
	Closes a safe loop traversal block.

#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_flag64(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)

#define	ast_opt_cache_record_files ast_test_flag64(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)

#define	ast_opt_console ast_test_flag64(&ast_options, AST_OPT_FLAG_CONSOLE)

#define	ast_opt_dont_warn ast_test_flag64(&ast_options, AST_OPT_FLAG_DONT_WARN)

#define	ast_opt_dump_core ast_test_flag64(&ast_options, AST_OPT_FLAG_DUMP_CORE)

#define	ast_opt_exec ast_test_flag64(&ast_options, AST_OPT_FLAG_EXEC)

#define	ast_opt_exec_includes ast_test_flag64(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)

#define	ast_opt_high_priority ast_test_flag64(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)

#define	ast_opt_init_keys ast_test_flag64(&ast_options, AST_OPT_FLAG_INIT_KEYS)

#define	ast_opt_mute ast_test_flag64(&ast_options, AST_OPT_FLAG_MUTE)

#define	ast_opt_no_color ast_test_flag64(&ast_options, AST_OPT_FLAG_NO_COLOR)

#define	ast_opt_no_fork ast_test_flag64(&ast_options, AST_OPT_FLAG_NO_FORK)

#define	ast_opt_override_config ast_test_flag64(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)

#define	ast_opt_priority_jumping ast_test_flag64(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)

#define	ast_opt_quiet ast_test_flag64(&ast_options, AST_OPT_FLAG_QUIET)

#define	ast_opt_reconnect ast_test_flag64(&ast_options, AST_OPT_FLAG_RECONNECT)

#define	ast_opt_remote ast_test_flag64(&ast_options, AST_OPT_FLAG_REMOTE)

#define	ast_opt_timestamp ast_test_flag64(&ast_options, AST_OPT_FLAG_TIMESTAMP)

#define	ast_opt_transcode_via_slin ast_test_flag64(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)

#define	ast_opt_transmit_silence ast_test_flag64(&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.

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

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

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

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

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

#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.

#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.

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

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

#define	AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER

#define	ast_test_flag64(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	SWAP64_32(flags) (((uint64_t)(flags) << 32) \| ((uint64_t)(flags) >> 32))

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

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_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.

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

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.

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

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.

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.

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

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

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.

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.

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.

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

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.

void	ast_mark_lock_failed (void *lock_addr)

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

void	ast_replace_sigchld (void)
	Replace the SIGCHLD handler.

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.

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.

char *	ast_skip_blanks (const char *str)

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

static force_inline int	ast_strlen_zero (const char *s)

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

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.

struct timeval	ast_tvnow (void)

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

static int	ast_unlock_context (struct ast_context *con)

static int	ast_unlock_contexts (void)

void	ast_unreplace_sigchld (void)
	Restore the SIGCHLD handler.

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.

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.

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

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.

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.

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

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.

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)

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:

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.

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.

static struct timeval	tvfix (struct timeval a)

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

Variables
uint64_t	__unsigned_int_flags_dummy64

char	ast_defaultlanguage []

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 = AST_RWLOCK_INIT_VALUE

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 = AST_RWLOCK_INIT_VALUE

static struct hints	hints = AST_RWLIST_HEAD_INIT_VALUE

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.

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 extensions.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 1356 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 1360 of file extconf.c.

◆ AST_FILENAME_MAX

#define AST_FILENAME_MAX 80

Definition at line 1357 of file extconf.c.

◆ ast_fully_booted

#define ast_fully_booted ast_test_flag64(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)

Definition at line 1373 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 1991 of file extconf.c.

                                                   {            \
      if (!(head)->first) {                     \
        (head)->first = (list)->first;              \
        (head)->last = (list)->last;                \
      } else {                              \
        (head)->last->field.next = (list)->first;       \
        (head)->last = (list)->last;                \
      }                                 \
} while (0)

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

       {                                \
    struct type *next;                      \
}

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

◆ 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;

AST_LIST_HEAD

#define AST_LIST_HEAD(name, type)

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

Definition linkedlists.h:173

entry_list

Definition dnsmgr.c:85

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

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

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

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

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

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

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

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

◆ 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;

AST_LIST_HEAD_NOLOCK

#define AST_LIST_HEAD_NOLOCK(name, type)

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

Definition linkedlists.h:225

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

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

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

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

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

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

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

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

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

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

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

AST_LIST_HEAD_STATIC

#define AST_LIST_HEAD_STATIC(name, type)

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

Definition linkedlists.h:291

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

Definition at line 1571 of file extconf.c.

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

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

                                                            {       \
    (elm)->field.next = (listelm)->field.next;          \
    (listelm)->field.next = (elm);                  \
    if ((head)->last == (listelm))                  \
        (head)->last = (elm);                   \
} while (0)

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

                                                            {       \
    if (__list_prev) {                      \
        (elm)->field.next = __list_prev->field.next;        \
        __list_prev->field.next = elm;              \
    } else {                            \
        (elm)->field.next = (head)->first;          \
        (head)->first = (elm);                  \
    }                               \
    __new_prev = (elm);                     \
} while (0)

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

                                                  {         \
        (elm)->field.next = (head)->first;          \
        (head)->first = (elm);                  \
        if (!(head)->last)                  \
            (head)->last = (elm);               \
} while (0)

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

                                                  {         \
      if (!(head)->first) {                     \
        (head)->first = (elm);                  \
        (head)->last = (elm);                   \
      } else {                              \
        (head)->last->field.next = (elm);           \
        (head)->last = (elm);                   \
      }                                 \
} while (0)

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

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

                                             {                  \
    if ((head)->first == (elm)) {                   \
        (head)->first = (elm)->field.next;          \
        if ((head)->last == (elm))          \
            (head)->last = NULL;            \
    } else {                                \
        typeof(elm) curelm = (head)->first;         \
        while (curelm && (curelm->field.next != (elm)))         \
            curelm = curelm->field.next;            \
        if (curelm) { \
            curelm->field.next = (elm)->field.next;         \
            if ((head)->last == (elm))              \
                (head)->last = curelm;              \
        } \
    }                               \
        (elm)->field.next = NULL;                                       \
} while (0)

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

                                           {                \
        typeof((head)->first) cur = (head)->first;      \
        if (cur) {                      \
            (head)->first = cur->field.next;        \
            cur->field.next = NULL;             \
            if ((head)->last == cur)            \
                (head)->last = NULL;            \
        }                           \
        cur;                            \
    })

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

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

                                                       {                \
    typeof((head)->first) __list_next;                      \
    typeof((head)->first) __list_prev = NULL;                   \
    typeof((head)->first) __new_prev = NULL;                    \
    for ((var) = (head)->first, __new_prev = (var),                 \
          __list_next = (var) ? (var)->field.next : NULL;               \
         (var);                                 \
         __list_prev = __new_prev, (var) = __list_next,             \
         __new_prev = (var),                            \
         __list_next = (var) ? (var)->field.next : NULL             \
        )

◆ AST_LIST_TRAVERSE_SAFE_END

#define AST_LIST_TRAVERSE_SAFE_END }

Closes a safe loop traversal block.

Definition at line 1870 of file extconf.c.

◆ AST_MAX_EXTENSION

#define AST_MAX_EXTENSION 80

Max length of an extension

Definition at line 2074 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.

◆ ast_opt_always_fork

#define ast_opt_always_fork ast_test_flag64(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)

Definition at line 1383 of file extconf.c.

◆ ast_opt_cache_record_files

#define ast_opt_cache_record_files ast_test_flag64(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)

Definition at line 1377 of file extconf.c.

◆ ast_opt_console

#define ast_opt_console ast_test_flag64(&ast_options, AST_OPT_FLAG_CONSOLE)

Definition at line 1367 of file extconf.c.

◆ ast_opt_dont_warn

#define ast_opt_dont_warn ast_test_flag64(&ast_options, AST_OPT_FLAG_DONT_WARN)

Definition at line 1382 of file extconf.c.

◆ ast_opt_dump_core

#define ast_opt_dump_core ast_test_flag64(&ast_options, AST_OPT_FLAG_DUMP_CORE)

Definition at line 1376 of file extconf.c.

◆ ast_opt_exec

#define ast_opt_exec ast_test_flag64(&ast_options, AST_OPT_FLAG_EXEC)

Definition at line 1371 of file extconf.c.

◆ ast_opt_exec_includes

#define ast_opt_exec_includes ast_test_flag64(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)

Definition at line 1364 of file extconf.c.

◆ ast_opt_high_priority

#define ast_opt_high_priority ast_test_flag64(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)

Definition at line 1368 of file extconf.c.

◆ ast_opt_init_keys

#define ast_opt_init_keys ast_test_flag64(&ast_options, AST_OPT_FLAG_INIT_KEYS)

Definition at line 1369 of file extconf.c.

◆ ast_opt_mute

#define ast_opt_mute ast_test_flag64(&ast_options, AST_OPT_FLAG_MUTE)

Definition at line 1384 of file extconf.c.

◆ ast_opt_no_color

#define ast_opt_no_color ast_test_flag64(&ast_options, AST_OPT_FLAG_NO_COLOR)

Definition at line 1372 of file extconf.c.

◆ ast_opt_no_fork

#define ast_opt_no_fork ast_test_flag64(&ast_options, AST_OPT_FLAG_NO_FORK)

Definition at line 1365 of file extconf.c.

◆ ast_opt_override_config

#define ast_opt_override_config ast_test_flag64(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)

Definition at line 1379 of file extconf.c.

◆ ast_opt_priority_jumping

#define ast_opt_priority_jumping ast_test_flag64(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)

Definition at line 1375 of file extconf.c.

◆ ast_opt_quiet

#define ast_opt_quiet ast_test_flag64(&ast_options, AST_OPT_FLAG_QUIET)

Definition at line 1366 of file extconf.c.

◆ ast_opt_reconnect

#define ast_opt_reconnect ast_test_flag64(&ast_options, AST_OPT_FLAG_RECONNECT)

Definition at line 1380 of file extconf.c.

◆ ast_opt_remote

#define ast_opt_remote ast_test_flag64(&ast_options, AST_OPT_FLAG_REMOTE)

Definition at line 1370 of file extconf.c.

◆ ast_opt_timestamp

#define ast_opt_timestamp ast_test_flag64(&ast_options, AST_OPT_FLAG_TIMESTAMP)

Definition at line 1378 of file extconf.c.

◆ ast_opt_transcode_via_slin

#define ast_opt_transcode_via_slin ast_test_flag64(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)

Definition at line 1374 of file extconf.c.

◆ ast_opt_transmit_silence

#define ast_opt_transmit_silence ast_test_flag64(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)

Definition at line 1381 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 2001 of file extconf.c.

◆ AST_RWLIST_EMPTY

#define AST_RWLIST_EMPTY AST_LIST_EMPTY

Definition at line 1731 of file extconf.c.

◆ AST_RWLIST_ENTRY

#define AST_RWLIST_ENTRY AST_LIST_ENTRY

Definition at line 1695 of file extconf.c.

◆ AST_RWLIST_FIRST

#define AST_RWLIST_FIRST AST_LIST_FIRST

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

AST_RWLIST_HEAD

#define AST_RWLIST_HEAD(name, type)

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

Definition linkedlists.h:199

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

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

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

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

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

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

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

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

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

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

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

AST_RWLIST_HEAD_STATIC

#define AST_RWLIST_HEAD_STATIC(name, type)

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

Definition linkedlists.h:333

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

Definition at line 1613 of file extconf.c.

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

◆ AST_RWLIST_INSERT_AFTER

#define AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER

Definition at line 1943 of file extconf.c.

◆ AST_RWLIST_INSERT_BEFORE_CURRENT

#define AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT

Definition at line 1865 of file extconf.c.

◆ AST_RWLIST_INSERT_HEAD

#define AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD

Definition at line 1959 of file extconf.c.

◆ AST_RWLIST_INSERT_TAIL

#define AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL

Definition at line 1982 of file extconf.c.

◆ AST_RWLIST_LAST

#define AST_RWLIST_LAST AST_LIST_LAST

Definition at line 1711 of file extconf.c.

◆ AST_RWLIST_NEXT

#define AST_RWLIST_NEXT AST_LIST_NEXT

Definition at line 1721 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 1420 of file extconf.c.

◆ AST_RWLIST_REMOVE

#define AST_RWLIST_REMOVE AST_LIST_REMOVE

Definition at line 2051 of file extconf.c.

◆ AST_RWLIST_REMOVE_CURRENT

#define AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT

Definition at line 1842 of file extconf.c.

◆ AST_RWLIST_REMOVE_HEAD

#define AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD

Definition at line 2023 of file extconf.c.

◆ AST_RWLIST_TRAVERSE

#define AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE

Definition at line 1772 of file extconf.c.

◆ AST_RWLIST_TRAVERSE_SAFE_BEGIN

#define AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN

Definition at line 1819 of file extconf.c.

◆ AST_RWLIST_TRAVERSE_SAFE_END

#define AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END

Definition at line 1872 of file extconf.c.

◆ 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 1431 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 1409 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_test_flag64

#define ast_test_flag64	(	p,
		flag
	)

Definition at line 685 of file extconf.c.

                                         { \
                    typeof ((p)->flags) __p = (p)->flags; \
                    typeof (__unsigned_int_flags_dummy64) __x = 0; \
                    (void) (&__p == (typeof(__p)*)&__x); \
                    ((p)->flags & SWAP64_32(flag)); \
                    })

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

◆ BACKGROUND_NOANSWER

#define BACKGROUND_NOANSWER (1 << 1)

Definition at line 2322 of file extconf.c.

◆ BACKGROUND_PLAYBACK

#define BACKGROUND_PLAYBACK (1 << 3)

Definition at line 2324 of file extconf.c.

◆ BACKGROUND_SKIP

#define BACKGROUND_SKIP (1 << 0)

Definition at line 2321 of file extconf.c.

◆ CB_INCR

#define CB_INCR 250

Definition at line 709 of file extconf.c.

◆ COMMENT_END

#define COMMENT_END "--;"

Definition at line 696 of file extconf.c.

◆ COMMENT_META

#define COMMENT_META ';'

Definition at line 697 of file extconf.c.

◆ COMMENT_START

#define COMMENT_START ";--"

Definition at line 695 of file extconf.c.

◆ COMMENT_TAG

#define COMMENT_TAG '-'

Definition at line 698 of file extconf.c.

◆ DEBUG_M

#define DEBUG_M ( a )

Value:

    { \
    a; \
}

Definition at line 96 of file extconf.c.

                   { \
    a; \
}

◆ EVENTLOG

#define EVENTLOG "event_log"

Definition at line 93 of file extconf.c.

◆ EXT_DATA_SIZE

#define EXT_DATA_SIZE 8192

Definition at line 3599 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.

◆ 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.

◆ 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.

◆ LOG_VERBOSE

#define LOG_VERBOSE __LOG_VERBOSE, _A_

Definition at line 151 of file extconf.c.

◆ LOG_WARNING

#define LOG_WARNING __LOG_WARNING, _A_

Definition at line 139 of file extconf.c.

◆ MAX_INCLUDE_LEVEL

#define MAX_INCLUDE_LEVEL 10

Definition at line 893 of file extconf.c.

◆ MAX_NESTED_COMMENTS

#define MAX_NESTED_COMMENTS 128

Definition at line 694 of file extconf.c.

◆ ONE_MILLION

#define ONE_MILLION 1000000

Definition at line 2257 of file extconf.c.

◆ PRIORITY_HINT

#define PRIORITY_HINT -1

Special Priority for a hint

Definition at line 2078 of file extconf.c.

◆ 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.

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

◆ STATUS_NO_CONTEXT

#define STATUS_NO_CONTEXT 1

Definition at line 2444 of file extconf.c.

◆ STATUS_NO_EXTENSION

#define STATUS_NO_EXTENSION 2

Definition at line 2445 of file extconf.c.

◆ STATUS_NO_LABEL

#define STATUS_NO_LABEL 4

Definition at line 2447 of file extconf.c.

◆ STATUS_NO_PRIORITY

#define STATUS_NO_PRIORITY 3

Definition at line 2446 of file extconf.c.

◆ STATUS_SUCCESS

#define STATUS_SUCCESS 5

Definition at line 2448 of file extconf.c.

◆ SWAP64_32

#define SWAP64_32 ( flags ) (((uint64_t)(flags) << 32) | ((uint64_t)(flags) >> 32))

Definition at line 678 of file extconf.c.

◆ SWITCH_DATA_LENGTH

#define SWITCH_DATA_LENGTH 256

Definition at line 3606 of file extconf.c.

◆ VAR_BUF_SIZE

#define VAR_BUF_SIZE 4096

Definition at line 2315 of file extconf.c.

◆ VAR_HARDTRAN

#define VAR_HARDTRAN 3

Definition at line 2319 of file extconf.c.

◆ VAR_NORMAL

#define VAR_NORMAL 1

Definition at line 2317 of file extconf.c.

◆ VAR_SOFTTRAN

#define VAR_SOFTTRAN 2

Definition at line 2318 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.

◆ VERBOSE_PREFIX_3

#define VERBOSE_PREFIX_3 " -- "

Definition at line 102 of file extconf.c.

◆ 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 2349 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 2101 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 931 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 933 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 934 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 932 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

Definition at line 2080 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_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 1306 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 4702 of file extconf.c.

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

References ast_calloc, ast_log, 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, name, ast_context::name, ast_context::next, NULL, option_debug, option_verbose, registrar, ast_context::registrar, ast_context::root, and VERBOSE_PREFIX_3.

Referenced by ast_context_find_or_create(), and localized_context_find_or_create().

◆ __ast_context_destroy()

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

static

Definition at line 5497 of file extconf.c.

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

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

Referenced by ast_merge_contexts_and_delete(), and localized_context_destroy().

◆ _extension_match_core()

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

static

Definition at line 4187 of file extconf.c.

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

References ast_log, ast_context::data, E_MATCH, E_MATCH_MASK, E_MATCHMORE, end, LOG_WARNING, and NULL.

Referenced by extension_match_core().

◆ _null_sig_handler()

static void _null_sig_handler ( int sig )

static

NULL handler so we can collect the child exit status.

Definition at line 787 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 3671 of file extconf.c.

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

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

Referenced by ast_add_extension2().

◆ ALLOC_COMMENT()

static struct ast_comment * ALLOC_COMMENT ( const char * buffer )

static

Definition at line 875 of file extconf.c.

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

References ast_calloc, and ast_comment::cmt.

Referenced by process_text_line().

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

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

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

Referenced by localized_add_extension2(), and pbx_load_config().

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

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

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

Referenced by add_pri(), and ast_add_extension2().

◆ ast_app_separate_args()

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

static

Definition at line 2482 of file extconf.c.

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

References array(), buf, paren, and quote().

◆ 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.

◆ 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.

◆ 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_in	Standard string containing a timerange, weekday range, monthday range, and month range, as well as an optional timezone.

Return values

1	on success.
0	on failure.

Definition at line 3802 of file extconf.c.

{
    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] == '|' || 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;
}

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

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

◆ ast_category_append()

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

static

Definition at line 2829 of file extconf.c.

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

Referenced by process_text_line().

◆ ast_category_browse()

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

static

Definition at line 3322 of file extconf.c.

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

Referenced by pbx_load_config().

◆ ast_category_destroy()

static void ast_category_destroy ( struct ast_category * cat )

static

Definition at line 2841 of file extconf.c.

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

Referenced by process_text_line().

◆ ast_category_get()

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

static

Definition at line 1208 of file extconf.c.

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

References category_get(), and config.

Referenced by ast_variable_browse().

◆ ast_category_new()

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

static

Definition at line 2784 of file extconf.c.

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

Referenced by process_text_line().

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

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

References AST_RWLIST_TRAVERSE, ast_hint::exten, and ast_hint::list.

Referenced by add_pri().

◆ 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

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

Definition at line 3996 of file extconf.c.

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

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

◆ ast_config_destroy()

static void ast_config_destroy ( struct ast_config * cfg )

static

Definition at line 1287 of file extconf.c.

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

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

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

{
    return cfg->current;
}

References ast_config::current.

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

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

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

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

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

◆ ast_config_new()

static struct ast_config * ast_config_new ( void )

static

Definition at line 3270 of file extconf.c.

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

Referenced by localized_config_load(), and localized_config_load_with_comments().

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

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

References ast_config::current.

◆ ast_console_puts()

void ast_console_puts ( const char * string )

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

Definition at line 1368 of file asterisk.c.

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

◆ ast_context_add_ignorepat2()

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

static

Definition at line 4563 of file extconf.c.

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

References ast_calloc, errno, ast_context::ignorepats, ast_ignorepat::next, NULL, ast_ignorepat::pattern, registrar, ast_ignorepat::registrar, and value.

Referenced by localized_context_add_ignorepat2(), and pbx_load_config().

◆ ast_context_add_include2()

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

static

Definition at line 4497 of file extconf.c.

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

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

Referenced by localized_context_add_include2(), and pbx_load_config().

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

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

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, ast_sw::name, option_verbose, registrar, ast_sw::registrar, ast_sw::stuff, SWITCH_DATA_LENGTH, ast_sw::tmpdata, value, and VERBOSE_PREFIX_3.

Referenced by localized_context_add_switch2(), and pbx_load_config().

◆ ast_context_find()

static struct ast_context * ast_context_find ( const char * name )

static

Definition at line 4168 of file extconf.c.

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

Referenced by ast_context_verify_includes().

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

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

References __ast_context_create(), name, and registrar.

Referenced by pbx_load_config().

◆ ast_context_ignorepats_count()

int ast_context_ignorepats_count ( struct ast_context * con )

Definition at line 4119 of file extconf.c.

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

References ast_walk_context_ignorepats(), c, and NULL.

◆ ast_context_includes_count()

int ast_context_includes_count ( struct ast_context * con )

Definition at line 4086 of file extconf.c.

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

References ast_walk_context_includes(), c, and NULL.

◆ ast_context_switches_count()

int ast_context_switches_count ( struct ast_context * con )

Definition at line 4153 of file extconf.c.

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

References ast_walk_context_switches(), c, and NULL.

◆ ast_context_verify_includes()

static int ast_context_verify_includes ( struct ast_context * con )

static

Definition at line 5616 of file extconf.c.

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

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

◆ ast_copy_string()

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

Definition at line 968 of file extconf.c.

References str.

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

◆ ast_extension_match()

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

static

Definition at line 4291 of file extconf.c.

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

Referenced by matchcid().

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

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

Referenced by pbx_load_config().

◆ ast_func_read()

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

static

Definition at line 4989 of file extconf.c.

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

References ast_log, and LOG_ERROR.

Referenced by pbx_substitute_variables_helper_full().

◆ ast_func_write()

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

static

Definition at line 2474 of file extconf.c.

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

Referenced by pbx_builtin_setvar_helper().

◆ ast_get_context_name()

static const char * ast_get_context_name ( struct ast_context * con )

static

Definition at line 4482 of file extconf.c.

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

References ast_context::name, and NULL.

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

◆ ast_get_extension_app()

static const char * ast_get_extension_app ( struct ast_exten * e )

static

Definition at line 3608 of file extconf.c.

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

References ast_exten::app, and NULL.

Referenced by ast_add_hint().

◆ ast_get_extension_name()

static const char * ast_get_extension_name ( struct ast_exten * exten )

static

Definition at line 3613 of file extconf.c.

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

References ast_exten::exten, and NULL.

Referenced by ast_add_hint().

◆ ast_include_find()

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

static

Definition at line 1161 of file extconf.c.

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

Referenced by ast_include_new().

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

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

Referenced by process_text_line().

◆ ast_includes_destroy()

static void ast_includes_destroy ( struct ast_config_include * incls )

static

Definition at line 1271 of file extconf.c.

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

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

◆ ast_log()

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

static

Definition at line 2190 of file extconf.c.

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

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

◆ ast_mark_lock_failed()

void ast_mark_lock_failed ( void * lock_addr )

Definition at line 2309 of file extconf.c.

{
    /* Pretend to do something. */
}

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

◆ ast_merge_contexts_and_delete()

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

static

Definition at line 5566 of file extconf.c.

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

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

◆ ast_mutex_init()

static int ast_mutex_init ( ast_mutex_t * pmutex )

inlinestatic

Definition at line 469 of file extconf.c.

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

References AST_MUTEX_KIND, and pthread_mutex_init.

◆ ast_process_quotes_and_slashes()

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

static

Definition at line 2214 of file extconf.c.

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

Referenced by pbx_load_config().

◆ ast_queue_log()

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

Definition at line 973 of file logger.c.

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

Referenced by logger_queue_start(), and reload_logger().

◆ ast_remove_hint()

static int ast_remove_hint ( struct ast_exten * e )

static

ast_remove_hint: Remove hint from extension

Definition at line 3729 of file extconf.c.

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

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

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

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

References null_sig_handler, safe_system_level, and safe_system_prev_handler.

Referenced by ast_safe_fork(), ast_safe_system(), and handle_include_exec().

◆ ast_rwlock_destroy()

static int ast_rwlock_destroy ( ast_rwlock_t * prwlock )

inlinestatic

Definition at line 529 of file extconf.c.

{
    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.

{
    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.

{
    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.

{
    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.

{
    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 827 of file extconf.c.

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

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

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

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

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

Referenced by pbx_load_config().

◆ ast_skip_blanks()

char * ast_skip_blanks ( const char * str )

Definition at line 977 of file extconf.c.

References str.

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

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

Referenced by config_text_file_load(), and process_text_line().

◆ ast_strlen_zero()

static force_inline int ast_strlen_zero ( const char * s )

static

Definition at line 950 of file extconf.c.

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

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

◆ ast_trim_blanks()

char * ast_trim_blanks ( char * str )

Trims trailing whitespace characters from a string.

Parameters

str	the input string

Returns: a pointer to the modified string

Definition at line 1002 of file extconf.c.

References ast_skip_blanks(), and ast_trim_blanks().

Referenced by ast_trim_blanks().

◆ ast_true()

static int ast_true ( const char * s )

static

Definition at line 2240 of file extconf.c.

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

References ast_strlen_zero().

Referenced by pbx_load_config().

◆ ast_tvadd()

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

Returns the sum of two timevals a + b.

Definition at line 2278 of file extconf.c.

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

References a, b, 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_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_and_jitter(), calc_timestamp(), cli_show_tasks(), cli_tps_ping(), conf_run(), consumer_should_stay(), dial_exec_full(), do_cdr(), do_timing(), expire_objects_from_cache(), handler_wait_for_message(), hook_event_cb(), iax2_process_thread(), jb_get_and_deliver(), jitterbuffer_frame_get_ntp_timestamp(), make_deadline(), mb_poll_thread(), monmp3thread(), mp3_exec(), mwi_monitor_handler(), 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(), stasis_app_broadcast_wait(), subscription_persistence_update(), timeout_write(), user_event_wait_for_events(), and wait_for_stimulus().

◆ ast_tvnow()

struct timeval ast_tvnow ( void )

Definition at line 5667 of file extconf.c.

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

References NULL.

◆ ast_tvsub()

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

Returns the difference of two timevals a - b.

Definition at line 2293 of file extconf.c.

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

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

Referenced by action_login(), ast_poll2(), ast_sched_dump(), AST_TEST_DEFINE(), ast_translate(), ast_waitfor_nandfds(), calc_rxstamp(), calc_rxstamp_and_jitter(), 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().

◆ ast_unlock_context()

static int ast_unlock_context ( struct ast_context * con )

static

Definition at line 4620 of file extconf.c.

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

References ast_rwlock_unlock, and ast_context::lock.

Referenced by __ast_context_destroy().

◆ ast_unlock_contexts()

static int ast_unlock_contexts ( void )

static

Definition at line 4610 of file extconf.c.

{
    return ast_rwlock_unlock(&conlock);
}

References ast_rwlock_unlock, and conlock.

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

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

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

References NULL, safe_system_level, and safe_system_prev_handler.

Referenced by ast_safe_fork_cleanup(), ast_safe_system(), and handle_include_exec().

◆ ast_var_assign()

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

static

Definition at line 2450 of file extconf.c.

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

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

◆ ast_var_delete()

static void ast_var_delete ( struct ast_var_t * var )

static

Definition at line 2467 of file extconf.c.

{
    free(var);
}

Referenced by pbx_builtin_setvar_helper().

◆ ast_var_name()

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

static

Definition at line 2166 of file extconf.c.

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

References name, NULL, and var.

Referenced by pbx_builtin_setvar_helper(), and pbx_retrieve_variable().

◆ ast_var_value()

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

static

Definition at line 5021 of file extconf.c.

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

References NULL, and var.

Referenced by pbx_retrieve_variable().

◆ ast_variable_append()

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

static

Definition at line 1175 of file extconf.c.

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

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

◆ ast_variable_browse()

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

static

Definition at line 1213 of file extconf.c.

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

Referenced by ast_variable_retrieve(), and pbx_load_config().

◆ ast_variable_new()

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

static

Definition at line 1053 of file extconf.c.

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

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

◆ ast_variable_retrieve()

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

static

Definition at line 1225 of file extconf.c.

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

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

Referenced by pbx_load_config().

◆ ast_variables_destroy()

static void ast_variables_destroy ( struct ast_variable * v )

static

Definition at line 1260 of file extconf.c.

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

Referenced by ast_category_destroy(), and ast_config_destroy().

◆ ast_verbose()

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

Definition at line 2202 of file extconf.c.

{
    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 4036 of file extconf.c.

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

References ast_exten::exten, ast_exten::next, NULL, and ast_context::root.

Referenced by localized_walk_context_extensions(), and pbx_find_extension().

◆ ast_walk_context_ignorepats()

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

static

Definition at line 4109 of file extconf.c.

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

References ast_context::ignorepats, ast_ignorepat::next, and NULL.

Referenced by ast_context_ignorepats_count().

◆ ast_walk_context_includes()

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

static

Definition at line 4076 of file extconf.c.

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

References ast_context::includes, ast_include::next, and NULL.

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

◆ ast_walk_context_switches()

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

static

Definition at line 4135 of file extconf.c.

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

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

Referenced by ast_context_switches_count(), and localized_walk_context_switches().

◆ ast_walk_contexts()

static struct ast_context * ast_walk_contexts ( struct ast_context * con )

static

Definition at line 4020 of file extconf.c.

{
    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 4057 of file extconf.c.

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

Referenced by localized_walk_extension_priorities(), and pbx_find_extension().

◆ ast_wrlock_context()

static int ast_wrlock_context ( struct ast_context * con )

static

Definition at line 4615 of file extconf.c.

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

References ast_rwlock_wrlock, and ast_context::lock.

Referenced by __ast_context_destroy().

◆ ast_wrlock_contexts()

static int ast_wrlock_contexts ( void )

static

Definition at line 4605 of file extconf.c.

{
    return ast_rwlock_wrlock(&conlock);
}

References ast_rwlock_wrlock, and conlock.

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

◆ category_get()

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

static

Definition at line 1190 of file extconf.c.

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

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

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

◆ CB_ADD()

static void CB_ADD ( char * str )

static

Definition at line 735 of file extconf.c.

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

References ast_realloc, CB_INCR, comment_buffer, comment_buffer_size, and str.

Referenced by config_text_file_load().

◆ CB_ADD_LEN()

static void CB_ADD_LEN	(	char *	str,
		int	len
	)

static

Definition at line 748 of file extconf.c.

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

References ast_realloc, CB_INCR, comment_buffer, comment_buffer_size, len(), and str.

Referenced by config_text_file_load().

◆ CB_INIT()

static void CB_INIT ( void )

static

Definition at line 716 of file extconf.c.

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

References ast_malloc, CB_INCR, comment_buffer, comment_buffer_size, lline_buffer, and lline_buffer_size.

Referenced by config_text_file_load().

◆ CB_RESET()

static void CB_RESET ( void )

static

Definition at line 775 of file extconf.c.

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

References comment_buffer, and lline_buffer.

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

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

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

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

◆ destroy_exten()

static void destroy_exten ( struct ast_exten * e )

static

Definition at line 3761 of file extconf.c.

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

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

Referenced by __ast_context_destroy().

◆ ext_cmp()

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

static

the full routine to compare extensions in rules.

Definition at line 3940 of file extconf.c.

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

References a, b, and ext_cmp1().

Referenced by ast_add_extension2().

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

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

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

Referenced by ext_cmp().

◆ ext_strncpy()

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

static

copy a string skipping whitespace

Definition at line 3967 of file extconf.c.

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

References len().

Referenced by ast_add_extension2().

◆ extension_match_core()

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

static

Definition at line 4282 of file extconf.c.

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

References _extension_match_core(), and ast_context::data.

Referenced by ast_extension_match(), and pbx_find_extension().

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

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

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

Referenced by ast_config_internal_load().

◆ gen_header()

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

static

Definition at line 3384 of file extconf.c.

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

References ast_copy_string().

Referenced by localized_config_text_file_save().

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

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

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

Referenced by ast_build_timing().

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

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

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

Referenced by ast_build_timing().

◆ include_valid()

static int include_valid ( struct ast_include * i )

inlinestatic

Definition at line 4307 of file extconf.c.

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

References ast_check_timing(), ast_include::hastime, and ast_include::timing.

Referenced by pbx_find_extension().

◆ inherit_category()

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

static

Definition at line 2819 of file extconf.c.

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

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

Referenced by process_text_line().

◆ LLB_ADD()

static void LLB_ADD ( char * str )

static

Definition at line 762 of file extconf.c.

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

References ast_realloc, CB_INCR, lline_buffer, lline_buffer_size, and str.

Referenced by config_text_file_load().

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

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

References ast_add_extension2(), ast_exten::data, ast_exten::datad, ast_exten::label, priority, registrar, and replace().

◆ localized_ast_include_rename()

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

Definition at line 1108 of file extconf.c.

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

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

◆ localized_category_get()

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

Definition at line 2797 of file extconf.c.

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

References category_get(), and config.

◆ localized_config_load()

struct ast_config * localized_config_load ( const char * filename )

Definition at line 3281 of file extconf.c.

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

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

Referenced by pbx_load_config().

◆ localized_config_load_with_comments()

struct ast_config * localized_config_load_with_comments ( const char * filename )

Definition at line 3299 of file extconf.c.

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

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), NULL, and 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 3417 of file extconf.c.

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

References ast_log, ast_verbose, ast_comment::cmt, errno, ast_config_include::exec, ast_config_include::exec_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_category::lineno, LOG_DEBUG, ast_category::name, ast_comment::next, ast_category::next, ast_config_include::next, option_debug, option_verbose, ast_config_include::output, ast_category::precomments, ast_category::root, ast_config::root, ast_category::sameline, set_fn(), var, and VERBOSE_PREFIX_2.

◆ localized_context_add_ignorepat2()

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

Definition at line 4595 of file extconf.c.

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

References ast_context_add_ignorepat2(), registrar, and value.

◆ localized_context_add_include2()

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

Definition at line 4553 of file extconf.c.

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

References ast_context_add_include2(), registrar, and value.

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

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

References ast_context_add_switch2(), ast_sw::data, ast_sw::eval, registrar, and value.

◆ localized_context_destroy()

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

Definition at line 5558 of file extconf.c.

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

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

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

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

References __ast_context_create(), name, and registrar.

◆ localized_context_verify_includes()

int localized_context_verify_includes ( struct ast_context * con )

Definition at line 5633 of file extconf.c.

{
    return ast_context_verify_includes(con);
}

References ast_context_verify_includes().

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

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

References ast_exten::exten, ast_exten::label, NULL, pbx_find_extension(), and priority.

Referenced by pbx_find_extension().

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

{
    ast_merge_contexts_and_delete(extcontexts, registrar);
}

References ast_merge_contexts_and_delete(), and registrar.

◆ localized_pbx_builtin_setvar()

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

Definition at line 2601 of file extconf.c.

{
    return pbx_builtin_setvar(chan, data);
}

References pbx_builtin_setvar().

◆ localized_pbx_load_module()

int localized_pbx_load_module ( void )

Definition at line 5640 of file extconf.c.

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

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

Referenced by check_goto(), and check_pval_item().

◆ localized_use_conf_dir()

void localized_use_conf_dir ( void )

Definition at line 3109 of file extconf.c.

{
    use_local_dir = 0;
}

References use_local_dir.

Referenced by main().

◆ localized_use_local_dir()

void localized_use_local_dir ( void )

Definition at line 3104 of file extconf.c.

{
    use_local_dir = 1;
}

References use_local_dir.

Referenced by main().

◆ localized_walk_context_extensions()

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

Definition at line 4047 of file extconf.c.

{
    return ast_walk_context_extensions(con,exten);
}

References ast_walk_context_extensions(), and ast_exten::exten.

◆ localized_walk_context_includes()

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

Definition at line 4100 of file extconf.c.

{
    return ast_walk_context_includes(con, inc);
}

References ast_walk_context_includes().

◆ localized_walk_context_switches()

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

Definition at line 4146 of file extconf.c.

{
    return ast_walk_context_switches(con, sw);
}

References ast_walk_context_switches().

◆ localized_walk_contexts()

struct ast_context * localized_walk_contexts ( struct ast_context * con )

Definition at line 4026 of file extconf.c.

{
    return ast_walk_contexts(con);
}

References ast_walk_contexts().

◆ localized_walk_extension_priorities()

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

Definition at line 4065 of file extconf.c.

{
    return ast_walk_extension_priorities(exten, priority);
}

References ast_walk_extension_priorities(), ast_exten::exten, and 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 2611 of file extconf.c.

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

References max.

Referenced by get_range().

◆ matchcid()

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

static

Definition at line 4296 of file extconf.c.

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

References ast_extension_match(), and ast_strlen_zero().

Referenced by pbx_find_extension().

◆ move_variables()

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

static

Definition at line 2802 of file extconf.c.

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

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

Referenced by process_text_line().

◆ next_available_category()

static struct ast_category * next_available_category ( struct ast_category * cat )

static

Definition at line 3315 of file extconf.c.

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

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

Referenced by ast_category_browse().

◆ null_datad()

static void null_datad ( void * foo )

static

Definition at line 2738 of file extconf.c.

2739{

2740}

Referenced by ast_add_extension2().

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

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

References var.

Referenced by pbx_retrieve_variable(), and pbx_substitute_variables_helper_full().

◆ pbx_builtin_setvar()

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

static

Definition at line 2564 of file extconf.c.

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

References ast_app_separate_args, ast_log, ast_strdupa, ast_strlen_zero(), global, LOG_WARNING, name, NULL, pbx_builtin_setvar_helper(), and value.

Referenced by localized_pbx_builtin_setvar().

◆ pbx_builtin_setvar_helper()

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

static

Definition at line 2524 of file extconf.c.

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

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, name, option_verbose, value, and VERBOSE_PREFIX_2.

Referenced by pbx_builtin_setvar(), and pbx_load_config().

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

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

References 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, option_debug, pbx_find_extension(), priority, 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().

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

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

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, pbx_find_info::data, E_CANMATCH, E_FINDLABEL, E_MATCHMORE, 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, LOG_WARNING, match(), ast_exten::matchcid, matchcid(), ast_switch::matchmore, ast_context::name, ast_include::next, NULL, pbx_find_extension(), pbx_findswitch(), priority, 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, and pbx_find_info::swo.

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

◆ pbx_load_config()

static int pbx_load_config ( const char * config_file )

static

Definition at line 5332 of file extconf.c.

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

References 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(), autofallthrough_config, clearglobalvars_config, config_file, end, ext, free(), global_registrar, ast_variable::lineno, local_contexts, localized_config_load(), LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), PRIORITY_HINT, S_OR, static_config, strsep(), userscontext, ast_variable::value, and write_protect_config.

Referenced by localized_pbx_load_module().

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

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

References c, NULL, and pbx_substitute_variables_helper_full().

Referenced by pbx_load_config().

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

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

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

Referenced by pbx_substitute_variables_helper(), and pbx_substitute_variables_helper_full().

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

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

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(), comment_buffer, inherit_category(), ast_variable::lineno, ast_category::lineno, lline_buffer, 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().

◆ set_fn()

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

static

Definition at line 3402 of file extconf.c.

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

References ast_config_AST_CONFIG_DIR, ast_copy_string(), and ast_category::file.

Referenced by localized_config_text_file_save().

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

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

References ast_copy_string(), and value.

Referenced by pbx_retrieve_variable(), and pbx_substitute_variables_helper_full().

◆ tvfix()

static struct timeval tvfix ( struct timeval a )

static

Definition at line 2262 of file extconf.c.

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

References a, ast_log, LOG_WARNING, and ONE_MILLION.

◆ variable_clone()

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

static

Definition at line 1246 of file extconf.c.

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

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

Variable Documentation

◆ __unsigned_int_flags_dummy64

uint64_t __unsigned_int_flags_dummy64

extern

◆ ast_defaultlanguage

char ast_defaultlanguage[]

extern

Definition at line 99 of file options.c.

Referenced by load_asterisk_conf().

◆ ast_mainpid

pid_t ast_mainpid

extern

Definition at line 323 of file asterisk.c.

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

◆ autofallthrough_config

int autofallthrough_config = 0

static

Definition at line 2121 of file extconf.c.

Referenced by pbx_load_config().

◆ clearglobalvars_config

int clearglobalvars_config = 0

static

Definition at line 2122 of file extconf.c.

Referenced by pbx_load_config().

◆ comment_buffer

char* comment_buffer

static

Growable string buffer this will be a comment collector.

Definition at line 703 of file extconf.c.

Referenced by CB_ADD(), CB_ADD_LEN(), CB_INIT(), CB_RESET(), config_text_file_load(), config_text_file_load(), process_text_line(), and process_text_line().

◆ comment_buffer_size

int comment_buffer_size

static

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

Definition at line 704 of file extconf.c.

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

◆ config_engine_list

static struct ast_config_engine * config_engine_list

static

Definition at line 891 of file extconf.c.

Referenced by ast_config_internal_load(), and find_engine().

◆ config_filename

char* config_filename = "extensions.conf"

static

Definition at line 2116 of file extconf.c.

Referenced by AST_TEST_DEFINE(), config_alloc(), load_database_config(), load_database_config_file(), load_text_file_advanced_config(), load_text_file_config_file(), load_text_file_legacy_config(), load_text_file_legacy_mappings(), localized_pbx_load_module(), parse_config(), and parse_legacy_template().

◆ config_maps

struct ast_config_map * config_maps = NULL

static

Referenced by find_engine().

◆ conlock

ast_rwlock_t conlock = AST_RWLOCK_INIT_VALUE

static

Lock for the ast_context list

Definition at line 4478 of file extconf.c.

Referenced by ast_unlock_contexts(), and ast_wrlock_contexts().

◆ contexts

static struct ast_context * contexts = NULL

static

Definition at line 3593 of file extconf.c.

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

◆ days

char* days[]

Definition at line 3771 of file extconf.c.

{
    "sun",
    "mon",
    "tue",
    "wed",
    "thu",
    "fri",
    "sat",
    NULL,
};

Referenced by ast_build_timing().

◆ debug_filename

char debug_filename[AST_FILENAME_MAX]

extern

◆ extconfig_conf

char* extconfig_conf = "extconfig.conf"

static

Definition at line 700 of file extconf.c.

Referenced by ast_config_internal_load().

◆ global_registrar

char* global_registrar = "conf2ael"

static

Definition at line 2117 of file extconf.c.

Referenced by localized_pbx_load_module(), and pbx_load_config().

◆ globals

struct varshead globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE

static

Definition at line 2064 of file extconf.c.

Referenced by pbx_builtin_setvar_helper(), and pbx_retrieve_variable().

◆ globalslock

ast_rwlock_t globalslock = AST_RWLOCK_INIT_VALUE

static

Definition at line 2063 of file extconf.c.

Referenced by pbx_retrieve_variable().

◆ hints

struct hints hints = AST_RWLIST_HEAD_INIT_VALUE

static

◆ lline_buffer

char* lline_buffer

static

A buffer for stuff behind the ;

Definition at line 706 of file extconf.c.

Referenced by CB_INIT(), CB_RESET(), config_text_file_load(), config_text_file_load(), LLB_ADD(), process_text_line(), and process_text_line().

◆ lline_buffer_size

int lline_buffer_size

static

Definition at line 707 of file extconf.c.

Referenced by CB_INIT(), config_text_file_load(), and LLB_ADD().

◆ local_contexts

struct ast_context* local_contexts = NULL

static

Definition at line 3592 of file extconf.c.

Referenced by localized_pbx_load_module(), and pbx_load_config().

◆ months

char* months[]

Definition at line 3783 of file extconf.c.

{
    "jan",
    "feb",
    "mar",
    "apr",
    "may",
    "jun",
    "jul",
    "aug",
    "sep",
    "oct",
    "nov",
    "dec",
    NULL,
};

Referenced by ast_build_timing().

◆ null_sig_handler

struct sigaction null_sig_handler

static

Initial value:

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

Definition at line 792 of file extconf.c.

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

Referenced by ast_replace_sigchld().

◆ record_cache_dir

char record_cache_dir[AST_CACHE_DIR_LEN]

extern

Definition at line 97 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 783 of file extconf.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

◆ safe_system_prev_handler

struct sigaction safe_system_prev_handler

static

Definition at line 784 of file extconf.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

◆ static_config

int static_config = 0

static

Definition at line 2119 of file extconf.c.

Referenced by pbx_load_config().

◆ text_file_engine

struct ast_config_engine text_file_engine

static

Initial value:

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

Definition at line 2850 of file extconf.c.

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

Referenced by ast_config_internal_load().

◆ use_local_dir

int use_local_dir = 1

static

Definition at line 3099 of file extconf.c.

Referenced by config_text_file_load(), localized_use_conf_dir(), and localized_use_local_dir().

◆ userscontext

char userscontext[AST_MAX_EXTENSION] = "default"

static

Definition at line 2118 of file extconf.c.

Referenced by pbx_load_config().

◆ write_protect_config

int write_protect_config = 1

static

Definition at line 2120 of file extconf.c.

Referenced by pbx_load_config().

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