extconf.c File Reference

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

Go to the source code of this file.

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_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)
#define	AST_LIST_APPEND_LIST(head, list, field)
	Appends a whole list to the tail of a list. More...
#define	AST_LIST_EMPTY(head)   (AST_LIST_FIRST(head) == NULL)
	Checks whether the specified list contains any entries. More...
#define	AST_LIST_ENTRY(type)
	Declare a forward link structure inside a list entry. More...
#define	AST_LIST_FIRST(head)   ((head)->first)
	Returns the first entry contained in a list. More...
#define	AST_LIST_HEAD(name, type)
	Defines a structure to be used to hold a list of specified type. More...
#define	AST_LIST_HEAD_INIT(head)
	Initializes a list head structure. More...
#define	AST_LIST_HEAD_INIT_NOLOCK(head)
	Initializes a list head structure. More...
#define	AST_LIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD. More...
#define	AST_LIST_HEAD_NOLOCK(name, type)
	Defines a structure to be used to hold a list of specified type (with no lock). More...
#define	AST_LIST_HEAD_NOLOCK_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK. More...
#define	AST_LIST_HEAD_NOLOCK_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized. More...
#define	AST_LIST_HEAD_SET(head, entry)
	Initializes a list head structure with a specified first entry. More...
#define	AST_LIST_HEAD_SET_NOLOCK(head, entry)
	Initializes a list head structure with a specified first entry. More...
#define	AST_LIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized. More...
#define	AST_LIST_INSERT_AFTER(head, listelm, elm, field)
	Inserts a list entry after a given entry. More...
#define	AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field)
	Inserts a list entry before the current entry during a traversal. More...
#define	AST_LIST_INSERT_HEAD(head, elm, field)
	Inserts a list entry at the head of a list. More...
#define	AST_LIST_INSERT_TAIL(head, elm, field)
	Appends a list entry to the tail of a list. More...
#define	AST_LIST_LAST(head)   ((head)->last)
	Returns the last entry contained in a list. More...
#define	AST_LIST_NEXT(elm, field)   ((elm)->field.next)
	Returns the next entry in the list after the given entry. More...
#define	AST_LIST_REMOVE(head, elm, field)
	Removes a specific entry from a list. More...
#define	AST_LIST_REMOVE_CURRENT(head, field)
	Removes the current entry from a list during a traversal. More...
#define	AST_LIST_REMOVE_HEAD(head, field)
	Removes and returns the head entry from a list. More...
#define	AST_LIST_TRAVERSE(head, var, field)    for((var) = (head)->first; (var); (var) = (var)->field.next)
	Loops over (traverses) the entries in a list. More...
#define	AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
	Loops safely over (traverses) the entries in a list. More...
#define	AST_LIST_TRAVERSE_SAFE_END   }
	Closes a safe loop traversal block. More...
#define	AST_MAX_EXTENSION   80
#define	AST_MUTEX_DEFINE_STATIC(mutex)   __AST_MUTEX_DEFINE(static, mutex)
#define	AST_MUTEX_INIT_VALUE   ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
#define	AST_MUTEX_INITIALIZER   __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
#define	AST_MUTEX_KIND   PTHREAD_MUTEX_RECURSIVE
#define	ast_opt_always_fork   ast_test_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)
#define	ast_opt_cache_record_files   ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)
#define	ast_opt_console   ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)
#define	ast_opt_dont_warn   ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)
#define	ast_opt_dump_core   ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)
#define	ast_opt_exec   ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)
#define	ast_opt_exec_includes   ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)
#define	ast_opt_high_priority   ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)
#define	ast_opt_init_keys   ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)
#define	ast_opt_mute   ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)
#define	ast_opt_no_color   ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)
#define	ast_opt_no_fork   ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)
#define	ast_opt_override_config   ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)
#define	ast_opt_priority_jumping   ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)
#define	ast_opt_quiet   ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)
#define	ast_opt_reconnect   ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)
#define	ast_opt_remote   ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)
#define	ast_opt_timestamp   ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)
#define	ast_opt_transcode_via_slin   ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)
#define	ast_opt_transmit_silence   ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)
#define	ast_pthread_mutex_init(pmutex, a)   pthread_mutex_init(pmutex,a)
#define	AST_PTHREADT_NULL   (pthread_t) -1
#define	AST_PTHREADT_STOP   (pthread_t) -2
#define	AST_RWLIST_APPEND_LIST   AST_LIST_APPEND_LIST
#define	AST_RWLIST_EMPTY   AST_LIST_EMPTY
#define	AST_RWLIST_ENTRY   AST_LIST_ENTRY
#define	AST_RWLIST_FIRST   AST_LIST_FIRST
#define	AST_RWLIST_HEAD(name, type)
	Defines a structure to be used to hold a read/write list of specified type. More...
#define	AST_RWLIST_HEAD_DESTROY(head)
	Destroys an rwlist head structure. More...
#define	AST_RWLIST_HEAD_INIT(head)
	Initializes an rwlist head structure. More...
#define	AST_RWLIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_RWLIST_HEAD. More...
#define	AST_RWLIST_HEAD_SET(head, entry)
	Initializes an rwlist head structure with a specified first entry. More...
#define	AST_RWLIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a read/write list of specified type, statically initialized. More...
#define	AST_RWLIST_INSERT_AFTER   AST_LIST_INSERT_AFTER
#define	AST_RWLIST_INSERT_BEFORE_CURRENT   AST_LIST_INSERT_BEFORE_CURRENT
#define	AST_RWLIST_INSERT_HEAD   AST_LIST_INSERT_HEAD
#define	AST_RWLIST_INSERT_TAIL   AST_LIST_INSERT_TAIL
#define	AST_RWLIST_LAST   AST_LIST_LAST
#define	AST_RWLIST_NEXT   AST_LIST_NEXT
#define	AST_RWLIST_RDLOCK(head)    ast_rwlock_rdlock(&(head)->lock)
	Read locks a list. More...
#define	AST_RWLIST_REMOVE   AST_LIST_REMOVE
#define	AST_RWLIST_REMOVE_CURRENT   AST_LIST_REMOVE_CURRENT
#define	AST_RWLIST_REMOVE_HEAD   AST_LIST_REMOVE_HEAD
#define	AST_RWLIST_TRAVERSE   AST_LIST_TRAVERSE
#define	AST_RWLIST_TRAVERSE_SAFE_BEGIN   AST_LIST_TRAVERSE_SAFE_BEGIN
#define	AST_RWLIST_TRAVERSE_SAFE_END   AST_LIST_TRAVERSE_SAFE_END
#define	AST_RWLIST_UNLOCK(head)    ast_rwlock_unlock(&(head)->lock)
	Attempts to unlock a read/write based list. More...
#define	AST_RWLIST_WRLOCK(head)    ast_rwlock_wrlock(&(head)->lock)
	Write locks a list. More...
#define	AST_RWLOCK_DEFINE_STATIC(rwlock)   __AST_RWLOCK_DEFINE(static, rwlock)
#define	AST_RWLOCK_INIT_VALUE   PTHREAD_RWLOCK_INITIALIZER
#define	ast_set2_flag(p, value, flag)
#define	ast_test_flag(p, flag)
#define	ASTMM_LIBC   ASTMM_IGNORE
#define	BACKGROUND_MATCHEXTEN   (1 << 2)
#define	BACKGROUND_NOANSWER   (1 << 1)
#define	BACKGROUND_PLAYBACK   (1 << 3)
#define	BACKGROUND_SKIP   (1 << 0)
#define	CB_INCR   250
#define	COMMENT_END   "--;"
#define	COMMENT_META   ';'
#define	COMMENT_START   ";--"
#define	COMMENT_TAG   '-'
#define	DEBUG_M(a)
#define	EVENTLOG   "event_log"
#define	EXT_DATA_SIZE   8192
#define	gethostbyname   __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
#define	LOG_DEBUG   __LOG_DEBUG, _A_
#define	LOG_DTMF   __LOG_DTMF, _A_
#define	LOG_ERROR   __LOG_ERROR, _A_
#define	LOG_EVENT   __LOG_EVENT, _A_
#define	LOG_NOTICE   __LOG_NOTICE, _A_
#define	LOG_VERBOSE   __LOG_VERBOSE, _A_
#define	LOG_WARNING   __LOG_WARNING, _A_
#define	MAX_INCLUDE_LEVEL   10
#define	MAX_NESTED_COMMENTS   128
#define	ONE_MILLION   1000000
#define	PRIORITY_HINT   -1
#define	pthread_cond_t   use_ast_cond_t_instead_of_pthread_cond_t
#define	pthread_create   __use_ast_pthread_create_instead__
#define	pthread_mutex_init   use_ast_mutex_init_instead_of_pthread_mutex_init
#define	PTHREAD_MUTEX_INIT_VALUE   PTHREAD_MUTEX_INITIALIZER
#define	pthread_mutex_t   use_ast_mutex_t_instead_of_pthread_mutex_t
#define	QUEUELOG   "queue_log"
#define	S_OR(a, b)   (!ast_strlen_zero(a) ? (a) : (b))
#define	STATUS_NO_CONTEXT   1
#define	STATUS_NO_EXTENSION   2
#define	STATUS_NO_LABEL   4
#define	STATUS_NO_PRIORITY   3
#define	STATUS_SUCCESS   5
#define	SWITCH_DATA_LENGTH   256
#define	VAR_BUF_SIZE   4096
#define	VAR_HARDTRAN   3
#define	VAR_NORMAL   1
#define	VAR_SOFTTRAN   2
#define	VERBOSE_PREFIX_1   " "
#define	VERBOSE_PREFIX_2   " == "
#define	VERBOSE_PREFIX_3   " -- "
#define	VERBOSE_PREFIX_4   " > "

Typedefs
typedef pthread_cond_t	ast_cond_t
typedef pthread_mutex_t	ast_mutex_t
typedef pthread_rwlock_t	ast_rwlock_t
typedef int(*	ast_state_cb_type) (char *context, char *id, enum ast_extension_states state, void *data)
typedef int()	ast_switch_f(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
typedef struct ast_config *	config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, int withcomments, const char *suggested_include_file)
typedef struct ast_config *	realtime_multi_get(const char *database, const char *table, va_list ap)
typedef int	realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)
typedef struct ast_variable *	realtime_var_get(const char *database, const char *table, va_list ap)

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

Functions
static struct ast_context *	__ast_context_create (struct ast_context **extcontexts, const char *name, const char *registrar, int existsokay)
static void	__ast_context_destroy (struct ast_context *con, const char *registrar)
static int	_extension_match_core (const char *pattern, const char *data, enum ext_match_t mode)
static void	_null_sig_handler (int sig)
	NULL handler so we can collect the child exit status. More...
static int	add_pri (struct ast_context *con, struct ast_exten *tmp, struct ast_exten *el, struct ast_exten *e, int replace)
	add the extension in the priority chain. returns 0 on success, -1 on failure More...
static struct ast_comment *	ALLOC_COMMENT (const char *buffer)
static int	ast_add_extension2 (struct ast_context *con, int replace, const char *extension, int priority, const char *label, const char *callerid, const char *application, void *data, void(*datad)(void *), const char *registrar)
	Main interface to add extensions to the list for out context. More...
static int	ast_add_hint (struct ast_exten *e)
	ast_add_hint: Add hint to hint list, check initial extension state More...
static unsigned int	ast_app_separate_args (char *buf, char delim, char **array, int arraylen)
int	ast_atomic_dec_and_test (volatile int *p)
	decrement *p by 1 and return true if the variable has reached 0. Useful e.g. to check if a refcount has reached 0. More...
int	ast_atomic_fetchadd_int (volatile int *p, int v)
	Atomically add v to *p and return * the previous value of *p. This can be used to handle reference counts, and the return value can be used to generate unique identifiers. More...
int	ast_build_timing (struct ast_timing *i, const char *info_in)
	Construct a timing bitmap, for use in time-based conditionals. More...
static void	ast_category_append (struct ast_config *config, struct ast_category *category)
static char *	ast_category_browse (struct ast_config *config, const char *prev)
static void	ast_category_destroy (struct ast_category *cat)
static struct ast_category *	ast_category_get (const struct ast_config *config, const char *category_name)
static struct ast_category *	ast_category_new (const char *name, const char *in_file, int lineno)
static int	ast_change_hint (struct ast_exten *oe, struct ast_exten *ne)
	ast_change_hint: Change hint for an extension More...
int	ast_check_timing (const struct ast_timing *i)
	Evaluate a pre-constructed bitmap as to whether the current time falls within the range specified. More...
static void	ast_config_destroy (struct ast_config *cfg)
struct ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
	Retrieve the current category name being built. More...
static struct ast_config *	ast_config_internal_load (const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_incl_file)
static struct ast_config *	ast_config_new (void)
void	ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
	Set the category within the configuration as being current. More...
void	ast_console_puts (const char *string)
	write the string to the root console, and all attached network console clients More...
static int	ast_context_add_ignorepat2 (struct ast_context *con, const char *value, const char *registrar)
static int	ast_context_add_include2 (struct ast_context *con, const char *value, const char *registrar)
static int	ast_context_add_switch2 (struct ast_context *con, const char *value, const char *data, int eval, const char *registrar)
static struct ast_context *	ast_context_find (const char *name)
static struct ast_context *	ast_context_find_or_create (struct ast_context **extcontexts, void *tab, const char *name, const char *registrar)
int	ast_context_ignorepats_count (struct ast_context *con)
int	ast_context_includes_count (struct ast_context *con)
int	ast_context_switches_count (struct ast_context *con)
static int	ast_context_verify_includes (struct ast_context *con)
void	ast_copy_string (char *dst, const char *src, size_t size)
static int	ast_extension_match (const char *pattern, const char *data)
static int	ast_findlabel_extension2 (struct ast_channel *c, struct ast_context *con, const char *exten, const char *label, const char *callerid)
static int	ast_func_read (struct ast_channel *chan, const char *function, char *workspace, size_t len)
static int	ast_func_write (struct ast_channel *chan, const char *function, const char *value)
static const char *	ast_get_context_name (struct ast_context *con)
static const char *	ast_get_extension_app (struct ast_exten *e)
static const char *	ast_get_extension_name (struct ast_exten *exten)
static struct ast_config_include *	ast_include_find (struct ast_config *conf, const char *included_file)
static struct ast_config_include *	ast_include_new (struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size)
static void	ast_includes_destroy (struct ast_config_include *incls)
static void	ast_log (int level, const char *file, int line, const char *function, const char *fmt,...)
void	ast_log_backtrace (void)
	Log a backtrace of the current thread's execution stack to the Asterisk log. More...
void	ast_mark_lock_failed (void *lock_addr)
static void	ast_merge_contexts_and_delete (struct ast_context **extcontexts, const char *registrar)
static int	ast_mutex_init (ast_mutex_t *pmutex)
static char *	ast_process_quotes_and_slashes (char *start, char find, char replace_with)
void	ast_queue_log (const char *queuename, const char *callid, const char *agent, const char *event, const char *fmt,...)
static int	ast_remove_hint (struct ast_exten *e)
	ast_remove_hint: Remove hint from extension More...
void	ast_replace_sigchld (void)
	Replace the SIGCHLD handler. More...
static int	ast_rwlock_destroy (ast_rwlock_t *prwlock)
static int	ast_rwlock_init (ast_rwlock_t *prwlock)
static int	ast_rwlock_rdlock (ast_rwlock_t *prwlock)
static int	ast_rwlock_unlock (ast_rwlock_t *prwlock)
static int	ast_rwlock_wrlock (ast_rwlock_t *prwlock)
int	ast_safe_system (const char *s)
	Safely spawn an OS shell command while closing file descriptors. More...
static void	ast_shrink_phone_number (char *n)
	Clean up phone string remove '(', ' ', ')', non-trailing '.', and '-' not in square brackets. Basically, remove anything that could be invalid in a pattern. More...
char *	ast_skip_blanks (const char *str)
char *	ast_strip (char *s)
	Strip leading/trailing whitespace from a string. More...
static force_inline int	ast_strlen_zero (const char *s)
char *	ast_trim_blanks (char *str)
	Trims trailing whitespace characters from a string. More...
static int	ast_true (const char *s)
struct timeval	ast_tvadd (struct timeval a, struct timeval b)
	Returns the sum of two timevals a + b. More...
struct timeval	ast_tvnow (void)
struct timeval	ast_tvsub (struct timeval a, struct timeval b)
	Returns the difference of two timevals a - b. More...
static int	ast_unlock_context (struct ast_context *con)
static int	ast_unlock_contexts (void)
void	ast_unreplace_sigchld (void)
	Restore the SIGCHLD handler. More...
static struct ast_var_t *	ast_var_assign (const char *name, const char *value)
static void	ast_var_delete (struct ast_var_t *var)
static const char *	ast_var_name (const struct ast_var_t *var)
static const char *	ast_var_value (const struct ast_var_t *var)
static void	ast_variable_append (struct ast_category *category, struct ast_variable *variable)
static struct ast_variable *	ast_variable_browse (const struct ast_config *config, const char *category)
static struct ast_variable *	ast_variable_new (const char *name, const char *value, const char *filename)
static const char *	ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable)
static void	ast_variables_destroy (struct ast_variable *v)
void	ast_verbose (const char *fmt,...)
static struct ast_exten *	ast_walk_context_extensions (struct ast_context *con, struct ast_exten *exten)
static struct ast_ignorepat *	ast_walk_context_ignorepats (struct ast_context *con, struct ast_ignorepat *ip)
static struct ast_include *	ast_walk_context_includes (struct ast_context *con, struct ast_include *inc)
static struct ast_sw *	ast_walk_context_switches (struct ast_context *con, struct ast_sw *sw)
static struct ast_context *	ast_walk_contexts (struct ast_context *con)
static struct ast_exten *	ast_walk_extension_priorities (struct ast_exten *exten, struct ast_exten *priority)
static int	ast_wrlock_context (struct ast_context *con)
static int	ast_wrlock_contexts (void)
static struct ast_category *	category_get (const struct ast_config *config, const char *category_name, int ignored)
static void	CB_ADD (char *str)
static void	CB_ADD_LEN (char *str, int len)
static void	CB_INIT (void)
static void	CB_RESET (void)
static struct ast_config *	config_text_file_load (const char *database, const char *table, const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_include_file)
static void	destroy_exten (struct ast_exten *e)
static int	ext_cmp (const char *a, const char *b)
	the full routine to compare extensions in rules. More...
static int	ext_cmp1 (const char **p)
	helper functions to sort extensions and patterns in the desired way, so that more specific patterns appear first. More...
static int	ext_strncpy (char *dst, const char *src, int len)
	copy a string skipping whitespace More...
static int	extension_match_core (const char *pattern, const char *data, enum ext_match_t mode)
static struct ast_config_engine *	find_engine (const char *family, char *database, int dbsiz, char *table, int tabsiz)
	Find realtime engine for realtime family. More...
static void	gen_header (FILE *f1, const char *configfile, const char *fn, const char *generator)
static unsigned	get_range (char *src, int max, char *const names[], const char *msg)
	helper function to return a range up to max (7, 12, 31 respectively). names, if supplied, is an array of names that should be mapped to numbers. More...
static void	get_timerange (struct ast_timing *i, char *times)
	store a bitmask of valid times, one bit each 2 minute More...
static int	include_valid (struct ast_include *i)
static void	inherit_category (struct ast_category *new, const struct ast_category *base)
static void	LLB_ADD (char *str)
int	localized_add_extension2 (struct ast_context *con, int replace, const char *extension, int priority, const char *label, const char *callerid, const char *application, void *data, void(*datad)(void *), const char *registrar)
void	localized_ast_include_rename (struct ast_config *conf, const char *from_file, const char *to_file)
struct ast_category *	localized_category_get (const struct ast_config *config, const char *category_name)
struct ast_config *	localized_config_load (const char *filename)
struct ast_config *	localized_config_load_with_comments (const char *filename)
int	localized_config_text_file_save (const char *configfile, const struct ast_config *cfg, const char *generator)
int	localized_context_add_ignorepat2 (struct ast_context *con, const char *value, const char *registrar)
int	localized_context_add_include2 (struct ast_context *con, const char *value, const char *registrar)
int	localized_context_add_switch2 (struct ast_context *con, const char *value, const char *data, int eval, const char *registrar)
void	localized_context_destroy (struct ast_context *con, const char *registrar)
struct ast_context *	localized_context_find_or_create (struct ast_context **extcontexts, void *tab, const char *name, const char *registrar)
int	localized_context_verify_includes (struct ast_context *con)
struct ast_exten *	localized_find_extension (struct ast_context *bypass, struct pbx_find_info *q, const char *context, const char *exten, int priority, const char *label, const char *callerid, enum ext_match_t action)
void	localized_merge_contexts_and_delete (struct ast_context **extcontexts, void *tab, const char *registrar)
int	localized_pbx_builtin_setvar (struct ast_channel *chan, const void *data)
int	localized_pbx_load_module (void)
void	localized_use_conf_dir (void)
void	localized_use_local_dir (void)
struct ast_exten *	localized_walk_context_extensions (struct ast_context *con, struct ast_exten *exten)
struct ast_include *	localized_walk_context_includes (struct ast_context *con, struct ast_include *inc)
struct ast_sw *	localized_walk_context_switches (struct ast_context *con, struct ast_sw *sw)
struct ast_context *	localized_walk_contexts (struct ast_context *con)
struct ast_exten *	localized_walk_extension_priorities (struct ast_exten *exten, struct ast_exten *priority)
static int	lookup_name (const char *s, char *const names[], int max)
	Helper for get_range. return the index of the matching entry, starting from 1. If names is not supplied, try numeric values. More...
static int	matchcid (const char *cidpattern, const char *callerid)
static void	move_variables (struct ast_category *old, struct ast_category *new)
static struct ast_category *	next_available_category (struct ast_category *cat)
static void	null_datad (void *foo)
static int	parse_variable_name (char *var, int *offset, int *length, int *isfunc)
	extract offset:length from variable name. Returns 1 if there is a offset:length part, which is trimmed off (values go into variables) More...
static int	pbx_builtin_setvar (struct ast_channel *chan, const void *data)
static void	pbx_builtin_setvar_helper (struct ast_channel *chan, const char *name, const char *value)
static int	pbx_extension_helper (struct ast_channel *c, struct ast_context *con, const char *context, const char *exten, int priority, const char *label, const char *callerid, enum ext_match_t action)
	The return value depends on the action: More...
static struct ast_exten *	pbx_find_extension (struct ast_channel *chan, struct ast_context *bypass, struct pbx_find_info *q, const char *context, const char *exten, int priority, const char *label, const char *callerid, enum ext_match_t action)
static int	pbx_load_config (const char *config_file)
static void	pbx_retrieve_variable (struct ast_channel *c, const char *var, char **ret, char *workspace, int workspacelen, struct varshead *headp)
	Support for Asterisk built-in variables in the dialplan. More...
static void	pbx_substitute_variables_helper (struct ast_channel *c, const char *cp1, char *cp2, int count)
static void	pbx_substitute_variables_helper_full (struct ast_channel *c, struct varshead *headp, const char *cp1, char *cp2, int count)
static int	process_text_line (struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile, int withcomments, const char *suggested_include_file)
static void	set_fn (char *fn, int fn_size, const char *file, const char *configfile)
static char *	substring (const char *value, int offset, int length, char *workspace, size_t workspace_len)
	takes a substring. It is ok to call with value == workspace. More...
static struct timeval	tvfix (struct timeval a)
static struct ast_variable *	variable_clone (const struct ast_variable *old)

Variables
char	ast_defaultlanguage []
int	ast_language_is_prefix
	The following variable controls the layout of localized sound files. If 0, use the historical layout with prefix just before the filename (i.e. digits/en/1.gsm , digits/it/1.gsm or default to digits/1.gsm), if 1 put the prefix at the beginning of the filename (i.e. en/digits/1.gsm, it/digits/1.gsm or default to digits/1.gsm). The latter permits a language to be entirely in one directory. More...
pid_t	ast_mainpid
int	ast_option_maxcalls
double	ast_option_maxload
struct ast_flags	ast_options = { AST_DEFAULT_OPTIONS }
static int	autofallthrough_config = 0
static int	clearglobalvars_config = 0
static char *	comment_buffer
static int	comment_buffer_size
static struct ast_config_engine *	config_engine_list
static char *	config_filename = "extensions.conf"
static struct ast_config_map *	config_maps = NULL
static ast_rwlock_t	conlock = PTHREAD_RWLOCK_INITIALIZER
static struct ast_context *	contexts = NULL
char *	days []
char	debug_filename [AST_FILENAME_MAX]
static char *	extconfig_conf = "extconfig.conf"
static char *	global_registrar = "conf2ael"
static struct varshead	globals = AST_LIST_HEAD_NOLOCK_INIT_VALUE
static ast_rwlock_t	globalslock = PTHREAD_RWLOCK_INITIALIZER
static struct hints	hints = { .first = NULL, .last = NULL, .lock = PTHREAD_RWLOCK_INITIALIZER , }
static char *	lline_buffer
static int	lline_buffer_size
static struct ast_context *	local_contexts = NULL
char *	months []
static struct sigaction	null_sig_handler
int	option_debug
int	option_verbose
char	record_cache_dir [AST_CACHE_DIR_LEN]
static unsigned int	safe_system_level = 0
	Keep track of how many threads are currently trying to wait*() on a child process. More...
static struct sigaction	safe_system_prev_handler
static int	static_config = 0
static struct ast_config_engine	text_file_engine
static int	use_local_dir = 1
static char	userscontext [AST_MAX_EXTENSION] = "default"
static int	write_protect_config = 1

Detailed Description

A condensation of the pbx_config stuff, to read into 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 1358 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 1362 of file extconf.c.

AST_FILENAME_MAX

#define AST_FILENAME_MAX   80

Definition at line 1359 of file extconf.c.

ast_fully_booted

#define ast_fully_booted   ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)

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

AST_LIST_EMPTY

#define AST_LIST_EMPTY

(

head

)

(AST_LIST_FIRST(head) == NULL)

Checks whether the specified list contains any entries.

Parameters

head	This is a pointer to the list head structure

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

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

AST_LIST_FIRST

#define AST_LIST_FIRST

(

head

)

((head)->first)

Returns the first entry contained in a list.

Parameters

head	This is a pointer to the list head structure

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

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

AST_LIST_HEAD_INIT

#define AST_LIST_HEAD_INIT

(

head

)

Value:

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

Initializes a list head structure.

Parameters

head	This is a pointer to the list head structure

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

Definition at line 1885 of file extconf.c.

AST_LIST_HEAD_INIT_NOLOCK

#define AST_LIST_HEAD_INIT_NOLOCK

(

head

)

Value:

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

Initializes a list head structure.

Parameters

head	This is a pointer to the list head structure

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

Definition at line 1926 of file extconf.c.

AST_LIST_HEAD_INIT_VALUE

#define AST_LIST_HEAD_INIT_VALUE

Value:

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

Defines initial values for a declaration of AST_LIST_HEAD.

Definition at line 1518 of file extconf.c.

AST_LIST_HEAD_NOLOCK

#define AST_LIST_HEAD_NOLOCK	(		name,
			type
	)

Value:

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

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

Parameters

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

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

Example usage:

static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;

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

Definition at line 1509 of file extconf.c.

AST_LIST_HEAD_NOLOCK_INIT_VALUE

#define AST_LIST_HEAD_NOLOCK_INIT_VALUE

Value:

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

Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK.

Definition at line 1536 of file extconf.c.

AST_LIST_HEAD_NOLOCK_STATIC

#define AST_LIST_HEAD_NOLOCK_STATIC	(		name,
			type
	)

Value:

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

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

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

Definition at line 1630 of file extconf.c.

AST_LIST_HEAD_SET

#define AST_LIST_HEAD_SET	(		head,
			entry
	)

Value:

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

Initializes a list head structure with a specified first entry.

Parameters

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

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

Definition at line 1644 of file extconf.c.

AST_LIST_HEAD_SET_NOLOCK

#define AST_LIST_HEAD_SET_NOLOCK	(		head,
			entry
	)

Value:

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

Initializes a list head structure with a specified first entry.

Parameters

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

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

Definition at line 1672 of file extconf.c.

AST_LIST_HEAD_STATIC

#define AST_LIST_HEAD_STATIC	(		name,
			type
	)

Value:

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

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

Parameters

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

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

Example usage:

static AST_LIST_HEAD_STATIC(entry_list, entry);

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

Definition at line 1575 of file extconf.c.

AST_LIST_INSERT_AFTER

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

Inserts a list entry after a given entry.

Parameters

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

Definition at line 1940 of file extconf.c.

AST_LIST_INSERT_BEFORE_CURRENT

#define AST_LIST_INSERT_BEFORE_CURRENT	(		head,
			elm,
			field
	)

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

Parameters

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

Note

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

Definition at line 1858 of file extconf.c.

AST_LIST_INSERT_HEAD

#define AST_LIST_INSERT_HEAD	(		head,
			elm,
			field
	)

Inserts a list entry at the head of a list.

Parameters

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

Definition at line 1956 of file extconf.c.

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

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 1713 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 1723 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 2037 of file extconf.c.

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

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

AST_LIST_TRAVERSE_SAFE_END

#define AST_LIST_TRAVERSE_SAFE_END   }

Closes a safe loop traversal block.

Definition at line 1874 of file extconf.c.

AST_MAX_EXTENSION

#define AST_MAX_EXTENSION   80

Max length of an extension

Definition at line 2078 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_flag(&ast_options, AST_OPT_FLAG_ALWAYS_FORK)

Definition at line 1385 of file extconf.c.

ast_opt_cache_record_files

#define ast_opt_cache_record_files   ast_test_flag(&ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES)

Definition at line 1379 of file extconf.c.

ast_opt_console

#define ast_opt_console   ast_test_flag(&ast_options, AST_OPT_FLAG_CONSOLE)

Definition at line 1369 of file extconf.c.

ast_opt_dont_warn

#define ast_opt_dont_warn   ast_test_flag(&ast_options, AST_OPT_FLAG_DONT_WARN)

Definition at line 1384 of file extconf.c.

ast_opt_dump_core

#define ast_opt_dump_core   ast_test_flag(&ast_options, AST_OPT_FLAG_DUMP_CORE)

Definition at line 1378 of file extconf.c.

ast_opt_exec

#define ast_opt_exec   ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC)

Definition at line 1373 of file extconf.c.

ast_opt_exec_includes

#define ast_opt_exec_includes   ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES)

Definition at line 1366 of file extconf.c.

ast_opt_high_priority

#define ast_opt_high_priority   ast_test_flag(&ast_options, AST_OPT_FLAG_HIGH_PRIORITY)

Definition at line 1370 of file extconf.c.

ast_opt_init_keys

#define ast_opt_init_keys   ast_test_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS)

Definition at line 1371 of file extconf.c.

ast_opt_mute

#define ast_opt_mute   ast_test_flag(&ast_options, AST_OPT_FLAG_MUTE)

Definition at line 1386 of file extconf.c.

ast_opt_no_color

#define ast_opt_no_color   ast_test_flag(&ast_options, AST_OPT_FLAG_NO_COLOR)

Definition at line 1374 of file extconf.c.

ast_opt_no_fork

#define ast_opt_no_fork   ast_test_flag(&ast_options, AST_OPT_FLAG_NO_FORK)

Definition at line 1367 of file extconf.c.

ast_opt_override_config

#define ast_opt_override_config   ast_test_flag(&ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG)

Definition at line 1381 of file extconf.c.

ast_opt_priority_jumping

#define ast_opt_priority_jumping   ast_test_flag(&ast_options, AST_OPT_FLAG_PRIORITY_JUMPING)

Definition at line 1377 of file extconf.c.

ast_opt_quiet

#define ast_opt_quiet   ast_test_flag(&ast_options, AST_OPT_FLAG_QUIET)

Definition at line 1368 of file extconf.c.

ast_opt_reconnect

#define ast_opt_reconnect   ast_test_flag(&ast_options, AST_OPT_FLAG_RECONNECT)

Definition at line 1382 of file extconf.c.

ast_opt_remote

#define ast_opt_remote   ast_test_flag(&ast_options, AST_OPT_FLAG_REMOTE)

Definition at line 1372 of file extconf.c.

ast_opt_timestamp

#define ast_opt_timestamp   ast_test_flag(&ast_options, AST_OPT_FLAG_TIMESTAMP)

Definition at line 1380 of file extconf.c.

ast_opt_transcode_via_slin

#define ast_opt_transcode_via_slin   ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN)

Definition at line 1376 of file extconf.c.

ast_opt_transmit_silence

#define ast_opt_transmit_silence   ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE)

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

AST_RWLIST_EMPTY

#define AST_RWLIST_EMPTY   AST_LIST_EMPTY

Definition at line 1735 of file extconf.c.

AST_RWLIST_ENTRY

#define AST_RWLIST_ENTRY   AST_LIST_ENTRY

Definition at line 1699 of file extconf.c.

AST_RWLIST_FIRST

#define AST_RWLIST_FIRST   AST_LIST_FIRST

Definition at line 1707 of file extconf.c.

AST_RWLIST_HEAD

#define AST_RWLIST_HEAD	(		name,
			type
	)

Value:

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

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

Parameters

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

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

Example usage:

static AST_RWLIST_HEAD(entry_list, entry) entries;

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

Definition at line 1483 of file extconf.c.

AST_RWLIST_HEAD_DESTROY

#define AST_RWLIST_HEAD_DESTROY

(

head

)

Value:

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

Destroys an rwlist head structure.

Parameters

head	This is a pointer to the list head structure

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

Definition at line 1912 of file extconf.c.

AST_RWLIST_HEAD_INIT

#define AST_RWLIST_HEAD_INIT

(

head

)

Value:

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

Initializes an rwlist head structure.

Parameters

head	This is a pointer to the list head structure

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

Definition at line 1898 of file extconf.c.

AST_RWLIST_HEAD_INIT_VALUE

#define AST_RWLIST_HEAD_INIT_VALUE

Value:

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

Defines initial values for a declaration of AST_RWLIST_HEAD.

Definition at line 1527 of file extconf.c.

AST_RWLIST_HEAD_SET

#define AST_RWLIST_HEAD_SET	(		head,
			entry
	)

Value:

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

Initializes an rwlist head structure with a specified first entry.

Parameters

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

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

Definition at line 1658 of file extconf.c.

AST_RWLIST_HEAD_STATIC

#define AST_RWLIST_HEAD_STATIC	(		name,
			type
	)

Value:

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

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

Parameters

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

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

Example usage:

static AST_RWLIST_HEAD_STATIC(entry_list, entry);

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

Definition at line 1617 of file extconf.c.

AST_RWLIST_INSERT_AFTER

#define AST_RWLIST_INSERT_AFTER   AST_LIST_INSERT_AFTER

Definition at line 1947 of file extconf.c.

AST_RWLIST_INSERT_BEFORE_CURRENT

#define AST_RWLIST_INSERT_BEFORE_CURRENT   AST_LIST_INSERT_BEFORE_CURRENT

Definition at line 1869 of file extconf.c.

AST_RWLIST_INSERT_HEAD

#define AST_RWLIST_INSERT_HEAD   AST_LIST_INSERT_HEAD

Definition at line 1963 of file extconf.c.

AST_RWLIST_INSERT_TAIL

#define AST_RWLIST_INSERT_TAIL   AST_LIST_INSERT_TAIL

Definition at line 1986 of file extconf.c.

AST_RWLIST_LAST

#define AST_RWLIST_LAST   AST_LIST_LAST

Definition at line 1715 of file extconf.c.

AST_RWLIST_NEXT

#define AST_RWLIST_NEXT   AST_LIST_NEXT

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

AST_RWLIST_REMOVE

#define AST_RWLIST_REMOVE   AST_LIST_REMOVE

Definition at line 2055 of file extconf.c.

AST_RWLIST_REMOVE_CURRENT

#define AST_RWLIST_REMOVE_CURRENT   AST_LIST_REMOVE_CURRENT

Definition at line 1846 of file extconf.c.

AST_RWLIST_REMOVE_HEAD

#define AST_RWLIST_REMOVE_HEAD   AST_LIST_REMOVE_HEAD

Definition at line 2027 of file extconf.c.

AST_RWLIST_TRAVERSE

#define AST_RWLIST_TRAVERSE   AST_LIST_TRAVERSE

Definition at line 1776 of file extconf.c.

AST_RWLIST_TRAVERSE_SAFE_BEGIN

#define AST_RWLIST_TRAVERSE_SAFE_BEGIN   AST_LIST_TRAVERSE_SAFE_BEGIN

Definition at line 1823 of file extconf.c.

AST_RWLIST_TRAVERSE_SAFE_END

#define AST_RWLIST_TRAVERSE_SAFE_END   AST_LIST_TRAVERSE_SAFE_END

Definition at line 1876 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 1435 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 1413 of file extconf.c.

AST_RWLOCK_DEFINE_STATIC

#define AST_RWLOCK_DEFINE_STATIC

(

rwlock

)

__AST_RWLOCK_DEFINE(static, rwlock)

Definition at line 568 of file extconf.c.

AST_RWLOCK_INIT_VALUE

#define AST_RWLOCK_INIT_VALUE   PTHREAD_RWLOCK_INITIALIZER

Definition at line 563 of file extconf.c.

ast_set2_flag

#define ast_set2_flag	(		p,
			value,
			flag
	)

Definition at line 684 of file extconf.c.

ast_test_flag

#define ast_test_flag	(		p,
			flag
	)

Definition at line 677 of file extconf.c.

ASTMM_LIBC

#define ASTMM_LIBC   ASTMM_IGNORE

Definition at line 46 of file extconf.c.

BACKGROUND_MATCHEXTEN

#define BACKGROUND_MATCHEXTEN   (1 << 2)

Definition at line 2327 of file extconf.c.

BACKGROUND_NOANSWER

#define BACKGROUND_NOANSWER   (1 << 1)

Definition at line 2326 of file extconf.c.

BACKGROUND_PLAYBACK

#define BACKGROUND_PLAYBACK   (1 << 3)

Definition at line 2328 of file extconf.c.

BACKGROUND_SKIP

#define BACKGROUND_SKIP   (1 << 0)

Definition at line 2325 of file extconf.c.

CB_INCR

#define CB_INCR   250

Definition at line 711 of file extconf.c.

COMMENT_END

#define COMMENT_END   "--;"

Definition at line 698 of file extconf.c.

COMMENT_META

#define COMMENT_META   ';'

Definition at line 699 of file extconf.c.

COMMENT_START

#define COMMENT_START   ";--"

Definition at line 697 of file extconf.c.

COMMENT_TAG

#define COMMENT_TAG   '-'

Definition at line 700 of file extconf.c.

DEBUG_M

#define DEBUG_M

(

a

)

Value:

    { \
    a; \
}

Definition at line 96 of file extconf.c.

EVENTLOG

#define EVENTLOG   "event_log"

Definition at line 93 of file extconf.c.

EXT_DATA_SIZE

#define EXT_DATA_SIZE   8192

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

MAX_NESTED_COMMENTS

#define MAX_NESTED_COMMENTS   128

Definition at line 696 of file extconf.c.

ONE_MILLION

#define ONE_MILLION   1000000

Definition at line 2261 of file extconf.c.

PRIORITY_HINT

#define PRIORITY_HINT   -1

Special Priority for a hint

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

STATUS_NO_CONTEXT

#define STATUS_NO_CONTEXT   1

Definition at line 2448 of file extconf.c.

STATUS_NO_EXTENSION

#define STATUS_NO_EXTENSION   2

Definition at line 2449 of file extconf.c.

STATUS_NO_LABEL

#define STATUS_NO_LABEL   4

Definition at line 2451 of file extconf.c.

STATUS_NO_PRIORITY

#define STATUS_NO_PRIORITY   3

Definition at line 2450 of file extconf.c.

STATUS_SUCCESS

#define STATUS_SUCCESS   5

Definition at line 2452 of file extconf.c.

SWITCH_DATA_LENGTH

#define SWITCH_DATA_LENGTH   256

Definition at line 3610 of file extconf.c.

VAR_BUF_SIZE

#define VAR_BUF_SIZE   4096

Definition at line 2319 of file extconf.c.

VAR_HARDTRAN

#define VAR_HARDTRAN   3

Definition at line 2323 of file extconf.c.

VAR_NORMAL

#define VAR_NORMAL   1

Definition at line 2321 of file extconf.c.

VAR_SOFTTRAN

#define VAR_SOFTTRAN   2

Definition at line 2322 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 2353 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 2105 of file extconf.c.

config_load_func

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

Definition at line 933 of file extconf.c.

realtime_multi_get

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

Definition at line 935 of file extconf.c.

realtime_update

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

Definition at line 936 of file extconf.c.

realtime_var_get

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

Definition at line 934 of file extconf.c.

Enumeration Type Documentation

ast_extension_states

enum ast_extension_states

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

Definition at line 2084 of file extconf.c.

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

ast_option_flags

enum ast_option_flags

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

Definition at line 1308 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 4706 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, LOG_DEBUG, LOG_WARNING, name, NULL, option_debug, option_verbose, registrar, tmp(), 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 5501 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, registrar, and tmp().

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

{
 
}

add_pri()

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

static

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

Definition at line 3675 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, free(), LOG_WARNING, ast_context::name, ast_exten::next, NULL, ast_exten::peer, ast_exten::priority, PRIORITY_HINT, replace(), ast_context::root, and tmp().

Referenced by ast_add_extension2().

ALLOC_COMMENT()

static struct ast_comment * ALLOC_COMMENT ( const char *  buffer )

static

Definition at line 877 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 4773 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_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, priority, PRIORITY_HINT, registrar, replace(), ast_context::root, tmp(), 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 3642 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, 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 2486 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().

Referenced by pbx_builtin_setvar().

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 3806 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(), sip_to_pjsip::info(), 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 2833 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 3326 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 2845 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 1210 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 2788 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 3625 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, and ast_hint::exten.

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

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

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

ast_config_destroy()

static void ast_config_destroy ( struct ast_config *  cfg )

static

Definition at line 1289 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 2781 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 2862 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, db, extconfig_conf, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, NULL, result, table, and text_file_engine.

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

ast_config_new()

static struct ast_config * ast_config_new ( void  )

static

Definition at line 3274 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 3362 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 1357 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 4567 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, ast_ignorepat::registrar, 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 4501 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, ast_include::registrar, 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 4639 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, ast_sw::registrar, 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 4172 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 4980 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 4123 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 4090 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 4157 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 5620 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.

Referenced by localized_context_verify_includes(), and localized_pbx_load_module().

ast_copy_string()

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

Definition at line 970 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 4295 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 4975 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 4993 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 2478 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 4486 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 3612 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 3617 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 1163 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 1074 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 1273 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 2194 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);
}

References make_ari_stubs::file.

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

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 2510 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 2313 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 5570 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::next, NULL, option_debug, registrar, and tmp().

Referenced by localized_merge_contexts_and_delete(), and localized_pbx_load_module().

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 2218 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 965 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 3733 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 801 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);
}

Referenced by __ast_context_destroy().

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

Referenced by __ast_context_create().

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

Referenced by pbx_retrieve_variable().

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

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

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

Referenced by ast_wrlock_context(), and ast_wrlock_contexts().

ast_safe_system()

int ast_safe_system

(

const char *

s

)

Safely spawn an OS shell command while closing file descriptors.

Note

This replaces the system call in all Asterisk modules

Parameters

s	- OS shell command string to execute.

Warning

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

Definition at line 829 of file extconf.c.

{
    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(), convert_bdb_to_sqlite3(), mixmonitor_thread(), notify_message(), process_text_line(), rotate_file(), run_externnotify(), sendmail(), sendpage(), system_exec_helper(), and vm_change_password_shell().

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 2136 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 979 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 1023 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 952 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 1004 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 2244 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 2282 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(), rtp_deallocate_transport(), run_task(), sched_run(), sched_settime(), schedule_cache_expiration(), schedule_delivery(), set_timeout(), sla_process_timers(), smdi_message_wait(), sorcery_memory_cache_print_object(), subscription_persistence_update(), timeout_write(), user_event_wait_for_events(), and wait_for_stimulus().

ast_tvnow()

struct timeval ast_tvnow

(

void

)

Definition at line 5671 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 2297 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 4624 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 4614 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 815 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 2454 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.

Referenced by pbx_builtin_setvar_helper().

ast_var_delete()

static void ast_var_delete ( struct ast_var_t *  var )

static

Definition at line 2471 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 2170 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 5025 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 1177 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 1215 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 1055 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.

Referenced by process_text_line(), and variable_clone().

ast_variable_retrieve()

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

static

Definition at line 1227 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 1262 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 2206 of file extconf.c.

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

Referenced by __ast_context_create(), ast_add_extension2(), ast_agi_send(), ast_ari_callback(), ast_context_add_include2(), ast_context_add_switch2(), ast_remotecontrol(), ast_rtcp_calculate_sr_rr_statistics(), ast_rtcp_interpret(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_continuation(), ast_rtp_dtmf_end_with_duration(), ast_rtp_read(), ast_rtp_sendcng(), ast_stun_handle_packet(), astman_append(), astman_flush(), bridge_p2p_rtp_write(), can_safely_quit(), conf_run(), config_text_file_load(), dahdi_softhangup_all(), dundi_debug_output(), hook_event_cb(), iax_debug_output(), ivr_demo_func(), jb_debug_output(), localized_config_text_file_save(), log_action(), logging_on_rx_msg(), logging_on_tx_msg(), pbx_builtin_setvar_helper(), print_frame(), print_intro_message(), process_dtmf_rfc2833(), rtp_raw_write(), run_agi(), should_send_event(), stasis_app_message_handler(), stun_process_attr(), timing_read(), xmpp_log_hook(), and xmpp_pubsub_receive_node_list().

ast_walk_context_extensions()

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

static

Definition at line 4040 of file extconf.c.

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

References ast_exten::exten, 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 4113 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 4080 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 4139 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 4024 of file extconf.c.

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

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

ast_walk_extension_priorities()

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

static

Definition at line 4061 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 4619 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 4609 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 1192 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, and NULL.

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

CB_ADD()

static void CB_ADD ( char *  str )

static

Definition at line 737 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 750 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 718 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 777 of file extconf.c.

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

References comment_buffer, and lline_buffer.

Referenced by 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 3119 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 3765 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 3944 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:

1. the empty set is equivalent to NUL.
2. 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 3872 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 3971 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 4286 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 2747 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, table, 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 3388 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 2638 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 2682 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 4311 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 2823 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 764 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 4895 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 1110 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, ast_category::root, and strdup.

localized_category_get()

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

Definition at line 2801 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 3285 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 3303 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 3421 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 4599 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 4557 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 4700 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 5562 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 4986 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 5637 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 4468 of file extconf.c.

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

References voicemailpwcheck::context, 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 5615 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 2605 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 5644 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 3113 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 3108 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 4051 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 4104 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 4150 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 4030 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 4069 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 2615 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 4300 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 2806 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 3319 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 2742 of file extconf.c.

{
}

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 5003 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 2568 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 2528 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 4914 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, voicemailpwcheck::context, 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 4332 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_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, voicemailpwcheck::context, 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(), pbx_find_info::incstack, ast_exten::label, LOG_WARNING, match(), ast_exten::matchcid, matchcid(), ast_switch::matchmore, 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, pbx_find_info::swo, and tmp().

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 5336 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, strdup, 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

See also

• Globally predefined channel variables Channel variables
• Hangup Causes for Asterisk The HANGUPCAUSE variable

Definition at line 5079 of file extconf.c.

{
    const char not_found = '\0';
    char *tmpvar;
    const char *s;  /* the result */
    int offset, length;
    int i, need_substring;
    struct varshead *places[2] = { headp, &globals };   /* list of places where we may look */
 
    /*
     * Make a copy of var because parse_variable_name() modifies the string.
     * Then if called directly, we might need to run substring() on the result;
     * remember this for later in 'need_substring', 'offset' and 'length'
     */
    tmpvar = ast_strdupa(var);  /* parse_variable_name modifies the string */
    need_substring = parse_variable_name(tmpvar, &offset, &length, &i /* ignored */);
 
    /*
     * Look first into predefined variables, then into variable lists.
     * Variable 's' points to the result, according to the following rules:
     * s == &not_found (set at the beginning) means that we did not find a
     *  matching variable and need to look into more places.
     * If s != &not_found, s is a valid result string as follows:
     * s = NULL if the variable does not have a value;
     *  you typically do this when looking for an unset predefined variable.
     * s = workspace if the result has been assembled there;
     *  typically done when the result is built e.g. with an snprintf(),
     *  so we don't need to do an additional copy.
     * s != workspace in case we have a string, that needs to be copied
     *  (the ast_copy_string is done once for all at the end).
     *  Typically done when the result is already available in some string.
     */
    s = &not_found; /* default value */
    if (s == &not_found) { /* look for more */
        if (!strcmp(var, "EPOCH")) {
            snprintf(workspace, workspacelen, "%u",(int)time(NULL));
        }
 
        s = workspace;
    }
    /* if not found, look into chanvars or global vars */
    for (i = 0; s == &not_found && i < (sizeof(places) / sizeof(places[0])); i++) {
        struct ast_var_t *variables;
        if (!places[i])
            continue;
        if (places[i] == &globals)
            ast_rwlock_rdlock(&globalslock);
        AST_LIST_TRAVERSE(places[i], variables, entries) {
            if (strcasecmp(ast_var_name(variables), var)==0) {
                s = ast_var_value(variables);
                break;
            }
        }
        if (places[i] == &globals)
            ast_rwlock_unlock(&globalslock);
    }
    if (s == &not_found || s == NULL)
        *ret = NULL;
    else {
        if (s != workspace)
            ast_copy_string(workspace, s, workspacelen);
        *ret = workspace;
        if (need_substring)
            *ret = substring(*ret, offset, length, workspace, workspacelen);
    }
}

References ast_copy_string(), AST_LIST_TRAVERSE, ast_rwlock_rdlock(), ast_rwlock_unlock(), ast_strdupa, ast_var_name(), ast_var_value(), ast_var_t::entries, globals, globalslock, NULL, parse_variable_name(), substring(), and var.

Referenced by pbx_substitute_variables_helper_full().

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 5328 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 5146 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 = 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(), tmp(), 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 2906 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 3406 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 make_ari_stubs::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 5038 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 2266 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.

Referenced by ast_tvadd(), and ast_tvsub().

variable_clone()

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

static

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

ast_defaultlanguage

char ast_defaultlanguage[]

extern

Definition at line 98 of file options.c.

Referenced by load_asterisk_conf().

ast_language_is_prefix

int ast_language_is_prefix

extern

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

This is settable in asterisk.conf.

Definition at line 67 of file file.c.

Referenced by fileexists_test().

ast_mainpid

pid_t ast_mainpid

extern

Definition at line 315 of file asterisk.c.

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

autofallthrough_config

int autofallthrough_config = 0

static

Definition at line 2125 of file extconf.c.

Referenced by pbx_load_config().

clearglobalvars_config

int clearglobalvars_config = 0

static

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

Referenced by CB_ADD(), CB_ADD_LEN(), CB_INIT(), CB_RESET(), config_text_file_load(), 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 706 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 893 of file extconf.c.

Referenced by ast_config_internal_load(), and find_engine().

config_filename

char* config_filename = "extensions.conf"

static

Definition at line 2120 of file extconf.c.

Referenced by AST_TEST_DEFINE(), localized_pbx_load_module(), and parse_config().

config_maps

struct ast_config_map * config_maps = NULL

static

Referenced by find_engine().

conlock

ast_rwlock_t conlock = PTHREAD_RWLOCK_INITIALIZER

static

Lock for the ast_context list

Definition at line 4482 of file extconf.c.

Referenced by ast_unlock_contexts(), and ast_wrlock_contexts().

contexts

static struct ast_context * contexts = NULL

static

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

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

Referenced by ast_config_internal_load().

global_registrar

char* global_registrar = "conf2ael"

static

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

Referenced by pbx_builtin_setvar_helper(), and pbx_retrieve_variable().

globalslock

ast_rwlock_t globalslock = PTHREAD_RWLOCK_INITIALIZER

static

Definition at line 2067 of file extconf.c.

Referenced by pbx_retrieve_variable().

hints

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

static

lline_buffer

char* lline_buffer

static

A buffer for stuff behind the ;

Definition at line 708 of file extconf.c.

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

lline_buffer_size

int lline_buffer_size

static

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

Referenced by localized_pbx_load_module(), and pbx_load_config().

months

char* months[]

Definition at line 3787 of file extconf.c.

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

Referenced by ast_replace_sigchld().

record_cache_dir

char record_cache_dir[AST_CACHE_DIR_LEN]

extern

Definition at line 96 of file options.c.

Referenced by load_asterisk_conf().

safe_system_level

unsigned int safe_system_level = 0

static

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

Definition at line 785 of file extconf.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

safe_system_prev_handler

struct sigaction safe_system_prev_handler

static

Definition at line 786 of file extconf.c.

Referenced by ast_replace_sigchld(), and ast_unreplace_sigchld().

static_config

int static_config = 0

static

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

Referenced by ast_config_internal_load().

use_local_dir

int use_local_dir = 1

static

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

Referenced by pbx_load_config().

write_protect_config

int write_protect_config = 1

static

Definition at line 2124 of file extconf.c.

Referenced by pbx_load_config().