chan_iax2.c File Reference

Implementation of Inter-Asterisk eXchange Version 2 as specified in RFC 5456. More...

#include "asterisk.h"
#include <sys/mman.h>
#include <dirent.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <sys/time.h>
#include <signal.h>
#include <netdb.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <regex.h>
#include "asterisk/paths.h"
#include "asterisk/lock.h"
#include "asterisk/frame.h"
#include "asterisk/channel.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/translate.h"
#include "asterisk/md5.h"
#include "asterisk/crypto.h"
#include "asterisk/acl.h"
#include "asterisk/manager.h"
#include "asterisk/callerid.h"
#include "asterisk/app.h"
#include "asterisk/mwi.h"
#include "asterisk/astdb.h"
#include "asterisk/musiconhold.h"
#include "asterisk/features.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/localtime.h"
#include "asterisk/dnsmgr.h"
#include "asterisk/devicestate.h"
#include "asterisk/stringfields.h"
#include "asterisk/linkedlists.h"
#include "asterisk/astobj2.h"
#include "asterisk/timing.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/test.h"
#include "asterisk/security_events.h"
#include "asterisk/stasis_endpoints.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_system.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/format_cache.h"
#include "asterisk/format_compatibility.h"
#include "asterisk/format_cap.h"
#include "iax2/include/iax2.h"
#include "iax2/include/firmware.h"
#include "iax2/include/parser.h"
#include "iax2/include/provision.h"
#include "iax2/include/codec_pref.h"
#include "iax2/include/format_compatibility.h"
#include "iax2/include/netsock.h"
#include "jitterbuf.h"

Go to the source code of this file.

Data Structures
struct	active_list
struct	addr_range
struct	call_number_pool
struct	chan_iax2_pvt
struct	create_addr_info
struct	dpcache
struct	dpreq_data
struct	dynamic_list
struct	iax2_context
struct	iax2_dpcache
struct	iax2_peer
struct	iax2_pkt_buf
struct	iax2_registry
struct	iax2_thread
struct	iax2_trunk_peer
struct	iax2_user
struct	iax_rr
struct	idle_list
struct	parsed_dial_string
struct	peercnt
struct	registrations
struct	show_peers_context
struct	chan_iax2_pvt::signaling_queue
struct	signaling_queue_entry
struct	tpeers

Macros
#define	ACN_FORMAT1   "%-24.25s %4u %4d %4d %5d %3d %5d %4d %6d %4d %4d %5d %3d %5d %4d %6d %s%s %4s%s\n"
#define	ACN_FORMAT2   "%s %u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"
#define	AUTH_METHOD_NAMES_BUFSIZE   19
#define	CALLNO_ENTRY_GET_CALLNO(a)   ((a) & 0x7FFF)
#define	CALLNO_ENTRY_IS_VALIDATED(a)   ((a) & 0x8000)
#define	CALLNO_ENTRY_SET_VALIDATED(a)   ((a) |= 0x8000)
#define	CALLNO_ENTRY_TO_PTR(a)   ((void *)(unsigned long)(a))
#define	CALLNO_TO_PTR(a)   ((void *)(unsigned long)(a))
#define	CALLTOKEN_HASH_FORMAT   "%s%u%d" /* address + port + ts + randomcalldata */
#define	CALLTOKEN_IE_FORMAT   "%u?%s" /* time + ? + (40 char hash) */
#define	DEBUG_SCHED_MULTITHREAD
#define	DEBUG_SUPPORT
#define	DEFAULT_CONTEXT   "default"
#define	DEFAULT_DROP   3
#define	DEFAULT_FREQ_NOTOK   10 * 1000 /* How often to check, if the host is down... */
#define	DEFAULT_FREQ_OK   60 * 1000 /* How often to check for the host to be up */
#define	DEFAULT_MAX_THREAD_COUNT   100
#define	DEFAULT_MAXMS   2000 /* Must be faster than 2 seconds by default */
#define	DEFAULT_RETRY_TIME   1000
#define	DEFAULT_THREAD_COUNT   10
#define	DEFAULT_TRUNKDATA   640 * 10
#define	FORMAT   "%-15.15s %-20.20s %-15.15s %-15.15s %-5.5s %-5.10s\n"
#define	FORMAT   "%-45.45s %-6.6s %-10.10s %-45.45s %8d %s\n"
#define	FORMAT   "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d %-5.5dms %-4.4dms %-4.4dms %-6.6s %s%s %3s%s\n"
#define	FORMAT2   "%-15.15s %-20.20s %-15.15d %-15.15s %-5.5s %-5.10s\n"
#define	FORMAT2   "%-45.45s %-6.6s %-10.10s %-45.45s %8.8s %s\n"
#define	FORMAT2   "%-20.20s %-40.40s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %-6.6s %s %s %9s\n"
#define	FORMATB   "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d [Native Bridged to ID=%5.5d]\n"
#define	GAMMA   (0.01)
#define	IAX2_TRUNK_PREFACE   (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
#define	IAX_ALLOWFWDOWNLOAD   (uint64_t)(1LLU << 26)
#define	IAX_ALREADYGONE   (uint64_t)(1LLU << 9)
#define	IAX_CALLENCRYPTED(pvt)    (ast_test_flag64(pvt, IAX_ENCRYPTED) && ast_test_flag64(pvt, IAX_KEYPOPULATED))
#define	IAX_CAPABILITY_FULLBANDWIDTH   0xFFFF
#define	IAX_CAPABILITY_LOWBANDWIDTH
#define	IAX_CAPABILITY_LOWFREE
#define	IAX_CAPABILITY_MEDBANDWIDTH
#define	IAX_CODEC_NOCAP   (uint64_t)(1LLU << 16)
#define	IAX_CODEC_NOPREFS   (uint64_t)(1LLU << 15)
#define	IAX_CODEC_USER_FIRST   (uint64_t)(1LLU << 14)
#define	IAX_DEBUGDIGEST(msg, key)
#define	IAX_DELAYPBXSTART   (uint64_t)(1LLU << 25)
#define	IAX_DELME   (uint64_t)(1LLU << 1)
#define	IAX_DYNAMIC   (uint64_t)(1LLU << 6)
#define	IAX_ENCRYPTED   (uint64_t)(1LLU << 12)
#define	IAX_FORCE_ENCRYPT   (uint64_t)(1LLU << 30)
#define	IAX_HASCALLERID   (uint64_t)(1LLU << 0)
#define	IAX_IMMEDIATE   (uint64_t)(1LLU << 27)
#define	IAX_KEYPOPULATED   (uint64_t)(1LLU << 13)
#define	IAX_MAXAUTHREQ   (uint64_t)(1LLU << 24)
#define	IAX_NOTRANSFER   (uint64_t)(1LLU << 4)
#define	IAX_PROVISION   (uint64_t)(1LLU << 10)
#define	IAX_QUELCH   (uint64_t)(1LLU << 11)
#define	IAX_RECVCONNECTEDLINE   (uint64_t)(1LLU << 29)
#define	IAX_RTAUTOCLEAR   (uint64_t)(1LLU << 19)
#define	IAX_RTCACHEFRIENDS   (uint64_t)(1LLU << 17)
#define	IAX_RTIGNOREREGEXPIRE   (uint64_t)(1LLU << 21)
#define	IAX_RTSAVE_SYSNAME   (uint64_t)(1LLU << 8)
#define	IAX_RTUPDATE   (uint64_t)(1LLU << 18)
#define	IAX_SENDANI   (uint64_t)(1LLU << 7)
#define	IAX_SENDCONNECTEDLINE   (uint64_t)(1LLU << 28)
#define	IAX_SHRINKCALLERID   (uint64_t)(1LLU << 31)
#define	IAX_TEMPONLY   (uint64_t)(1LLU << 2)
#define	IAX_TRANSFERMEDIA   (uint64_t)(1LLU << 23)
#define	IAX_TRUNK   (uint64_t)(1LLU << 3)
#define	IAX_TRUNKTIMESTAMPS   (uint64_t)(1LLU << 22)
#define	IAX_USEJITTERBUF   (uint64_t)(1LLU << 5)
#define	MARK_IAX_SUBCLASS_TX   0x8000
#define	MAX_JITTER_BUFFER   50
#define	MAX_PEER_BUCKETS   563
#define	MAX_RETRY_TIME   10000
#define	MAX_TIMESTAMP_SKEW   160
#define	MAX_TRUNK_MTU   1240
	Maximum transmission unit for the UDP packet in the trunk not to be fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240. More...
#define	MAX_TRUNKDATA   640 * 200
#define	MAX_USER_BUCKETS   MAX_PEER_BUCKETS
#define	MEMORY_SIZE   100
#define	MIN_JITTER_BUFFER   10
#define	MIN_RETRY_TIME   100
#define	MIN_REUSE_TIME   60 /* Don't reuse a call number within 60 seconds */
#define	PEERS_FORMAT   "%-15.15s %-40.40s %s %-40.40s %-6s%s %s %-11s %-32.32s\n"
#define	PEERS_FORMAT2   "%-15.15s %-40.40s %s %-40.40s %-9s %s %-11s %-32.32s\n"
#define	PTR_TO_CALLNO(a)   ((unsigned short)(unsigned long)(a))
#define	PTR_TO_CALLNO_ENTRY(a)   ((uint16_t)(unsigned long)(a))
#define	SCHED_MULTITHREADED
#define	schedule_action(func, data)   __schedule_action(func, data, __PRETTY_FUNCTION__)
#define	TRUNK_CALL_START   (IAX_MAX_CALLS / 2)
#define	TS_GAP_FOR_JB_RESYNC   5000

Typedefs
typedef uint16_t	callno_entry

Enumerations
enum	{   CACHE_FLAG_EXISTS = (1 << 0) , CACHE_FLAG_NONEXISTENT = (1 << 1) , CACHE_FLAG_CANEXIST = (1 << 2) , CACHE_FLAG_PENDING = (1 << 3) ,   CACHE_FLAG_TIMEOUT = (1 << 4) , CACHE_FLAG_TRANSMITTED = (1 << 5) , CACHE_FLAG_UNKNOWN = (1 << 6) , CACHE_FLAG_MATCHMORE = (1 << 7) }
enum	{ NEW_PREVENT = 0 , NEW_ALLOW = 1 , NEW_FORCE = 2 , NEW_ALLOW_CALLTOKEN_VALIDATED = 3 }
enum	callno_type { CALLNO_TYPE_NORMAL , CALLNO_TYPE_TRUNK }
enum	calltoken_peer_enum { CALLTOKEN_DEFAULT = 0 , CALLTOKEN_YES = 1 , CALLTOKEN_AUTO = 2 , CALLTOKEN_NO = 3 }
	Call token validation settings. More...
enum	iax2_state { IAX_STATE_STARTED = (1 << 0) , IAX_STATE_AUTHENTICATED = (1 << 1) , IAX_STATE_TBD = (1 << 2) }
enum	iax2_thread_iostate { IAX_IOSTATE_IDLE , IAX_IOSTATE_READY , IAX_IOSTATE_PROCESSING , IAX_IOSTATE_SCHEDREADY }
enum	iax2_thread_type { IAX_THREAD_TYPE_POOL , IAX_THREAD_TYPE_DYNAMIC }
enum	iax_reg_state {   REG_STATE_UNREGISTERED = 0 , REG_STATE_REGSENT , REG_STATE_AUTHSENT , REG_STATE_REGISTERED ,   REG_STATE_REJECTED , REG_STATE_TIMEOUT , REG_STATE_NOAUTH }
enum	iax_transfer_state {   TRANSFER_NONE = 0 , TRANSFER_BEGIN , TRANSFER_READY , TRANSFER_RELEASED ,   TRANSFER_PASSTHROUGH , TRANSFER_MBEGIN , TRANSFER_MREADY , TRANSFER_MRELEASED ,   TRANSFER_MPASSTHROUGH , TRANSFER_MEDIA , TRANSFER_MEDIAPASS }

Functions
static void	__attempt_transmit (const void *data)
static void	__auth_reject (const void *nothing)
static void	__auto_congest (const void *nothing)
static void	__auto_hangup (const void *nothing)
static int	__do_deliver (void *data)
static void	__expire_registry (const void *data)
static int	__find_callno (unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int return_locked, int check_dcallno)
static void	__get_from_jb (const void *p)
static void	__iax2_do_register_s (const void *data)
static void	__iax2_poke_noanswer (const void *data)
static void	__iax2_poke_peer_s (const void *data)
static int	__iax2_show_peers (int fd, int *total, struct mansession *s, const int argc, const char *const argv[])
static void	__reg_module (void)
static int	__schedule_action (void(*func)(const void *data), const void *data, const char *funcname)
static int	__send_command (struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno, int now, int transfer, int final)
static void	__send_lagrq (const void *data)
static void	__send_ping (const void *data)
static int	__unload_module (void)
static void	__unreg_module (void)
static void	_iax2_show_peers_one (int fd, struct mansession *s, struct show_peers_context *cont, struct iax2_peer *peer)
static int	acf_channel_read (struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen)
static int	acf_iaxvar_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	acf_iaxvar_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
static void	acl_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	acl_change_stasis_subscribe (void)
static void	acl_change_stasis_unsubscribe (void)
static int	add_calltoken_ignore (const char *addr)
static void	add_empty_calltoken_ie (struct chan_iax2_pvt *pvt, struct iax_ie_data *ied)
static int	addr_range_cmp_cb (void *obj, void *arg, int flags)
static int	addr_range_delme_cb (void *obj, void *arg, int flags)
static int	addr_range_hash_cb (const void *obj, const int flags)
static int	addr_range_match_address_cb (void *obj, void *arg, int flags)
static int	apply_context (struct iax2_context *con, const char *context)
static int	ast_cli_netstats (struct mansession *s, int fd, int limit_fmt)
static struct ast_channel *	ast_iax2_new (int callno, int state, iax2_format capability, struct iax2_codec_pref *prefs, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, unsigned int cachable)
	Create new call, interface with the PBX core. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	attempt_transmit (const void *data)
static int	auth_fail (int callno, int failcode)
static char *	auth_method_names (int authmethods, char *restrict buf)
	Get names of all auth methods. More...
static int	auth_reject (const void *data)
static int	authenticate (const char *challenge, const char *secret, const char *keyn, int authmethods, struct iax_ie_data *ied, struct ast_sockaddr *addr, struct chan_iax2_pvt *pvt)
static int	authenticate_reply (struct chan_iax2_pvt *p, struct ast_sockaddr *addr, struct iax_ies *ies, const char *override, const char *okey)
static int	authenticate_request (int call_num)
static int	authenticate_verify (struct chan_iax2_pvt *p, struct iax_ies *ies)
static int	auto_congest (const void *data)
static int	auto_hangup (const void *data)
static void	build_callno_limits (struct ast_variable *v)
static struct iax2_context *	build_context (const char *context)
static void	build_ecx_key (const unsigned char *digest, struct chan_iax2_pvt *pvt)
static void	build_encryption_keys (const unsigned char *digest, struct chan_iax2_pvt *pvt)
static struct iax2_peer *	build_peer (const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
	Create peer structure based on configuration. More...
static void	build_rand_pad (unsigned char *buf, ssize_t len)
static struct iax2_user *	build_user (const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
	Create in-memory user structure from configuration. More...
static int	cache_get_callno_locked (const char *data)
static unsigned int	calc_rxstamp (struct chan_iax2_pvt *p, unsigned int offset)
static unsigned int	calc_timestamp (struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
static unsigned int	calc_txpeerstamp (struct iax2_trunk_peer *tpeer, int sampms, struct timeval *now)
static int	calltoken_required (struct ast_sockaddr *addr, const char *name, int subclass)
static int	check_access (int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
static int	check_provisioning (struct ast_sockaddr *addr, int sockfd, char *si, unsigned int ver)
static int	check_srcaddr (struct ast_sockaddr *addr)
	Check if address can be used as packet source. More...
static void	cleanup_thread_list (void *head)
static struct ast_format *	codec_choose_from_prefs (struct iax2_codec_pref *pref, struct ast_format_cap *cap)
static int	complete_dpreply (struct chan_iax2_pvt *pvt, struct iax_ies *ies)
static char *	complete_iax2_peers (const char *line, const char *word, int pos, int state, uint64_t flags)
static char *	complete_iax2_unregister (const char *line, const char *word, int pos, int state)
static int	complete_transfer (int callno, struct iax_ies *ies)
static unsigned char	compress_subclass (iax2_format subclass)
static void	construct_rr (struct chan_iax2_pvt *pvt, struct iax_ie_data *iep)
static int	create_addr (const char *peername, struct ast_channel *c, struct ast_sockaddr *addr, struct create_addr_info *cai)
static int	create_callno_pools (void)
static int	decode_frame (ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
static int	decrypt_frame (int callno, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
static void	defer_full_frame (struct iax2_thread *from_here, struct iax2_thread *to_here)
	Queue the last read full frame for processing by a certain thread. More...
static void	delete_users (void)
static void	dp_lookup (int callno, const char *context, const char *callednum, const char *callerid, int skiplock)
static void *	dp_lookup_thread (void *data)
static void	encmethods_to_str (int e, struct ast_str **buf)
static int	encrypt_frame (ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen)
static int	expire_registry (const void *data)
static struct iax2_dpcache *	find_cache (struct ast_channel *chan, const char *data, const char *context, const char *exten, int priority)
static int	find_callno (unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame)
static int	find_callno_locked (unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame)
static struct iax2_thread *	find_idle_thread (void)
static struct iax2_peer *	find_peer (const char *name, int realtime)
static struct iax2_trunk_peer *	find_tpeer (struct ast_sockaddr *addr, int fd)
static struct iax2_user *	find_user (const char *name)
static int	firmware_show_callback (struct ast_iax2_firmware_header *header, void *user_data)
static unsigned int	fix_peerts (struct timeval *rxtrunktime, int callno, unsigned int ts)
static void	free_context (struct iax2_context *con)
static void	free_signaling_queue_entry (struct signaling_queue_entry *s)
static int	function_iaxpeer (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	get_auth_methods (const char *value)
static int	get_encrypt_methods (const char *s)
static int	get_from_jb (const void *p)
static int	get_unused_callno (enum callno_type type, int validated, callno_entry *entry)
static int	handle_call_token (struct ast_iax2_full_hdr *fh, struct iax_ies *ies, struct ast_sockaddr *addr, int fd)
static char *	handle_cli_iax2_provision (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_prune_realtime (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_set_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_set_debug_jb (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_set_debug_trunk (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_set_mtu (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Set trunk MTU from CLI. More...
static char *	handle_cli_iax2_show_cache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_callno_limits (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_firmware (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_netstats (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_peer (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Show one peer in detail. More...
static char *	handle_cli_iax2_show_peers (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_registry (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_stats (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_threads (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_show_users (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_test_losspct (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_iax2_unregister (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	handle_deferred_full_frames (struct iax2_thread *thread)
	Handle any deferred full frames for this thread. More...
static int	handle_error (void)
static int	iax2_ack_registry (struct iax_ies *ies, struct ast_sockaddr *addr, int callno)
	Acknowledgment received for OUR registration. More...
static int attribute_pure	iax2_allow_new (int frametype, int subclass, int inbound)
static int	iax2_answer (struct ast_channel *c)
static int	iax2_append_register (const char *hostname, const char *username, const char *secret, const char *porta)
static int	iax2_call (struct ast_channel *c, const char *dest, int timeout)
static int	iax2_canmatch (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
	part of the IAX2 dial plan switch interface More...
static iax2_format	iax2_codec_choose (struct iax2_codec_pref *pref, iax2_format formats)
static unsigned int	iax2_datetime (const char *tz)
static int	iax2_delete_from_sched (const void *data)
static void	iax2_destroy (int callno)
static void	iax2_destroy_helper (struct chan_iax2_pvt *pvt)
static int	iax2_devicestate (const char *data)
	Part of the device state notification system —. More...
static int	iax2_digit_begin (struct ast_channel *c, char digit)
static int	iax2_digit_end (struct ast_channel *c, char digit, unsigned int duration)
static int	iax2_do_register (struct iax2_registry *reg)
static int	iax2_do_register_s (const void *data)
static void	iax2_dprequest (struct iax2_dpcache *dp, int callno)
static void *	iax2_dup_variable_datastore (void *)
static int	iax2_exec (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
	Execute IAX2 dialplan switch. More...
static int	iax2_exists (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
	Part of the IAX2 switch interface. More...
static int	iax2_fixup (struct ast_channel *oldchannel, struct ast_channel *newchan)
static void	iax2_frame_free (struct iax_frame *fr)
static void	iax2_free_variable_datastore (void *)
const char *	iax2_getformatname (iax2_format format)
	iax2 wrapper function for ast_getformatname More...
static const char *	iax2_getformatname_multiple (iax2_format format, struct ast_str **codec_buf)
static int	iax2_getpeername (struct ast_sockaddr addr, char *host, int len)
static int	iax2_getpeertrunk (struct ast_sockaddr addr)
static int	iax2_hangup (struct ast_channel *c)
static int	iax2_indicate (struct ast_channel *c, int condition, const void *data, size_t datalen)
static int	iax2_is_control_frame_allowed (int subtype)
static int	iax2_key_rotate (const void *vpvt)
static int	iax2_lock_callno_unless_destroyed (int callno)
	Acquire the iaxsl[callno] if call exists and not having ongoing hangup. More...
static void	iax2_lock_owner (int callno)
static int	iax2_matchmore (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
	Part of the IAX2 Switch interface. More...
static int	iax2_parse_allow_disallow (struct iax2_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
static int	iax2_poke_noanswer (const void *data)
static int	iax2_poke_peer (struct iax2_peer *peer, int heldcall)
static int	iax2_poke_peer_cb (void *obj, void *arg, int flags)
static int	iax2_poke_peer_s (const void *data)
static int	iax2_predestroy (int callno)
static void *	iax2_process_thread (void *data)
static void	iax2_process_thread_cleanup (void *data)
static int	iax2_prov_app (struct ast_channel *chan, const char *data)
static int	iax2_provision (struct ast_sockaddr *end, int sockfd, const char *dest, const char *template, int force)
static void	iax2_publish_registry (const char *username, const char *domain, const char *status, const char *cause)
static int	iax2_queryoption (struct ast_channel *c, int option, void *data, int *datalen)
static int	iax2_queue_frame (int callno, struct ast_frame *f)
	Queue a frame to a call's owning asterisk channel. More...
static int	iax2_queue_hangup (int callno)
	Queue a hangup frame on the ast_channel owner. More...
static int	iax2_queue_hold (int callno, const char *musicclass)
	Queue a hold frame on the ast_channel owner. More...
static int	iax2_queue_unhold (int callno)
	Queue an unhold frame on the ast_channel owner. More...
static struct ast_frame *	iax2_read (struct ast_channel *c)
static int	iax2_register (const char *value, int lineno)
static struct ast_channel *	iax2_request (const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
static int	iax2_sched_add (struct ast_sched_context *sched, int when, ast_sched_cb callback, const void *data)
static int	iax2_sched_replace (int id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
static int	iax2_send (struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
static int	iax2_sendhtml (struct ast_channel *c, int subclass, const char *data, int datalen)
static int	iax2_sendimage (struct ast_channel *c, struct ast_frame *img)
static int	iax2_sendtext (struct ast_channel *c, const char *text)
static int	iax2_setoption (struct ast_channel *c, int option, void *data, int datalen)
static int	iax2_transfer (struct ast_channel *c, const char *dest)
static int	iax2_transmit (struct iax_frame *fr)
static int	iax2_trunk_expired (struct iax2_trunk_peer *tpeer, struct timeval *now)
static int	iax2_trunk_queue (struct chan_iax2_pvt *pvt, struct iax_frame *fr)
static int	iax2_vnak (int callno)
static int	iax2_write (struct ast_channel *c, struct ast_frame *f)
static void	iax_debug_output (const char *data)
static void	iax_error_output (const char *data)
static void	iax_outputframe (struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct ast_sockaddr *addr, int datalen)
static ast_callid	iax_pvt_callid_get (int callno)
static void	iax_pvt_callid_new (int callno)
static void	iax_pvt_callid_set (int callno, ast_callid callid)
static struct iax_frame *	iaxfrdup2 (struct iax_frame *fr)
static void	insert_idle_thread (struct iax2_thread *thread)
static int	invalid_key (ast_aes_decrypt_key *ecx)
static void	jb_debug_output (const char *fmt,...)
static void	jb_error_output (const char *fmt,...)
static void	jb_warning_output (const char *fmt,...)
static int	load_module (void)
	Load the module. More...
static int	load_objects (void)
static void	log_jitterstats (unsigned short callno)
static int	make_trunk (unsigned short callno, int locked)
static int	manager_iax2_show_netstats (struct mansession *s, const struct message *m)
static int	manager_iax2_show_peer_list (struct mansession *s, const struct message *m)
	callback to display iax peers in manager format More...
static int	manager_iax2_show_peers (struct mansession *s, const struct message *m)
	callback to display iax peers in manager More...
static int	manager_iax2_show_registry (struct mansession *s, const struct message *m)
static int	match (struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
static void	memcpy_decrypt (unsigned char *dst, const unsigned char *src, int len, ast_aes_decrypt_key *dcx)
static void	memcpy_encrypt (unsigned char *dst, const unsigned char *src, int len, ast_aes_encrypt_key *ecx)
static void	merge_encryption (struct chan_iax2_pvt *p, unsigned int enc)
static int	network_change_sched_cb (const void *data)
static void	network_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	network_change_stasis_subscribe (void)
static void	network_change_stasis_unsubscribe (void)
static void *	network_thread (void *ignore)
static struct chan_iax2_pvt *	new_iax (struct ast_sockaddr *addr, const char *host)
static void	parse_dial_string (char *data, struct parsed_dial_string *pds)
	Parses an IAX dial string into its component parts. More...
static int	peer_cmp_cb (void *obj, void *arg, int flags)
static int	peer_delme_cb (void *obj, void *arg, int flags)
static void	peer_destructor (void *obj)
static int	peer_hash_cb (const void *obj, const int flags)
static struct iax2_peer *	peer_ref (struct iax2_peer *peer)
static int	peer_set_sock_cb (void *obj, void *arg, int flags)
static int	peer_set_srcaddr (struct iax2_peer *peer, const char *srcaddr)
	Parse the "sourceaddress" value, lookup in netsock list and set peer's sockfd. Defaults to defaultsockfd if not found. More...
static int	peer_status (struct iax2_peer *peer, char *status, int statuslen)
	peer_status: Report Peer status in character string More...
static struct iax2_peer *	peer_unref (struct iax2_peer *peer)
static int	peercnt_add (struct ast_sockaddr *addr)
static int	peercnt_cmp_cb (void *obj, void *arg, int flags)
static int	peercnt_hash_cb (const void *obj, const int flags)
static void	peercnt_modify (unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
static void	peercnt_remove (struct peercnt *peercnt)
static int	peercnt_remove_by_addr (struct ast_sockaddr *addr)
static int	peercnt_remove_cb (const void *obj)
static void	poke_all_peers (void)
static int	prune_addr_range_cb (void *obj, void *arg, int flags)
static void	prune_peers (void)
static void	prune_users (void)
static int	pvt_cmp_cb (void *obj, void *arg, int flags)
static void	pvt_destructor (void *obj)
static int	pvt_hash_cb (const void *obj, const int flags)
static int	queue_signalling (struct chan_iax2_pvt *pvt, struct ast_frame *f)
	All frames other than that of type AST_FRAME_IAX must be held until we have received a destination call number. More...
static int	raw_hangup (struct ast_sockaddr *addr, unsigned short src, unsigned short dst, int sockfd)
static struct iax2_peer *	realtime_peer (const char *peername, struct ast_sockaddr *addr)
static void	realtime_update_peer (const char *peername, struct ast_sockaddr *sockaddr, time_t regtime)
static struct iax2_user *	realtime_user (const char *username, struct ast_sockaddr *addr)
static void	reg_source_db (struct iax2_peer *p)
static void	register_peer_exten (struct iax2_peer *peer, int onoff)
static int	register_verify (int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
	Verify inbound registration. More...
static int	registry_authrequest (int callno)
static int	registry_rerequest (struct iax_ies *ies, int callno, struct ast_sockaddr *addr)
static char *	regstate2str (int regstate)
static int	reload (void)
static int	reload_config (int forced_reload)
static void	remove_by_peercallno (struct chan_iax2_pvt *pvt)
static void	remove_by_transfercallno (struct chan_iax2_pvt *pvt)
static int	replace_callno (const void *obj)
static void	requirecalltoken_mark_auto (const char *name, int subclass)
static void	resend_with_token (int callno, struct iax_frame *f, const char *newtoken)
static void	save_osptoken (struct iax_frame *fr, struct iax_ies *ies)
static void	save_rr (struct iax_frame *fr, struct iax_ies *ies)
static void	sched_delay_remove (struct ast_sockaddr *addr, callno_entry entry)
static int	schedule_delivery (struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
static int	scheduled_destroy (const void *vid)
static int	send_apathetic_reply (unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int command, int ts, unsigned char seqno, int sockfd, struct iax_ie_data *ied)
static int	send_command (struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
static int	send_command_final (struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
static int	send_command_immediate (struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
static int	send_command_locked (unsigned short callno, char, int, unsigned int, const unsigned char *, int, int)
static int	send_command_transfer (struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int)
static int	send_lagrq (const void *data)
static int	send_packet (struct iax_frame *f)
static int	send_ping (const void *data)
static void	send_signaling (struct chan_iax2_pvt *pvt)
	This function must be called once we are sure the other side has given us a call number. All signaling is held here until that point. More...
static int	send_trunk (struct iax2_trunk_peer *tpeer, struct timeval *now)
static int	set_config (const char *config_file, int reload, int forced)
	Load configuration. More...
static void	set_config_destroy (void)
static void	set_hangup_source_and_cause (int callno, unsigned char causecode)
static void	set_peercnt_limit (struct peercnt *peercnt)
static int	set_peercnt_limit_all_cb (void *obj, void *arg, int flags)
static void	signal_condition (ast_mutex_t *lock, ast_cond_t *cond)
static int	socket_process (struct iax2_thread *thread)
static int	socket_process_helper (struct iax2_thread *thread)
static int	socket_process_meta (int packet_len, struct ast_iax2_meta_hdr *meta, struct ast_sockaddr *addr, int sockfd, struct iax_frame *fr)
static int	socket_read (int *id, int fd, short events, void *cbdata)
static void	spawn_dp_lookup (int callno, const char *context, const char *callednum, const char *callerid)
static int	start_network_thread (void)
static void	stop_stuff (int callno)
static void	store_by_peercallno (struct chan_iax2_pvt *pvt)
static void	store_by_transfercallno (struct chan_iax2_pvt *pvt)
static int	timing_read (int *id, int fd, short events, void *cbdata)
static int	transfercallno_pvt_cmp_cb (void *obj, void *arg, int flags)
static int	transfercallno_pvt_hash_cb (const void *obj, const int flags)
static int	transmit_frame (void *data)
static int	transmit_trunk (struct iax_frame *f, struct ast_sockaddr *addr, int sockfd)
static int	try_transfer (struct chan_iax2_pvt *pvt, struct iax_ies *ies)
static iax2_format	uncompress_subclass (unsigned char csub)
static void	unlink_peer (struct iax2_peer *peer)
static int	unload_module (void)
static void	unwrap_timestamp (struct iax_frame *fr)
static void	update_jbsched (struct chan_iax2_pvt *pvt)
static int	update_packet (struct iax_frame *f)
static int	update_registry (struct ast_sockaddr *addr, int callno, char *devtype, int fd, unsigned short refresh)
static int	user_cmp_cb (void *obj, void *arg, int flags)
static int	user_delme_cb (void *obj, void *arg, int flags)
static void	user_destructor (void *obj)
static int	user_hash_cb (const void *obj, const int flags)
static struct iax2_user *	user_unref (struct iax2_user *user)
static void	vnak_retransmit (int callno, int last)
static int	wait_for_peercallno (struct chan_iax2_pvt *pvt)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Inter Asterisk eXchange (Ver 2)" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .requires = "dnsmgr", .optional_modules = "res_crypto", }
static char	accountcode [AST_MAX_ACCOUNT_CODE]
static struct stasis_subscription *	acl_change_sub
static struct active_list	active_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static int	adsi = 0
static int	amaflags = 0
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char *	auth_method_labels []
	Name of effective auth method. More...
static int	authdebug = 0
static int	autokill = 0
static struct ao2_container *	callno_limits
static struct call_number_pool	callno_pool
static ast_mutex_t	callno_pool_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static struct call_number_pool	callno_pool_trunk
static struct ao2_container *	calltoken_ignores
static struct ast_cli_entry	cli_iax2 []
static struct ast_sockaddr	debugaddr
static uint16_t	DEFAULT_MAXCALLNO_LIMIT = 2048
static uint16_t	DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192
static char	default_parkinglot [AST_MAX_CONTEXT]
static int	defaultsockfd = -1
static int	delayreject = 0
static struct dpcache	dpcache = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static struct dynamic_list	dynamic_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
struct {
struct iax_frame *   first
struct iax_frame *   last
}	frame_queue [IAX_MAX_CALLS]
	a list of frames that may need to be retransmitted More...
static int	global_max_trunk_mtu
static uint16_t	global_maxcallno
static uint16_t	global_maxcallno_nonval
static int	global_rtautoclear = 120
static struct ast_flags64	globalflags = { 0 }
static int	iax2_authmethods = 0
static iax2_format	iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH
static int	iax2_encryption = 0
static int(*	iax2_regfunk )(const char *username, int onoff) = NULL
static struct ast_switch	iax2_switch
static struct ast_channel_tech	iax2_tech
static const struct ast_datastore_info	iax2_variable_datastore_info
static struct ao2_container *	iax_peercallno_pvts
	Another container of iax2_pvt structures. More...
static struct ao2_container *	iax_transfercallno_pvts
	Another container of iax2_pvt structures. More...
static int	iaxactivethreadcount = 0
static int	iaxcompat = 0
static int	iaxdebug = 0
static int	iaxdefaultdpcache =10 * 60
static int	iaxdefaulttimeout = 5
static int	iaxdynamicthreadcount = 0
static int	iaxdynamicthreadnum = 0
static int	iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT
static struct ast_custom_function	iaxpeer_function
static struct chan_iax2_pvt *	iaxs [IAX_MAX_CALLS]
	an array of iax2 pvt structures More...
static ast_mutex_t	iaxsl [ARRAY_LEN(iaxs)]
	chan_iax2_pvt structure locks More...
static int	iaxthreadcount = DEFAULT_THREAD_COUNT
static int	iaxtrunkdebug = 0
static struct ast_custom_function	iaxvar_function
static struct idle_list	idle_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static struct io_context *	io
static int	jittertargetextra = 40
static int	lagrq_time = 10
static char	language [MAX_LANGUAGE] = ""
static int	last_authmethod = 0
static time_t	max_calltoken_delay = 10
static int	max_reg_expire
static int	max_retries = 4
static int	maxauthreq = 3
static int	maxjitterbuffer =1000
static int	maxjitterinterps =10
static int	min_reg_expire
static char	mohinterpret [MAX_MUSICCLASS]
static char	mohsuggest [MAX_MUSICCLASS]
static struct ast_netsock_list *	netsock
static pthread_t	netthreadid = AST_PTHREADT_NULL
static int	network_change_sched_id = -1
static struct stasis_subscription *	network_change_sub
static struct ast_netsock_list *	outsock
static char *	papp = "IAX2Provision"
static struct ao2_container *	peercnts
static struct ao2_container *	peers
static int	ping_time = 21
static struct iax2_codec_pref	prefs_global
struct {
unsigned int   cos
unsigned int   tos
}	qos = { 0, 0 }
static int	randomcalltokendata
static char	regcontext [AST_MAX_CONTEXT] = ""
static struct registrations	registrations = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static int	resyncthreshold =1000
static struct ast_sched_context *	sched
static int	srvlookup = 0
static const char	tdesc [] = "Inter Asterisk eXchange Driver (Ver 2)"
static int	test_losspct = 0
static struct ast_timer *	timer
static uint16_t	total_nonval_callno_used = 0
static struct tpeers	tpeers = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static struct ast_taskprocessor *	transmit_processor
static int	trunk_maxmtu
static int	trunk_nmaxmtu
static int	trunk_timed
static int	trunk_untimed
static int	trunkfreq = 20
static int	trunkmaxsize = MAX_TRUNKDATA
static struct ao2_container *	users

Detailed Description

Implementation of Inter-Asterisk eXchange Version 2 as specified in RFC 5456.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Todo:

Implement musicclass settings for IAX2 devices

Definition in file chan_iax2.c.

Macro Definition Documentation

ACN_FORMAT1

#define ACN_FORMAT1   "%-24.25s %4u %4d %4d %5d %3d %5d %4d %6d %4d %4d %5d %3d %5d %4d %6d %s%s %4s%s\n"

ACN_FORMAT2

#define ACN_FORMAT2   "%s %u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"

AUTH_METHOD_NAMES_BUFSIZE

#define AUTH_METHOD_NAMES_BUFSIZE   19

Definition at line 431 of file chan_iax2.c.

CALLNO_ENTRY_GET_CALLNO

#define CALLNO_ENTRY_GET_CALLNO

(

a

)

((a) & 0x7FFF)

Definition at line 980 of file chan_iax2.c.

CALLNO_ENTRY_IS_VALIDATED

#define CALLNO_ENTRY_IS_VALIDATED

(

a

)

((a) & 0x8000)

Definition at line 979 of file chan_iax2.c.

CALLNO_ENTRY_SET_VALIDATED

#define CALLNO_ENTRY_SET_VALIDATED

(

a

)

((a) |= 0x8000)

Definition at line 978 of file chan_iax2.c.

CALLNO_ENTRY_TO_PTR

#define CALLNO_ENTRY_TO_PTR

(

a

)

((void *)(unsigned long)(a))

Definition at line 976 of file chan_iax2.c.

CALLNO_TO_PTR

#define CALLNO_TO_PTR

(

a

)

((void *)(unsigned long)(a))

Definition at line 317 of file chan_iax2.c.

CALLTOKEN_HASH_FORMAT

#define CALLTOKEN_HASH_FORMAT   "%s%u%d" /* address + port + ts + randomcalldata */

CALLTOKEN_IE_FORMAT

#define CALLTOKEN_IE_FORMAT   "%u?%s" /* time + ? + (40 char hash) */

DEBUG_SCHED_MULTITHREAD

#define DEBUG_SCHED_MULTITHREAD

Definition at line 309 of file chan_iax2.c.

DEBUG_SUPPORT

#define DEBUG_SUPPORT

Definition at line 325 of file chan_iax2.c.

DEFAULT_CONTEXT

#define DEFAULT_CONTEXT   "default"

Definition at line 344 of file chan_iax2.c.

DEFAULT_DROP

#define DEFAULT_DROP   3

Definition at line 323 of file chan_iax2.c.

DEFAULT_FREQ_NOTOK

#define DEFAULT_FREQ_NOTOK   10 * 1000 /* How often to check, if the host is down... */

Definition at line 420 of file chan_iax2.c.

DEFAULT_FREQ_OK

#define DEFAULT_FREQ_OK   60 * 1000 /* How often to check for the host to be up */

Definition at line 419 of file chan_iax2.c.

DEFAULT_MAX_THREAD_COUNT

#define DEFAULT_MAX_THREAD_COUNT   100

Definition at line 320 of file chan_iax2.c.

DEFAULT_MAXMS

#define DEFAULT_MAXMS   2000 /* Must be faster than 2 seconds by default */

Definition at line 418 of file chan_iax2.c.

DEFAULT_RETRY_TIME

#define DEFAULT_RETRY_TIME   1000

Definition at line 321 of file chan_iax2.c.

DEFAULT_THREAD_COUNT

#define DEFAULT_THREAD_COUNT   10

Definition at line 319 of file chan_iax2.c.

DEFAULT_TRUNKDATA

#define DEFAULT_TRUNKDATA   640 * 10

40ms, uncompressed linear * 10 channels

Definition at line 734 of file chan_iax2.c.

FORMAT [1/3]

#define FORMAT   "%-15.15s %-20.20s %-15.15s %-15.15s %-5.5s %-5.10s\n"

FORMAT [2/3]

#define FORMAT   "%-45.45s %-6.6s %-10.10s %-45.45s %8d %s\n"

FORMAT [3/3]

#define FORMAT   "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d %-5.5dms %-4.4dms %-4.4dms %-6.6s %s%s %3s%s\n"

FORMAT2 [1/3]

#define FORMAT2   "%-15.15s %-20.20s %-15.15d %-15.15s %-5.5s %-5.10s\n"

FORMAT2 [2/3]

#define FORMAT2   "%-45.45s %-6.6s %-10.10s %-45.45s %8.8s %s\n"

FORMAT2 [3/3]

#define FORMAT2   "%-20.20s %-40.40s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %-6.6s %s %s %9s\n"

FORMATB

#define FORMATB   "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d [Native Bridged to ID=%5.5d]\n"

GAMMA

#define GAMMA   (0.01)

Definition at line 330 of file chan_iax2.c.

IAX2_TRUNK_PREFACE

#define IAX2_TRUNK_PREFACE   (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))

Definition at line 662 of file chan_iax2.c.

IAX_ALLOWFWDOWNLOAD

#define IAX_ALLOWFWDOWNLOAD   (uint64_t)(1LLU << 26)

Allow the FWDOWNL command?

Definition at line 547 of file chan_iax2.c.

IAX_ALREADYGONE

#define IAX_ALREADYGONE   (uint64_t)(1LLU << 9)

Already disconnected

Definition at line 531 of file chan_iax2.c.

IAX_CALLENCRYPTED

#define IAX_CALLENCRYPTED

(

pvt

)

(ast_test_flag64(pvt, IAX_ENCRYPTED) && ast_test_flag64(pvt, IAX_KEYPOPULATED))

Definition at line 464 of file chan_iax2.c.

IAX_CAPABILITY_FULLBANDWIDTH

#define IAX_CAPABILITY_FULLBANDWIDTH   0xFFFF

Definition at line 397 of file chan_iax2.c.

IAX_CAPABILITY_LOWBANDWIDTH

#define IAX_CAPABILITY_LOWBANDWIDTH

Value:

                     (IAX_CAPABILITY_MEDBANDWIDTH & \
                     ~AST_FORMAT_G726 &         \
                     ~AST_FORMAT_G726_AAL2 &    \
                     ~AST_FORMAT_ADPCM)

Definition at line 409 of file chan_iax2.c.

IAX_CAPABILITY_LOWFREE

#define IAX_CAPABILITY_LOWFREE

Value:

                     (IAX_CAPABILITY_LOWBANDWIDTH & \
                     ~AST_FORMAT_G723)

Definition at line 414 of file chan_iax2.c.

IAX_CAPABILITY_MEDBANDWIDTH

#define IAX_CAPABILITY_MEDBANDWIDTH

Definition at line 399 of file chan_iax2.c.

IAX_CODEC_NOCAP

#define IAX_CODEC_NOCAP   (uint64_t)(1LLU << 16)

only consider requested format and ignore capabilities

Definition at line 538 of file chan_iax2.c.

IAX_CODEC_NOPREFS

#define IAX_CODEC_NOPREFS   (uint64_t)(1LLU << 15)

Force old behaviour by turning off prefs

Definition at line 537 of file chan_iax2.c.

IAX_CODEC_USER_FIRST

#define IAX_CODEC_USER_FIRST   (uint64_t)(1LLU << 14)

are we willing to let the other guy choose the codec?

Definition at line 536 of file chan_iax2.c.

IAX_DEBUGDIGEST

#define IAX_DEBUGDIGEST	(		msg,
			key
	)

Definition at line 467 of file chan_iax2.c.

IAX_DELAYPBXSTART

#define IAX_DELAYPBXSTART   (uint64_t)(1LLU << 25)

Don't start a PBX on the channel until the peer sends us a response, so that we've achieved a three-way handshake with them before sending voice or anything else

Definition at line 546 of file chan_iax2.c.

IAX_DELME

#define IAX_DELME   (uint64_t)(1LLU << 1)

Needs to be deleted

Definition at line 523 of file chan_iax2.c.

IAX_DYNAMIC

#define IAX_DYNAMIC   (uint64_t)(1LLU << 6)

dynamic peer

Definition at line 528 of file chan_iax2.c.

IAX_ENCRYPTED

#define IAX_ENCRYPTED   (uint64_t)(1LLU << 12)

Whether we should assume encrypted tx/rx

Definition at line 534 of file chan_iax2.c.

IAX_FORCE_ENCRYPT

#define IAX_FORCE_ENCRYPT   (uint64_t)(1LLU << 30)

Forces call encryption, if encryption not possible hangup

Definition at line 551 of file chan_iax2.c.

IAX_HASCALLERID

#define IAX_HASCALLERID   (uint64_t)(1LLU << 0)

CallerID has been specified

Definition at line 522 of file chan_iax2.c.

IAX_IMMEDIATE

#define IAX_IMMEDIATE   (uint64_t)(1LLU << 27)

Allow immediate off-hook to extension s

Definition at line 548 of file chan_iax2.c.

IAX_KEYPOPULATED

#define IAX_KEYPOPULATED   (uint64_t)(1LLU << 13)

Whether we have a key populated

Definition at line 535 of file chan_iax2.c.

IAX_MAXAUTHREQ

#define IAX_MAXAUTHREQ   (uint64_t)(1LLU << 24)

Maximum outstanding AUTHREQ restriction is in place

Definition at line 545 of file chan_iax2.c.

IAX_NOTRANSFER

#define IAX_NOTRANSFER   (uint64_t)(1LLU << 4)

Don't native bridge

Definition at line 526 of file chan_iax2.c.

IAX_PROVISION

#define IAX_PROVISION   (uint64_t)(1LLU << 10)

This is a provisioning request

Definition at line 532 of file chan_iax2.c.

IAX_QUELCH

#define IAX_QUELCH   (uint64_t)(1LLU << 11)

Whether or not we quelch audio

Definition at line 533 of file chan_iax2.c.

IAX_RECVCONNECTEDLINE

#define IAX_RECVCONNECTEDLINE   (uint64_t)(1LLU << 29)

Allow receiving of connected line updates

Definition at line 550 of file chan_iax2.c.

IAX_RTAUTOCLEAR

#define IAX_RTAUTOCLEAR   (uint64_t)(1LLU << 19)

erase me on expire

Definition at line 541 of file chan_iax2.c.

IAX_RTCACHEFRIENDS

#define IAX_RTCACHEFRIENDS   (uint64_t)(1LLU << 17)

let realtime stay till your reload

Definition at line 539 of file chan_iax2.c.

IAX_RTIGNOREREGEXPIRE

#define IAX_RTIGNOREREGEXPIRE   (uint64_t)(1LLU << 21)

When using realtime, ignore registration expiration

Definition at line 542 of file chan_iax2.c.

IAX_RTSAVE_SYSNAME

#define IAX_RTSAVE_SYSNAME   (uint64_t)(1LLU << 8)

Save Systname on Realtime Updates

Definition at line 530 of file chan_iax2.c.

IAX_RTUPDATE

#define IAX_RTUPDATE   (uint64_t)(1LLU << 18)

Send a realtime update

Definition at line 540 of file chan_iax2.c.

IAX_SENDANI

#define IAX_SENDANI   (uint64_t)(1LLU << 7)

Send ANI along with CallerID

Definition at line 529 of file chan_iax2.c.

IAX_SENDCONNECTEDLINE

#define IAX_SENDCONNECTEDLINE   (uint64_t)(1LLU << 28)

Allow sending of connected line updates

Definition at line 549 of file chan_iax2.c.

IAX_SHRINKCALLERID

#define IAX_SHRINKCALLERID   (uint64_t)(1LLU << 31)

Turn on and off caller id shrinking

Definition at line 552 of file chan_iax2.c.

IAX_TEMPONLY

#define IAX_TEMPONLY   (uint64_t)(1LLU << 2)

Temporary (realtime)

Definition at line 524 of file chan_iax2.c.

IAX_TRANSFERMEDIA

#define IAX_TRANSFERMEDIA   (uint64_t)(1LLU << 23)

When doing IAX2 transfers, transfer media only

Definition at line 544 of file chan_iax2.c.

IAX_TRUNK

#define IAX_TRUNK   (uint64_t)(1LLU << 3)

Treat as a trunk

Definition at line 525 of file chan_iax2.c.

IAX_TRUNKTIMESTAMPS

#define IAX_TRUNKTIMESTAMPS   (uint64_t)(1LLU << 22)

Send trunk timestamps

Definition at line 543 of file chan_iax2.c.

IAX_USEJITTERBUF

#define IAX_USEJITTERBUF   (uint64_t)(1LLU << 5)

Use jitter buffer

Definition at line 527 of file chan_iax2.c.

MARK_IAX_SUBCLASS_TX

#define MARK_IAX_SUBCLASS_TX   0x8000

Definition at line 742 of file chan_iax2.c.

MAX_JITTER_BUFFER

#define MAX_JITTER_BUFFER   50

Definition at line 731 of file chan_iax2.c.

MAX_PEER_BUCKETS

#define MAX_PEER_BUCKETS   563

This module will get much higher performance when doing a lot of user and peer lookups if the number of buckets is increased from 1. However, to maintain old behavior for Asterisk 1.4, these are set to 1 by default. When using multiple buckets, search order through these containers is considered random, so you will not be able to depend on the order the entries are specified in iax.conf for matching order.

Definition at line 1023 of file chan_iax2.c.

MAX_RETRY_TIME

#define MAX_RETRY_TIME   10000

Definition at line 729 of file chan_iax2.c.

MAX_TIMESTAMP_SKEW

#define MAX_TIMESTAMP_SKEW   160

maximum difference between actual and predicted ts for sending

Definition at line 736 of file chan_iax2.c.

MAX_TRUNK_MTU

#define MAX_TRUNK_MTU   1240

Maximum transmission unit for the UDP packet in the trunk not to be fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240.

Definition at line 339 of file chan_iax2.c.

MAX_TRUNKDATA

#define MAX_TRUNKDATA   640 * 200

40ms, uncompressed linear * 200 channels

Definition at line 364 of file chan_iax2.c.

MAX_USER_BUCKETS

#define MAX_USER_BUCKETS   MAX_PEER_BUCKETS

Definition at line 1027 of file chan_iax2.c.

MEMORY_SIZE

#define MEMORY_SIZE   100

Definition at line 322 of file chan_iax2.c.

MIN_JITTER_BUFFER

#define MIN_JITTER_BUFFER   10

Definition at line 732 of file chan_iax2.c.

MIN_RETRY_TIME

#define MIN_RETRY_TIME   100

Definition at line 728 of file chan_iax2.c.

MIN_REUSE_TIME

#define MIN_REUSE_TIME   60 /* Don't reuse a call number within 60 seconds */

Definition at line 327 of file chan_iax2.c.

PEERS_FORMAT

#define PEERS_FORMAT   "%-15.15s %-40.40s %s %-40.40s %-6s%s %s %-11s %-32.32s\n"

Definition at line 6983 of file chan_iax2.c.

PEERS_FORMAT2

#define PEERS_FORMAT2   "%-15.15s %-40.40s %s %-40.40s %-9s %s %-11s %-32.32s\n"

Definition at line 6982 of file chan_iax2.c.

PTR_TO_CALLNO

#define PTR_TO_CALLNO

(

a

)

((unsigned short)(unsigned long)(a))

Definition at line 316 of file chan_iax2.c.

PTR_TO_CALLNO_ENTRY

#define PTR_TO_CALLNO_ENTRY

(

a

)

((uint16_t)(unsigned long)(a))

Definition at line 975 of file chan_iax2.c.

SCHED_MULTITHREADED

#define SCHED_MULTITHREADED

Todo:

XXX The IAX2 channel driver needs its native bridge code converted to the new bridge technology scheme.

Note

The chan_dahdi native bridge code can be used as an example. It also appears that chan_iax2 also has a native transfer check like chan_dahdi to eliminate tromboned calls.

The existing native bridge code is marked with the IAX2_NATIVE_BRIDGING conditional.

Definition at line 305 of file chan_iax2.c.

schedule_action

#define schedule_action	(		func,
			data
	)		__schedule_action(func, data, __PRETTY_FUNCTION__)

Definition at line 1750 of file chan_iax2.c.

TRUNK_CALL_START

#define TRUNK_CALL_START   (IAX_MAX_CALLS / 2)

Definition at line 1247 of file chan_iax2.c.

TS_GAP_FOR_JB_RESYNC

#define TS_GAP_FOR_JB_RESYNC   5000

Definition at line 739 of file chan_iax2.c.

Typedef Documentation

callno_entry

typedef uint16_t callno_entry

Definition at line 764 of file chan_iax2.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CACHE_FLAG_EXISTS	Extension exists
CACHE_FLAG_NONEXISTENT	Extension is nonexistent
CACHE_FLAG_CANEXIST	Extension can exist
CACHE_FLAG_PENDING	Waiting to hear back response
CACHE_FLAG_TIMEOUT	Timed out
CACHE_FLAG_TRANSMITTED	Request transmitted
CACHE_FLAG_UNKNOWN	Timeout
CACHE_FLAG_MATCHMORE	Matchmore

Definition at line 1074 of file chan_iax2.c.

     {
    /*! Extension exists */
    CACHE_FLAG_EXISTS      = (1 << 0),
    /*! Extension is nonexistent */
    CACHE_FLAG_NONEXISTENT = (1 << 1),
    /*! Extension can exist */
    CACHE_FLAG_CANEXIST    = (1 << 2),
    /*! Waiting to hear back response */
    CACHE_FLAG_PENDING     = (1 << 3),
    /*! Timed out */
    CACHE_FLAG_TIMEOUT     = (1 << 4),
    /*! Request transmitted */
    CACHE_FLAG_TRANSMITTED = (1 << 5),
    /*! Timeout */
    CACHE_FLAG_UNKNOWN     = (1 << 6),
    /*! Matchmore */
    CACHE_FLAG_MATCHMORE   = (1 << 7),
};

anonymous enum

anonymous enum

Enumerator
NEW_PREVENT
NEW_ALLOW
NEW_FORCE
NEW_ALLOW_CALLTOKEN_VALIDATED

Definition at line 2376 of file chan_iax2.c.

     {
    /* do not allow a new call number, only search ones in use for match */
    NEW_PREVENT = 0,
    /* search for match first, then allow a new one to be allocated */
    NEW_ALLOW = 1,
    /* do not search for match, force a new call number */
    NEW_FORCE = 2,
    /* do not search for match, force a new call number.  Signifies call number
     * has been calltoken validated */
    NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
};

callno_type

enum callno_type

Enumerator
CALLNO_TYPE_NORMAL
CALLNO_TYPE_TRUNK

Definition at line 970 of file chan_iax2.c.

                 {
    CALLNO_TYPE_NORMAL,
    CALLNO_TYPE_TRUNK,
};

calltoken_peer_enum

enum calltoken_peer_enum

Call token validation settings.

Enumerator
CALLTOKEN_DEFAULT	Default calltoken required unless the ip is in the ignorelist.
CALLTOKEN_YES	Require call token validation.
CALLTOKEN_AUTO	Require call token validation after a successful registration using call token validation occurs.
CALLTOKEN_NO	Do not require call token validation.

Definition at line 560 of file chan_iax2.c.

                         {
    /*! \brief Default calltoken required unless the ip is in the ignorelist */
    CALLTOKEN_DEFAULT = 0,
    /*! \brief Require call token validation. */
    CALLTOKEN_YES = 1,
    /*! \brief Require call token validation after a successful registration
     *         using call token validation occurs. */
    CALLTOKEN_AUTO = 2,
    /*! \brief Do not require call token validation. */
    CALLTOKEN_NO = 3,
};

iax2_state

enum iax2_state

Enumerator
IAX_STATE_STARTED
IAX_STATE_AUTHENTICATED
IAX_STATE_TBD

Definition at line 510 of file chan_iax2.c.

                {
    IAX_STATE_STARTED =         (1 << 0),
    IAX_STATE_AUTHENTICATED =   (1 << 1),
    IAX_STATE_TBD =             (1 << 2),
};

iax2_thread_iostate

enum iax2_thread_iostate

Enumerator
IAX_IOSTATE_IDLE
IAX_IOSTATE_READY
IAX_IOSTATE_PROCESSING
IAX_IOSTATE_SCHEDREADY

Definition at line 1115 of file chan_iax2.c.

                         {
    IAX_IOSTATE_IDLE,
    IAX_IOSTATE_READY,
    IAX_IOSTATE_PROCESSING,
    IAX_IOSTATE_SCHEDREADY,
};

iax2_thread_type

enum iax2_thread_type

Enumerator
IAX_THREAD_TYPE_POOL
IAX_THREAD_TYPE_DYNAMIC

Definition at line 1122 of file chan_iax2.c.

                      {
    IAX_THREAD_TYPE_POOL,
    IAX_THREAD_TYPE_DYNAMIC,
};

iax_reg_state

enum iax_reg_state

Enumerator
REG_STATE_UNREGISTERED
REG_STATE_REGSENT
REG_STATE_AUTHSENT
REG_STATE_REGISTERED
REG_STATE_REJECTED
REG_STATE_TIMEOUT
REG_STATE_NOAUTH

Definition at line 685 of file chan_iax2.c.

                   {
    REG_STATE_UNREGISTERED = 0,
    REG_STATE_REGSENT,
    REG_STATE_AUTHSENT,
    REG_STATE_REGISTERED,
    REG_STATE_REJECTED,
    REG_STATE_TIMEOUT,
    REG_STATE_NOAUTH
};

iax_transfer_state

enum iax_transfer_state

Enumerator
TRANSFER_NONE
TRANSFER_BEGIN
TRANSFER_READY
TRANSFER_RELEASED
TRANSFER_PASSTHROUGH
TRANSFER_MBEGIN
TRANSFER_MREADY
TRANSFER_MRELEASED
TRANSFER_MPASSTHROUGH
TRANSFER_MEDIA
TRANSFER_MEDIAPASS

Definition at line 695 of file chan_iax2.c.

                        {
    TRANSFER_NONE = 0,
    TRANSFER_BEGIN,
    TRANSFER_READY,
    TRANSFER_RELEASED,
    TRANSFER_PASSTHROUGH,
    TRANSFER_MBEGIN,
    TRANSFER_MREADY,
    TRANSFER_MRELEASED,
    TRANSFER_MPASSTHROUGH,
    TRANSFER_MEDIA,
    TRANSFER_MEDIAPASS
};

Function Documentation

__attempt_transmit()

static void __attempt_transmit ( const void *  data )

static

Definition at line 3621 of file chan_iax2.c.

{
    /* Attempt to transmit the frame to the remote peer...
       Called without iaxsl held. */
    struct iax_frame *f = (struct iax_frame *)data;
    int freeme = 0;
    int callno = f->callno;
 
    /* Make sure this call is still active */
    if (callno)
        ast_mutex_lock(&iaxsl[callno]);
    if (callno && iaxs[callno]) {
        if (f->retries < 0) {
            /* Already ACK'd */
            freeme = 1;
        } else if (f->retries >= max_retries) {
            /* Too many attempts.  Record an error. */
            if (f->transfer) {
                /* Transfer timeout */
                send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
            } else if (f->final) {
                iax2_destroy(callno);
            } else {
                if (iaxs[callno]->owner) {
                    ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %u, subclass = %d, ts=%u, seqno=%d)\n",
                        ast_sockaddr_stringify_addr(&iaxs[f->callno]->addr),
                        ast_channel_name(iaxs[f->callno]->owner),
                        f->af.frametype,
                        f->af.subclass.integer,
                        f->ts,
                        f->oseqno);
                }
                iaxs[callno]->error = ETIMEDOUT;
                if (iaxs[callno]->owner) {
                    struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
                    /* Hangup the fd */
                    iax2_queue_frame(callno, &fr); /* XXX */
                    /* Remember, owner could disappear */
                    if (iaxs[callno] && iaxs[callno]->owner)
                        ast_channel_hangupcause_set(iaxs[callno]->owner, AST_CAUSE_DESTINATION_OUT_OF_ORDER);
                } else {
                    if (iaxs[callno]->reg) {
                        memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
                        iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
                        iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
                    }
                    iax2_destroy(callno);
                }
            }
            freeme = 1;
        } else {
            /* Update it if it needs it */
            update_packet(f);
            /* Attempt transmission */
            send_packet(f);
            f->retries++;
            /* Try again later after 10 times as long */
            f->retrytime *= 10;
            if (f->retrytime > MAX_RETRY_TIME)
                f->retrytime = MAX_RETRY_TIME;
            /* Transfer messages max out at one second */
            if (f->transfer && (f->retrytime > 1000))
                f->retrytime = 1000;
            f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
        }
    } else {
        /* Make sure it gets freed */
        f->retries = -1;
        freeme = 1;
    }
 
    if (freeme) {
        /* Don't attempt delivery, just remove it from the queue */
        AST_LIST_REMOVE(&frame_queue[callno], f, list);
        ast_mutex_unlock(&iaxsl[callno]);
        f->retrans = -1; /* this is safe because this is the scheduled function */
        /* Free the IAX frame */
        iax2_frame_free(f);
    } else if (callno) {
        ast_mutex_unlock(&iaxsl[callno]);
    }
}

References chan_iax2_pvt::addr, iax_frame::af, AST_CAUSE_DESTINATION_OUT_OF_ORDER, ast_channel_hangupcause_set(), ast_channel_name(), AST_CONTROL_HANGUP, AST_FRAME_CONTROL, AST_FRAME_IAX, AST_LIST_REMOVE, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_stringify_addr(), attempt_transmit(), iax_frame::callno, iax_frame::data, chan_iax2_pvt::error, iax_frame::final, frame_queue, ast_frame::frametype, iax2_destroy(), iax2_frame_free(), iax2_queue_frame(), iax2_sched_add(), IAX_COMMAND_TXREJ, IAX_DEFAULT_REG_EXPIRE, iaxs, iaxsl, ast_frame_subclass::integer, LOG_WARNING, max_retries, MAX_RETRY_TIME, NULL, iax_frame::oseqno, chan_iax2_pvt::owner, iax2_registry::refresh, chan_iax2_pvt::reg, REG_STATE_TIMEOUT, iax2_registry::regstate, iax_frame::retrans, iax_frame::retries, iax_frame::retrytime, send_command(), send_packet(), ast_frame::subclass, iax_frame::transfer, iax_frame::ts, update_packet(), and iax2_registry::us.

Referenced by attempt_transmit().

__auth_reject()

static void __auth_reject ( const void *  nothing )

static

Definition at line 9464 of file chan_iax2.c.

{
    /* Called from IAX thread only, without iaxs lock */
    int callno = (int)(long)(nothing);
    struct iax_ie_data ied;
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        memset(&ied, 0, sizeof(ied));
        if (iaxs[callno]->authfail == IAX_COMMAND_REGREJ) {
            iax_ie_append_str(&ied, IAX_IE_CAUSE, "Registration Refused");
            iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_REJECTED);
        } else if (iaxs[callno]->authfail == IAX_COMMAND_REJECT) {
            iax_ie_append_str(&ied, IAX_IE_CAUSE, "No authority found");
            iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
        }
        send_command_final(iaxs[callno], AST_FRAME_IAX, iaxs[callno]->authfail, 0, ied.buf, ied.pos, -1);
    }
    ast_mutex_unlock(&iaxsl[callno]);
}

References AST_CAUSE_FACILITY_NOT_SUBSCRIBED, AST_CAUSE_FACILITY_REJECTED, AST_FRAME_IAX, ast_mutex_lock, ast_mutex_unlock, iax_ie_data::buf, IAX_COMMAND_REGREJ, IAX_COMMAND_REJECT, iax_ie_append_byte(), iax_ie_append_str(), IAX_IE_CAUSE, IAX_IE_CAUSECODE, iaxs, iaxsl, iax_ie_data::pos, and send_command_final().

Referenced by auth_reject().

__auto_congest()

static void __auto_congest ( const void *  nothing )

static

Definition at line 4822 of file chan_iax2.c.

{
    int callno = PTR_TO_CALLNO(nothing);
    struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_CONGESTION } };
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        iaxs[callno]->initid = -1;
        iax2_queue_frame(callno, &f);
        ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
    }
    ast_mutex_unlock(&iaxsl[callno]);
}

References AST_CONTROL_CONGESTION, AST_FRAME_CONTROL, ast_log, ast_mutex_lock, ast_mutex_unlock, iax2_queue_frame(), iaxs, iaxsl, chan_iax2_pvt::initid, LOG_NOTICE, and PTR_TO_CALLNO.

Referenced by auto_congest().

__auto_hangup()

static void __auto_hangup ( const void *  nothing )

static

Definition at line 9513 of file chan_iax2.c.

{
    /* Called from IAX thread only, without iaxs lock */
    int callno = (int)(long)(nothing);
    struct iax_ie_data ied;
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        memset(&ied, 0, sizeof(ied));
        iax_ie_append_str(&ied, IAX_IE_CAUSE, "Timeout");
        iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_NO_USER_RESPONSE);
        send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
    }
    ast_mutex_unlock(&iaxsl[callno]);
}

References AST_CAUSE_NO_USER_RESPONSE, AST_FRAME_IAX, ast_mutex_lock, ast_mutex_unlock, iax_ie_data::buf, IAX_COMMAND_HANGUP, iax_ie_append_byte(), iax_ie_append_str(), IAX_IE_CAUSE, IAX_IE_CAUSECODE, iaxs, iaxsl, iax_ie_data::pos, and send_command_final().

Referenced by auto_hangup().

__do_deliver()

static int __do_deliver ( void *  data )

static

Note

This function assumes that iaxsl[callno] is locked when called.

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it. This function calls iax2_queue_frame(), which may unlock and lock the mutex associated with this callno, meaning that another thread may grab it and destroy the call.

Definition at line 3413 of file chan_iax2.c.

{
    /* Just deliver the packet by using queueing.  This is called by
      the IAX thread with the iaxsl lock held. */
    struct iax_frame *fr = data;
    fr->retrans = -1;
    ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
    if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
        iax2_queue_frame(fr->callno, &fr->af);
    /* Free our iax frame */
    iax2_frame_free(fr);
    /* And don't run again */
    return 0;
}

References iax_frame::af, ast_clear_flag, AST_FRFLAG_HAS_TIMING_INFO, ast_test_flag64, iax_frame::callno, iax_frame::data, iax2_frame_free(), iax2_queue_frame(), IAX_ALREADYGONE, iaxs, and iax_frame::retrans.

Referenced by __get_from_jb(), and schedule_delivery().

__expire_registry()

static void __expire_registry ( const void *  data )

static

Definition at line 9080 of file chan_iax2.c.

{
    struct iax2_peer *peer = (struct iax2_peer *) data;
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    if (!peer)
        return;
    if (peer->expire == -1) {
        /* Removed already (possibly through CLI), ignore */
        return;
    }
 
    peer->expire = -1;
 
    ast_debug(1, "Expiring registration for peer '%s'\n", peer->name);
    if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(peer, IAX_TEMPONLY|IAX_RTCACHEFRIENDS)))
        realtime_update_peer(peer->name, &peer->addr, 0);
    ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
    blob = ast_json_pack("{s: s, s: s}",
        "peer_status", "Unregistered",
        "cause", "Expired");
    ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
    /* modify entry in peercnts table as _not_ registered */
    peercnt_modify((unsigned char) 0, 0, &peer->addr);
    /* Reset the address */
    ast_sockaddr_setnull(&peer->addr);
    /* Reset expiry value */
    peer->expiry = min_reg_expire;
    if (!ast_test_flag64(peer, IAX_TEMPONLY))
        ast_db_del("IAX/Registry", peer->name);
    register_peer_exten(peer, 0);
    ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
    if (iax2_regfunk)
        iax2_regfunk(peer->name, 0);
 
    if (ast_test_flag64(peer, IAX_RTAUTOCLEAR))
        unlink_peer(peer);
 
    peer_unref(peer);
}

References iax2_peer::addr, ast_db_del(), ast_debug, AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_endpoint_blob_publish(), AST_ENDPOINT_OFFLINE, ast_endpoint_set_state(), ast_endpoint_state_type(), ast_json_pack(), ast_json_unref(), ast_sockaddr_setnull(), ast_test_flag64, iax2_peer::endpoint, iax2_peer::expire, iax2_peer::expiry, globalflags, iax2_regfunk, IAX_RTAUTOCLEAR, IAX_RTCACHEFRIENDS, IAX_RTUPDATE, IAX_TEMPONLY, min_reg_expire, iax2_peer::name, NULL, peer_unref(), peercnt_modify(), RAII_VAR, realtime_update_peer(), register_peer_exten(), and unlink_peer().

Referenced by expire_registry().

__find_callno()

static int __find_callno ( unsigned short  callno, unsigned short  dcallno, struct ast_sockaddr *  addr, int  new, int  sockfd, int  return_locked, int  check_dcallno  )

static

Note

Calling this function while holding another pvt lock can cause a deadlock.

Definition at line 3181 of file chan_iax2.c.

{
    int res = 0;
    int x;
    /* this call is calltoken validated as long as it is either NEW_FORCE
     * or NEW_ALLOW_CALLTOKEN_VALIDATED */
    int validated = (new > NEW_ALLOW) ? 1 : 0;
    char host[80];
 
    if (new <= NEW_ALLOW) {
        if (callno) {
            struct chan_iax2_pvt *pvt;
            struct chan_iax2_pvt tmp_pvt = {
                .callno = dcallno,
                .peercallno = callno,
                .transfercallno = callno,
                /* hack!! */
                .frames_received = check_dcallno,
            };
 
            ast_sockaddr_copy(&tmp_pvt.addr, addr);
            /* this works for finding normal call numbers not involving transferring */
            if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
                if (return_locked) {
                    ast_mutex_lock(&iaxsl[pvt->callno]);
                }
                res = pvt->callno;
                ao2_ref(pvt, -1);
                pvt = NULL;
                return res;
            }
            /* this searches for transfer call numbers that might not get caught otherwise */
            memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
            ast_sockaddr_copy(&tmp_pvt.transfer, addr);
            if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
                if (return_locked) {
                    ast_mutex_lock(&iaxsl[pvt->callno]);
                }
                res = pvt->callno;
                ao2_ref(pvt, -1);
                pvt = NULL;
                return res;
            }
        }
            /* This will occur on the first response to a message that we initiated,
         * such as a PING. */
        if (dcallno) {
            ast_mutex_lock(&iaxsl[dcallno]);
        }
        if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(addr, callno, dcallno, iaxs[dcallno], check_dcallno)) {
            iaxs[dcallno]->peercallno = callno;
            res = dcallno;
            store_by_peercallno(iaxs[dcallno]);
            if (!res || !return_locked) {
                ast_mutex_unlock(&iaxsl[dcallno]);
            }
            return res;
        }
        if (dcallno) {
            ast_mutex_unlock(&iaxsl[dcallno]);
        }
    }
    if (!res && (new >= NEW_ALLOW)) {
        callno_entry entry;
 
        /* It may seem odd that we look through the peer list for a name for
         * this *incoming* call.  Well, it is weird.  However, users don't
         * have an IP address/port number that we can match against.  So,
         * this is just checking for a peer that has that IP/port and
         * assuming that we have a user of the same name.  This isn't always
         * correct, but it will be changed if needed after authentication. */
        if (!iax2_getpeername(*addr, host, sizeof(host)))
            snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(addr));
 
        if (peercnt_add(addr)) {
            /* This address has hit its callnumber limit.  When the limit
             * is reached, the connection is not added to the peercnts table.*/
            return 0;
        }
 
        if (get_unused_callno(CALLNO_TYPE_NORMAL, validated, &entry)) {
            /* since we ran out of space, remove the peercnt
             * entry we added earlier */
            peercnt_remove_by_addr(addr);
            ast_log(LOG_WARNING, "No more space\n");
            return 0;
        }
        x = CALLNO_ENTRY_GET_CALLNO(entry);
        ast_mutex_lock(&iaxsl[x]);
 
        iaxs[x] = new_iax(addr, host);
        if (iaxs[x]) {
            if (iaxdebug)
                ast_debug(1, "Creating new call structure %d\n", x);
            iaxs[x]->callno_entry = entry;
            iaxs[x]->sockfd = sockfd;
            ast_sockaddr_copy(&iaxs[x]->addr, addr);
            iaxs[x]->peercallno = callno;
            iaxs[x]->callno = x;
            iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
            iaxs[x]->expiry = min_reg_expire;
            iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
            iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
            iaxs[x]->amaflags = amaflags;
            ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
            ast_string_field_set(iaxs[x], accountcode, accountcode);
            ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
            ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
            ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
 
            if (iaxs[x]->peercallno) {
                store_by_peercallno(iaxs[x]);
            }
        } else {
            ast_log(LOG_WARNING, "Out of resources\n");
            ast_mutex_unlock(&iaxsl[x]);
            replace_callno(CALLNO_ENTRY_TO_PTR(entry));
            return 0;
        }
        if (!return_locked)
            ast_mutex_unlock(&iaxsl[x]);
        res = x;
    }
    return res;
}

References accountcode, chan_iax2_pvt::addr, amaflags, chan_iax2_pvt::amaflags, ao2_find, ao2_ref, ast_copy_flags64, ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_copy(), ast_sockaddr_stringify(), ast_string_field_set, chan_iax2_pvt::callno, chan_iax2_pvt::callno_entry, CALLNO_ENTRY_GET_CALLNO, CALLNO_ENTRY_TO_PTR, CALLNO_TYPE_NORMAL, default_parkinglot, DEFAULT_RETRY_TIME, chan_iax2_pvt::expiry, get_unused_callno(), globalflags, chan_iax2_pvt::host, iax2_getpeername(), iax2_sched_add(), IAX_FORCE_ENCRYPT, IAX_NOTRANSFER, iax_peercallno_pvts, IAX_RECVCONNECTEDLINE, IAX_SENDCONNECTEDLINE, iax_transfercallno_pvts, IAX_TRANSFERMEDIA, IAX_USEJITTERBUF, iaxdebug, iaxs, iaxsl, chan_iax2_pvt::lagid, lagrq_time, LOG_WARNING, match(), min_reg_expire, mohinterpret, mohsuggest, NEW_ALLOW, new_iax(), NULL, OBJ_POINTER, chan_iax2_pvt::parkinglot, chan_iax2_pvt::peercallno, peercnt_add(), peercnt_remove_by_addr(), ping_time, chan_iax2_pvt::pingid, chan_iax2_pvt::pingtime, replace_callno(), send_lagrq(), send_ping(), chan_iax2_pvt::sockfd, store_by_peercallno(), and chan_iax2_pvt::transfer.

Referenced by find_callno(), and find_callno_locked().

__get_from_jb()

static void __get_from_jb ( const void *  p )

static

Definition at line 4198 of file chan_iax2.c.

{
    int callno = PTR_TO_CALLNO(p);
    struct chan_iax2_pvt *pvt = NULL;
    struct iax_frame *fr;
    jb_frame frame;
    int ret;
    long ms;
    long next;
    struct timeval now = ast_tvnow();
    struct ast_format *voicefmt;
 
    /* Make sure we have a valid private structure before going on */
    ast_mutex_lock(&iaxsl[callno]);
    pvt = iaxs[callno];
    if (!pvt) {
        /* No go! */
        ast_mutex_unlock(&iaxsl[callno]);
        return;
    }
 
    pvt->jbid = -1;
 
    /* round up a millisecond since ast_sched_runq does; */
    /* prevents us from spinning while waiting for our now */
    /* to catch up with runq's now */
    now.tv_usec += 1000;
 
    ms = ast_tvdiff_ms(now, pvt->rxcore);
    if (ms >= (next = jb_next(pvt->jb))) {
        voicefmt = ast_format_compatibility_bitfield2format(pvt->voiceformat);
        if (!voicefmt) {
            /* pvt->voiceformat won't be set if we haven't received any voice frames yet.
             * In this case, fall back to using the format negotiated during call setup,
             * so we don't stall the jitterbuffer completely. */
            voicefmt = ast_format_compatibility_bitfield2format(pvt->peerformat);
            if (!voicefmt) {
                /* As a last resort, we can use pvt->chosenformat.
                 * This is set when we receive a call (either authenticated or unauthenticated),
                 * so even if we haven't received any voice frames yet, we can still use the
                 * right format.
                 *
                 * If we have to do this, in most cases, we aren't even processing voice frames
                 * anyways, it's likely a non-voice frame. In that case, the format doesn't
                 * really matter so much, because we could just pass 20 to jb_get instead
                 * of calling ast_format_get_default_ms. However, until jb_get returns,
                 * we don't actually know what kind of frame it is for sure, so use
                 * the right format just to be safe. */
                voicefmt = ast_format_compatibility_bitfield2format(pvt->chosenformat);
            }
        }
        if (!voicefmt) {
            /* This should never happen, since we should always be able to have an acceptable format to use. */
            ast_log(LOG_ERROR, "No voice, peer, or chosen format available on %s, backlogging frame\n", ast_channel_name(pvt->owner));
            goto cleanup; /* Don't crash if there's no voice format */
        }
        ret = jb_get(pvt->jb, &frame, ms, ast_format_get_default_ms(voicefmt));
        switch(ret) {
        case JB_OK:
            fr = frame.data;
            __do_deliver(fr);
            /* __do_deliver() can cause the call to disappear */
            pvt = iaxs[callno];
            break;
        case JB_INTERP:
        {
            struct ast_frame af = { 0, };
 
            /* create an interpolation frame */
            af.frametype = AST_FRAME_VOICE;
            af.subclass.format = voicefmt;
            af.samples  = frame.ms * (ast_format_get_sample_rate(voicefmt) / 1000);
            af.src  = "IAX2 JB interpolation";
            af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
            af.offset = AST_FRIENDLY_OFFSET;
 
            /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
             * which we'd need to malloc, and then it would free it.  That seems like a drag */
            if (!ast_test_flag64(iaxs[callno], IAX_ALREADYGONE)) {
                iax2_queue_frame(callno, &af);
                /* iax2_queue_frame() could cause the call to disappear */
                pvt = iaxs[callno];
            }
        }
        break;
        case JB_DROP:
            iax2_frame_free(frame.data);
            break;
        case JB_NOFRAME:
        case JB_EMPTY:
            /* do nothing */
            break;
        default:
            /* shouldn't happen */
            break;
        }
    }
cleanup:
    if (pvt)
        update_jbsched(pvt);
    ast_mutex_unlock(&iaxsl[callno]);
}

References __do_deliver(), ast_channel_name(), ast_format_compatibility_bitfield2format(), ast_format_get_default_ms(), ast_format_get_sample_rate(), AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_test_flag64, ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), chan_iax2_pvt::chosenformat, cleanup(), jb_frame::data, ast_frame::delivery, ast_frame_subclass::format, ast_frame::frametype, iax2_frame_free(), iax2_queue_frame(), IAX_ALREADYGONE, iaxs, iaxsl, chan_iax2_pvt::jb, JB_DROP, JB_EMPTY, jb_get(), JB_INTERP, jb_next(), JB_NOFRAME, JB_OK, chan_iax2_pvt::jbid, LOG_ERROR, jb_frame::ms, iax_frame::next, ast_frame::next, NULL, ast_frame::offset, chan_iax2_pvt::owner, chan_iax2_pvt::peerformat, PTR_TO_CALLNO, chan_iax2_pvt::rxcore, ast_frame::samples, ast_frame::src, ast_frame::subclass, update_jbsched(), and chan_iax2_pvt::voiceformat.

Referenced by get_from_jb().

__iax2_do_register_s()

static void __iax2_do_register_s ( const void *  data )

static

Definition at line 8723 of file chan_iax2.c.

{
    struct iax2_registry *reg = (struct iax2_registry *)data;
 
    if (ast_sockaddr_isnull(&reg->addr)) {
        reg->addr.ss.ss_family = AST_AF_UNSPEC;
        ast_dnsmgr_lookup(reg->hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL);
        if (!ast_sockaddr_port(&reg->addr)) {
            ast_sockaddr_set_port(&reg->addr, reg->port);
        } else {
            reg->port = ast_sockaddr_port(&reg->addr);
        }
    }
 
    reg->expire = -1;
    iax2_do_register(reg);
}

References iax2_registry::addr, AST_AF_UNSPEC, ast_dnsmgr_lookup(), ast_sockaddr_isnull(), ast_sockaddr_port, ast_sockaddr_set_port, iax2_registry::dnsmgr, iax2_registry::expire, iax2_registry::hostname, iax2_do_register(), NULL, iax2_registry::port, srvlookup, and ast_sockaddr::ss.

Referenced by iax2_do_register_s().

__iax2_poke_noanswer()

static void __iax2_poke_noanswer ( const void *  data )

static

Definition at line 12535 of file chan_iax2.c.

{
    struct iax2_peer *peer = (struct iax2_peer *)data;
    int callno;
 
    if (peer->lastms > -1) {
        RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
        ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Time: %d\n", peer->name, peer->lastms);
        ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
        blob = ast_json_pack("{s: s, s: i}",
            "peer_status", "Unreachable",
            "time", peer->lastms);
        ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
        ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
    }
    if ((callno = peer->callno) > 0) {
        ast_mutex_lock(&iaxsl[callno]);
        iax2_destroy(callno);
        ast_mutex_unlock(&iaxsl[callno]);
    }
    peer->callno = 0;
    peer->lastms = -1;
    /* Try again quickly */
    peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
    if (peer->pokeexpire == -1)
        peer_unref(peer);
}

References AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_endpoint_blob_publish(), AST_ENDPOINT_OFFLINE, ast_endpoint_set_state(), ast_endpoint_state_type(), ast_json_pack(), ast_json_unref(), ast_log, ast_mutex_lock, ast_mutex_unlock, iax2_peer::callno, iax2_peer::endpoint, iax2_destroy(), iax2_poke_peer_s(), iax2_sched_add(), iaxsl, iax2_peer::lastms, LOG_NOTICE, iax2_peer::name, NULL, peer_ref(), peer_unref(), iax2_peer::pokeexpire, iax2_peer::pokefreqnotok, and RAII_VAR.

Referenced by iax2_poke_noanswer().

__iax2_poke_peer_s()

static void __iax2_poke_peer_s ( const void *  data )

static

Definition at line 9573 of file chan_iax2.c.

{
    struct iax2_peer *peer = (struct iax2_peer *)data;
    iax2_poke_peer(peer, 0);
    peer_unref(peer);
}

References iax2_poke_peer(), and peer_unref().

Referenced by iax2_poke_peer_s().

__iax2_show_peers()

static int __iax2_show_peers ( int  fd, int *  total, struct mansession *  s, const int  argc, const char *const  argv[]  )

static

Definition at line 7086 of file chan_iax2.c.

{
    struct show_peers_context cont = {
        .havepattern = 0,
        .idtext = "",
        .registeredonly = 0,
 
        .peerlist = 0,
 
        .total_peers = 0,
        .online_peers = 0,
        .offline_peers = 0,
        .unmonitored_peers = 0,
    };
 
    struct ao2_iterator i;
 
    struct iax2_peer *peer = NULL;
 
    switch (argc) {
    case 6:
        if (!strcasecmp(argv[3], "registered"))
            cont.registeredonly = 1;
        else
            return RESULT_SHOWUSAGE;
        if (!strcasecmp(argv[4], "like")) {
            if (regcomp(&cont.regexbuf, argv[5], REG_EXTENDED | REG_NOSUB))
                return RESULT_SHOWUSAGE;
            cont.havepattern = 1;
        } else
            return RESULT_SHOWUSAGE;
        break;
    case 5:
        if (!strcasecmp(argv[3], "like")) {
            if (regcomp(&cont.regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
                return RESULT_SHOWUSAGE;
            cont.havepattern = 1;
        } else
            return RESULT_SHOWUSAGE;
        break;
    case 4:
        if (!strcasecmp(argv[3], "registered")) {
            cont.registeredonly = 1;
        } else {
            return RESULT_SHOWUSAGE;
        }
        break;
    case 3:
        break;
    default:
        return RESULT_SHOWUSAGE;
    }
 
 
    if (!s) {
        ast_cli(fd, PEERS_FORMAT2, "Name/Username", "Host", "   ", "Mask", "Port", "   ", "Status", "Description");
    }
 
    i = ao2_iterator_init(peers, 0);
    for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
 
        if (cont.registeredonly && ast_sockaddr_isnull(&peer->addr)) {
            continue;
        }
        if (cont.havepattern && regexec(&cont.regexbuf, peer->name, 0, NULL, 0)) {
            continue;
        }
 
        _iax2_show_peers_one(fd, s, &cont, peer);
 
    }
    ao2_iterator_destroy(&i);
 
    if (!s) {
        ast_cli(fd,"%d iax2 peers [%d online, %d offline, %d unmonitored]\n",
            cont.total_peers, cont.online_peers, cont.offline_peers, cont.unmonitored_peers);
    }
 
    if (cont.havepattern) {
        regfree(&cont.regexbuf);
    }
 
    if (total) {
        *total = cont.total_peers;
    }
 
    return RESULT_SUCCESS;
 
}

References _iax2_show_peers_one(), iax2_peer::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_cli(), ast_sockaddr_isnull(), show_peers_context::havepattern, iax2_peer::name, NULL, show_peers_context::offline_peers, show_peers_context::online_peers, peer_unref(), PEERS_FORMAT2, show_peers_context::regexbuf, show_peers_context::registeredonly, RESULT_SHOWUSAGE, RESULT_SUCCESS, total, show_peers_context::total_peers, and show_peers_context::unmonitored_peers.

Referenced by handle_cli_iax2_show_peers(), and manager_iax2_show_peers().

__reg_module()

static void __reg_module ( void  )

static

Definition at line 15186 of file chan_iax2.c.

__schedule_action()

static int __schedule_action ( void(*)(const void *data)  func, const void *  data, const char *  funcname  )

static

Definition at line 1725 of file chan_iax2.c.

{
    struct iax2_thread *thread;
    static time_t lasterror;
    time_t t;
 
    thread = find_idle_thread();
    if (thread != NULL) {
        thread->schedfunc = func;
        thread->scheddata = data;
        thread->iostate = IAX_IOSTATE_SCHEDREADY;
#ifdef DEBUG_SCHED_MULTITHREAD
        ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
#endif
        signal_condition(&thread->lock, &thread->cond);
        return 0;
    }
    time(&t);
    if (t != lasterror) {
        lasterror = t;
        ast_debug(1, "Out of idle IAX2 threads for scheduling! (%s)\n", funcname);
    }
 
    return -1;
}

References ast_copy_string(), ast_debug, find_idle_thread(), IAX_IOSTATE_SCHEDREADY, NULL, signal_condition(), and thread.

__send_command()

static int __send_command ( struct chan_iax2_pvt *  i, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen, int  seqno, int  now, int  transfer, int  final  )

static

Definition at line 7852 of file chan_iax2.c.

{
    struct ast_frame f = { 0, };
    int res = 0;
 
    f.frametype = type;
    f.subclass.integer = command;
    f.datalen = datalen;
    f.src = __FUNCTION__;
    f.data.ptr = (void *) data;
 
    if ((res = queue_signalling(i, &f)) <= 0) {
        return res;
    }
 
    return iax2_send(i, &f, ts, seqno, now, transfer, final);
}

References ast_frame::data, ast_frame::datalen, ast_frame::frametype, iax2_send(), ast_frame_subclass::integer, ast_frame::ptr, queue_signalling(), ast_frame::seqno, ast_frame::src, ast_frame::subclass, transfer(), ast_frame::ts, and type.

Referenced by send_command(), send_command_final(), send_command_immediate(), and send_command_transfer().

__send_lagrq()

static void __send_lagrq ( const void *  data )

static

Definition at line 1853 of file chan_iax2.c.

{
    int callno = PTR_TO_CALLNO(data);
 
    if (iax2_lock_callno_unless_destroyed(callno) == 0) {
        ast_debug(3, "Hangup initiated on call %d, aborting __send_lagrq\n", callno);
        return;
    }
 
    /* Mark lagid as invalid scheduler id. */
    iaxs[callno]->lagid = -1;
 
    /* callno is now locked. */
    if (iaxs[callno]->peercallno) {
        /* Send LAGRQ packet. */
        send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
 
        /* Schedule sending next lagrq. */
        iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
    }
 
    ast_mutex_unlock(&iaxsl[callno]);
}

References ast_debug, AST_FRAME_IAX, ast_mutex_unlock, iax2_thread::callno, iax2_lock_callno_unless_destroyed(), iax2_sched_add(), IAX_COMMAND_LAGRQ, iaxs, iaxsl, chan_iax2_pvt::lagid, lagrq_time, NULL, PTR_TO_CALLNO, send_command(), and send_lagrq().

Referenced by send_lagrq().

__send_ping()

static void __send_ping ( const void *  data )

static

Definition at line 1789 of file chan_iax2.c.

{
    int callno = PTR_TO_CALLNO(data);
 
    if (iax2_lock_callno_unless_destroyed(callno) == 0) {
        ast_debug(3, "Hangup initiated on call %d, aborting __send_ping\n", callno);
        return;
    }
 
    /* Mark pingid as invalid scheduler id. */
    iaxs[callno]->pingid = -1;
 
    /* callno is now locked. */
    if (iaxs[callno]->peercallno) {
        /* Send PING packet. */
        send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
 
        /* Schedule sending next ping. */
        iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
    }
 
    ast_mutex_unlock(&iaxsl[callno]);
}

References ast_debug, AST_FRAME_IAX, ast_mutex_unlock, iax2_thread::callno, iax2_lock_callno_unless_destroyed(), iax2_sched_add(), IAX_COMMAND_PING, iaxs, iaxsl, NULL, ping_time, chan_iax2_pvt::pingid, PTR_TO_CALLNO, send_command(), and send_ping().

Referenced by send_ping().

__unload_module()

static int __unload_module ( void  )

static

Definition at line 14813 of file chan_iax2.c.

{
    int x;
 
    network_change_stasis_unsubscribe();
    acl_change_stasis_unsubscribe();
 
    ast_manager_unregister("IAXpeers");
    ast_manager_unregister("IAXpeerlist");
    ast_manager_unregister("IAXnetstats");
    ast_manager_unregister("IAXregistry");
    ast_unregister_application(papp);
    ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
    ast_unregister_switch(&iax2_switch);
    ast_channel_unregister(&iax2_tech);
 
    if (netthreadid != AST_PTHREADT_NULL) {
        pthread_cancel(netthreadid);
        pthread_kill(netthreadid, SIGURG);
        pthread_join(netthreadid, NULL);
    }
 
    for (x = 0; x < ARRAY_LEN(iaxs); x++) {
        if (iaxs[x]) {
            iax2_destroy(x);
        }
    }
 
    /* Call for all threads to halt */
    cleanup_thread_list(&active_list);
    cleanup_thread_list(&dynamic_list);
    cleanup_thread_list(&idle_list);
 
    ast_netsock_release(netsock);
    ast_netsock_release(outsock);
    for (x = 0; x < ARRAY_LEN(iaxs); x++) {
        if (iaxs[x]) {
            iax2_destroy(x);
        }
    }
    ast_manager_unregister( "IAXpeers" );
    ast_manager_unregister( "IAXpeerlist" );
    ast_manager_unregister( "IAXnetstats" );
    ast_manager_unregister( "IAXregistry" );
    ast_unregister_application(papp);
    ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
    ast_unregister_switch(&iax2_switch);
    ast_channel_unregister(&iax2_tech);
    delete_users();
    iax_provision_unload();
    iax_firmware_unload();
 
    for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
        ast_mutex_destroy(&iaxsl[x]);
    }
 
    ao2_ref(peers, -1);
    ao2_ref(users, -1);
    ao2_ref(iax_peercallno_pvts, -1);
    ao2_ref(iax_transfercallno_pvts, -1);
    ao2_ref(callno_limits, -1);
    ao2_ref(calltoken_ignores, -1);
    if (timer) {
        ast_timer_close(timer);
        timer = NULL;
    }
    transmit_processor = ast_taskprocessor_unreference(transmit_processor);
 
    ast_sched_clean_by_callback(sched, peercnt_remove_cb, peercnt_remove_cb);
    ast_sched_context_destroy(sched);
    sched = NULL;
    ao2_ref(peercnts, -1);
 
    ast_context_destroy_by_name(regcontext, "IAX2");
    ast_unload_realtime("iaxpeers");
 
    ao2_ref(iax2_tech.capabilities, -1);
    iax2_tech.capabilities = NULL;
    return 0;
}

References acl_change_stasis_unsubscribe(), ao2_ref, ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_context_destroy_by_name(), ast_manager_unregister(), ast_mutex_destroy, ast_netsock_release(), AST_PTHREADT_NULL, ast_sched_clean_by_callback(), ast_sched_context_destroy(), ast_taskprocessor_unreference(), ast_timer_close(), ast_unload_realtime(), ast_unregister_application(), ast_unregister_switch(), callno_limits, calltoken_ignores, ast_channel_tech::capabilities, cleanup_thread_list(), cli_iax2, delete_users(), iax2_destroy(), iax2_switch, iax2_tech, iax_firmware_unload(), iax_peercallno_pvts, iax_provision_unload(), iax_transfercallno_pvts, iaxs, iaxsl, netsock, netthreadid, network_change_stasis_unsubscribe(), NULL, outsock, papp, peercnt_remove_cb(), peercnts, regcontext, timer, and transmit_processor.

Referenced by load_module(), and unload_module().

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 15186 of file chan_iax2.c.

_iax2_show_peers_one()

static void _iax2_show_peers_one ( int  fd, struct mansession *  s, struct show_peers_context *  cont, struct iax2_peer *  peer  )

static

Definition at line 6985 of file chan_iax2.c.

{
    char name[256] = "";
    char status[64];
    int retstatus;
    struct ast_str *encmethods = ast_str_alloca(256);
 
    char *tmp_host, *tmp_mask, *tmp_port;
 
    tmp_host = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
    tmp_mask = ast_strdupa(ast_sockaddr_stringify_addr(&peer->mask));
    tmp_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
 
    if (!ast_strlen_zero(peer->username)) {
        snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
    } else {
        ast_copy_string(name, peer->name, sizeof(name));
    }
 
    encmethods_to_str(peer->encmethods, &encmethods);
    retstatus = peer_status(peer, status, sizeof(status));
    if (retstatus > 0) {
        cont->online_peers++;
    } else if (!retstatus) {
        cont->offline_peers++;
    } else {
        cont->unmonitored_peers++;
    }
 
    if (s) {
        if (cont->peerlist) { /* IAXpeerlist */
            astman_append(s,
                "Event: PeerEntry\r\n%s"
                "Channeltype: IAX\r\n",
                cont->idtext);
            if (!ast_strlen_zero(peer->username)) {
                astman_append(s,
                    "ObjectName: %s\r\n"
                    "ObjectUsername: %s\r\n",
                    peer->name,
                    peer->username);
            } else {
                astman_append(s,
                    "ObjectName: %s\r\n",
                    name);
            }
        } else { /* IAXpeers */
            astman_append(s,
                "Event: PeerEntry\r\n%s"
                "Channeltype: IAX2\r\n"
                "ObjectName: %s\r\n",
                cont->idtext,
                name);
        }
        astman_append(s,
            "ChanObjectType: peer\r\n"
            "IPaddress: %s\r\n",
            tmp_host);
        if (cont->peerlist) { /* IAXpeerlist */
            astman_append(s,
                "Mask: %s\r\n"
                "Port: %s\r\n",
                tmp_mask,
                tmp_port);
        } else { /* IAXpeers */
            astman_append(s,
                "IPport: %s\r\n",
                tmp_port);
        }
        astman_append(s,
            "Dynamic: %s\r\n"
            "Trunk: %s\r\n"
            "Encryption: %s\r\n"
            "Status: %s\r\n",
            ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no",
            ast_test_flag64(peer, IAX_TRUNK) ? "yes" : "no",
            peer->encmethods ? ast_str_buffer(encmethods) : "no",
            status);
        if (cont->peerlist) { /* IAXpeerlist */
            astman_append(s, "\r\n");
        } else { /* IAXpeers */
            astman_append(s,
                "Description: %s\r\n\r\n",
                peer->description);
        }
    } else {
        ast_cli(fd, PEERS_FORMAT,
            name,
            tmp_host,
            ast_test_flag64(peer, IAX_DYNAMIC) ? "(D)" : "(S)",
            tmp_mask,
            tmp_port,
            ast_test_flag64(peer, IAX_TRUNK) ? "(T)" : "   ",
            peer->encmethods ? "(E)" : "   ",
            status,
            peer->description);
    }
 
    cont->total_peers++;
}

References iax2_peer::addr, ast_cli(), ast_copy_string(), ast_sockaddr_stringify_addr(), ast_sockaddr_stringify_port(), ast_str_alloca, ast_str_buffer(), ast_strdupa, ast_strlen_zero(), ast_test_flag64, astman_append(), iax2_peer::description, iax2_peer::encmethods, encmethods_to_str(), IAX_DYNAMIC, IAX_TRUNK, show_peers_context::idtext, iax2_peer::mask, name, iax2_peer::name, show_peers_context::offline_peers, show_peers_context::online_peers, peer_status(), show_peers_context::peerlist, PEERS_FORMAT, status, show_peers_context::total_peers, show_peers_context::unmonitored_peers, and iax2_peer::username.

Referenced by __iax2_show_peers(), and manager_iax2_show_peer_list().

acf_channel_read()

static int acf_channel_read ( struct ast_channel *  chan, const char *  funcname, char *  preparse, char *  buf, size_t  buflen  )

static

Definition at line 14679 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt;
    unsigned int callno;
    int res = 0;
 
    if (!chan || ast_channel_tech(chan) != &iax2_tech) {
        ast_log(LOG_ERROR, "This function requires a valid IAX2 channel\n");
        return -1;
    }
 
    callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
    ast_mutex_lock(&iaxsl[callno]);
    if (!(pvt = iaxs[callno])) {
        ast_mutex_unlock(&iaxsl[callno]);
        return -1;
    }
 
    if (!strcasecmp(args, "osptoken")) {
        ast_copy_string(buf, pvt->osptoken, buflen);
    } else if (!strcasecmp(args, "peerip")) {
        ast_copy_string(buf, !ast_sockaddr_isnull(&pvt->addr) ? ast_sockaddr_stringify_addr(&pvt->addr) : "", buflen);
    } else if (!strcasecmp(args, "peername")) {
        ast_copy_string(buf, pvt->username, buflen);
    } else if (!strcasecmp(args, "secure_signaling") || !strcasecmp(args, "secure_media")) {
        snprintf(buf, buflen, "%s", IAX_CALLENCRYPTED(pvt) ? "1" : "");
    } else {
        res = -1;
    }
 
    ast_mutex_unlock(&iaxsl[callno]);
 
    return res;
}

References chan_iax2_pvt::addr, args, ast_channel_tech(), ast_channel_tech_pvt(), ast_copy_string(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_isnull(), ast_sockaddr_stringify_addr(), buf, chan_iax2_pvt::callno, iax2_tech, IAX_CALLENCRYPTED, iaxs, iaxsl, LOG_ERROR, chan_iax2_pvt::osptoken, PTR_TO_CALLNO, and chan_iax2_pvt::username.

acf_iaxvar_read()

static int acf_iaxvar_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 10159 of file chan_iax2.c.

{
    struct ast_datastore *variablestore;
    AST_LIST_HEAD(, ast_var_t) *varlist;
    struct ast_var_t *var;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
    if (!variablestore) {
        *buf = '\0';
        return 0;
    }
    varlist = variablestore->data;
 
    AST_LIST_LOCK(varlist);
    AST_LIST_TRAVERSE(varlist, var, entries) {
        if (strcmp(var->name, data) == 0) {
            ast_copy_string(buf, var->value, len);
            break;
        }
    }
    AST_LIST_UNLOCK(varlist);
    return 0;
}

References ast_channel_datastore_find(), ast_copy_string(), AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, buf, ast_datastore::data, ast_var_t::entries, iax2_variable_datastore_info, len(), LOG_WARNING, NULL, and var.

acf_iaxvar_write()

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

static

Definition at line 10188 of file chan_iax2.c.

{
    struct ast_datastore *variablestore;
    AST_LIST_HEAD(, ast_var_t) *varlist;
    struct ast_var_t *var;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
    if (!variablestore) {
        variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
        if (!variablestore) {
            ast_log(LOG_ERROR, "Memory allocation error\n");
            return -1;
        }
        varlist = ast_calloc(1, sizeof(*varlist));
        if (!varlist) {
            ast_datastore_free(variablestore);
            ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
            return -1;
        }
 
        AST_LIST_HEAD_INIT(varlist);
        variablestore->data = varlist;
        variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
        ast_channel_datastore_add(chan, variablestore);
    } else
        varlist = variablestore->data;
 
    AST_LIST_LOCK(varlist);
    AST_LIST_TRAVERSE_SAFE_BEGIN(varlist, var, entries) {
        if (strcmp(var->name, data) == 0) {
            AST_LIST_REMOVE_CURRENT(entries);
            ast_var_delete(var);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
    var = ast_var_assign(data, value);
    if (var)
        AST_LIST_INSERT_TAIL(varlist, var, entries);
    else
        ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
    AST_LIST_UNLOCK(varlist);
    return 0;
}

References ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, ast_datastore_free(), AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log, ast_var_assign, ast_var_delete(), ast_datastore::data, DATASTORE_INHERIT_FOREVER, ast_var_t::entries, iax2_variable_datastore_info, ast_datastore::inheritance, LOG_ERROR, LOG_WARNING, NULL, value, and var.

acl_change_stasis_cb()

static void acl_change_stasis_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 1584 of file chan_iax2.c.

{
    if (stasis_message_type(message) != ast_named_acl_change_type()) {
        return;
    }
 
    ast_log(LOG_NOTICE, "Reloading chan_iax2 in response to ACL change event.\n");
    reload_config(1);
}

References ast_log, ast_named_acl_change_type(), LOG_NOTICE, reload_config(), and stasis_message_type().

Referenced by acl_change_stasis_subscribe(), and rtp_reload().

acl_change_stasis_subscribe()

static void acl_change_stasis_subscribe ( void  )

static

Definition at line 1542 of file chan_iax2.c.

{
    if (!acl_change_sub) {
        acl_change_sub = stasis_subscribe(ast_security_topic(),
            acl_change_stasis_cb, NULL);
        stasis_subscription_accept_message_type(acl_change_sub, ast_named_acl_change_type());
        stasis_subscription_set_filter(acl_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
    }
}

References acl_change_stasis_cb(), acl_change_sub, ast_named_acl_change_type(), ast_security_topic(), NULL, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, and stasis_subscription_set_filter().

Referenced by build_peer(), and build_user().

acl_change_stasis_unsubscribe()

static void acl_change_stasis_unsubscribe ( void  )

static

Definition at line 1552 of file chan_iax2.c.

{
    acl_change_sub = stasis_unsubscribe_and_join(acl_change_sub);
}

References acl_change_sub, and stasis_unsubscribe_and_join().

Referenced by __unload_module().

add_calltoken_ignore()

static int add_calltoken_ignore ( const char *  addr )

static

Definition at line 2868 of file chan_iax2.c.

{
    struct addr_range tmp;
    struct addr_range *addr_range = NULL;
    struct ast_ha *ha = NULL;
    int error = 0;
 
    if (ast_strlen_zero(addr)) {
        ast_log(LOG_WARNING, "invalid calltokenoptional (null)\n");
        return -1;
    }
 
    ha = ast_append_ha("permit", addr, NULL, &error);
 
    /* check for valid config information */
    if (error) {
        ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
        return -1;
    }
 
    ast_copy_ha(ha, &tmp.ha);
    /* find or create the addr_range */
    if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
        ao2_lock(addr_range);
        addr_range->delme = 0;
        ao2_unlock(addr_range);
    } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
        /* copy over config data into addr_range object */
        ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
        ao2_link(calltoken_ignores, addr_range);
    } else {
        ast_free_ha(ha);
        return -1;
    }
 
    ast_free_ha(ha);
    ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
 
    return 0;
}

References ast_ha::addr, ao2_alloc, ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_append_ha(), ast_copy_ha(), ast_free_ha(), ast_log, ast_strlen_zero(), calltoken_ignores, addr_range::delme, error(), addr_range::ha, LOG_WARNING, NULL, and OBJ_POINTER.

Referenced by set_config().

add_empty_calltoken_ie()

static void add_empty_calltoken_ie ( struct chan_iax2_pvt *  pvt, struct iax_ie_data *  ied  )

static

Definition at line 4898 of file chan_iax2.c.

{
    /* first make sure their are two empty bytes left in ied->buf */
    if (pvt && ied && (2 < ((int) sizeof(ied->buf) - ied->pos))) {
        ied->buf[ied->pos++] = IAX_IE_CALLTOKEN;  /* type */
        ied->buf[ied->pos++] = 0;   /* data size,  ZERO in this case */
        pvt->calltoken_ie_len = 2;
    }
}

References iax_ie_data::buf, chan_iax2_pvt::calltoken_ie_len, IAX_IE_CALLTOKEN, and iax_ie_data::pos.

Referenced by cache_get_callno_locked(), iax2_call(), iax2_do_register(), iax2_poke_peer(), and registry_rerequest().

addr_range_cmp_cb()

static int addr_range_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2524 of file chan_iax2.c.

{
    struct addr_range *lim1 = obj, *lim2 = arg;
    return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
            !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
            CMP_MATCH | CMP_STOP : 0;
}

References ast_ha::addr, ast_sockaddr_cmp_addr(), CMP_MATCH, CMP_STOP, addr_range::ha, and ast_ha::netmask.

Referenced by load_objects().

addr_range_delme_cb()

static int addr_range_delme_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2511 of file chan_iax2.c.

{
    struct addr_range *lim = obj;
    lim->delme = 1;
    return 0;
}

References addr_range::delme.

Referenced by set_config_destroy().

addr_range_hash_cb()

static int addr_range_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 2518 of file chan_iax2.c.

{
    const struct addr_range *lim = obj;
    return abs(ast_sockaddr_hash(&lim->ha.addr));
}

References abs, ast_ha::addr, ast_sockaddr_hash(), and addr_range::ha.

Referenced by load_objects().

addr_range_match_address_cb()

static int addr_range_match_address_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2548 of file chan_iax2.c.

{
    struct addr_range *addr_range = obj;
    struct ast_sockaddr *addr = arg;
    struct ast_sockaddr tmp_addr;
 
    ast_sockaddr_apply_netmask(addr, &addr_range->ha.netmask, &tmp_addr);
 
    if (!ast_sockaddr_cmp_addr(&tmp_addr, &addr_range->ha.addr)) {
        return CMP_MATCH | CMP_STOP;
    }
    return 0;
}

References ast_ha::addr, ast_sockaddr_apply_netmask(), ast_sockaddr_cmp_addr(), CMP_MATCH, CMP_STOP, addr_range::ha, and ast_ha::netmask.

Referenced by calltoken_required(), and set_peercnt_limit().

apply_context()

static int apply_context ( struct iax2_context *  con, const char *  context  )

static

Definition at line 7916 of file chan_iax2.c.

{
    while(con) {
        if (!strcmp(con->context, context) || !strcmp(con->context, "*"))
            return -1;
        con = con->next;
    }
    return 0;
}

References iax2_context::context, voicemailpwcheck::context, and iax2_context::next.

Referenced by check_access().

ast_cli_netstats()

static int ast_cli_netstats ( struct mansession *  s, int  fd, int  limit_fmt  )

static

Definition at line 7617 of file chan_iax2.c.

{
    int x;
    int numchans = 0;
    char first_message[10] = { 0, };
    char last_message[10] = { 0, };
#define ACN_FORMAT1 "%-24.25s %4u %4d %4d %5d %3d %5d %4d %6d %4d %4d %5d %3d %5d %4d %6d %s%s %4s%s\n"
#define ACN_FORMAT2 "%s %u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"
    for (x = 0; x < ARRAY_LEN(iaxs); x++) {
        ast_mutex_lock(&iaxsl[x]);
        if (iaxs[x]) {
            int localjitter, localdelay, locallost, locallosspct, localdropped, localooo;
            jb_info jbinfo;
            iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
            iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
 
            if(ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
                jb_getinfo(iaxs[x]->jb, &jbinfo);
                localjitter = jbinfo.jitter;
                localdelay = jbinfo.current - jbinfo.min;
                locallost = jbinfo.frames_lost;
                locallosspct = jbinfo.losspct/1000;
                localdropped = jbinfo.frames_dropped;
                localooo = jbinfo.frames_ooo;
            } else {
                localjitter = -1;
                localdelay = 0;
                locallost = -1;
                locallosspct = -1;
                localdropped = 0;
                localooo = -1;
            }
            if (s)
                astman_append(s, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
                    iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
                    iaxs[x]->pingtime,
                    localjitter,
                    localdelay,
                    locallost,
                    locallosspct,
                    localdropped,
                    localooo,
                    iaxs[x]->frames_received/1000,
                    iaxs[x]->remote_rr.jitter,
                    iaxs[x]->remote_rr.delay,
                    iaxs[x]->remote_rr.losscnt,
                    iaxs[x]->remote_rr.losspct,
                    iaxs[x]->remote_rr.dropped,
                    iaxs[x]->remote_rr.ooo,
                    iaxs[x]->remote_rr.packets/1000,
                    (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                    first_message,
                    (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                    last_message);
            else
                ast_cli(fd, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
                    iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
                    iaxs[x]->pingtime,
                    localjitter,
                    localdelay,
                    locallost,
                    locallosspct,
                    localdropped,
                    localooo,
                    iaxs[x]->frames_received/1000,
                    iaxs[x]->remote_rr.jitter,
                    iaxs[x]->remote_rr.delay,
                    iaxs[x]->remote_rr.losscnt,
                    iaxs[x]->remote_rr.losspct,
                    iaxs[x]->remote_rr.dropped,
                    iaxs[x]->remote_rr.ooo,
                    iaxs[x]->remote_rr.packets/1000,
                    (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                    first_message,
                    (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                    last_message);
            numchans++;
        }
        ast_mutex_unlock(&iaxsl[x]);
    }
 
    return numchans;
}

References ACN_FORMAT1, ACN_FORMAT2, ARRAY_LEN, ast_channel_name(), ast_cli(), ast_mutex_lock, ast_mutex_unlock, ast_test_flag64, astman_append(), jb_info::current, iax_rr::delay, iax_rr::dropped, chan_iax2_pvt::first_iax_message, jb_info::frames_dropped, jb_info::frames_lost, jb_info::frames_ooo, iax_frame_subclass2str(), IAX_USEJITTERBUF, iaxs, iaxsl, jb_getinfo(), jb_info::jitter, chan_iax2_pvt::last_iax_message, iax_rr::losscnt, iax_rr::losspct, jb_info::losspct, MARK_IAX_SUBCLASS_TX, jb_info::min, iax_rr::ooo, iax_rr::packets, and chan_iax2_pvt::remote_rr.

Referenced by handle_cli_iax2_show_netstats(), and manager_iax2_show_netstats().

ast_iax2_new()

static struct ast_channel * ast_iax2_new ( int  callno, int  state, iax2_format  capability, struct iax2_codec_pref *  prefs, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, unsigned int  cachable  )

static

Create new call, interface with the PBX core.

Definition at line 5946 of file chan_iax2.c.

{
    struct ast_channel *tmp = NULL;
    struct chan_iax2_pvt *i;
    struct iax2_peer *peer;
    struct ast_variable *v = NULL;
    struct ast_format_cap *native;
    struct ast_format *tmpfmt;
    ast_callid callid;
    char *peer_name = NULL;
 
    if (!(i = iaxs[callno])) {
        ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
        return NULL;
    }
 
    if (!capability) {
        ast_log(LOG_WARNING, "No formats specified for call to: IAX2/%s-%d\n",
            i->host, i->callno);
        return NULL;
    }
    native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!native) {
        return NULL;
    }
    if (iax2_codec_pref_best_bitfield2cap(capability, prefs, native)
        || !ast_format_cap_count(native)) {
        ast_log(LOG_WARNING, "No requested formats available for call to: IAX2/%s-%d\n",
            i->host, i->callno);
        ao2_ref(native, -1);
        return NULL;
    }
 
    if (!ast_strlen_zero(i->peer)) {
        peer_name = ast_strdupa(i->peer);
    } else if (!ast_strlen_zero(i->host)) {
        peer_name = ast_strdupa(i->host);
    }
 
    /* Don't hold call lock while making a channel or looking up a peer */
    ast_mutex_unlock(&iaxsl[callno]);
 
    if (!ast_strlen_zero(peer_name)) {
        peer = find_peer(peer_name, 1);
        if (peer && peer->endpoint) {
            tmp = ast_channel_alloc_with_endpoint(1, state, i->cid_num, i->cid_name,
                i->accountcode, i->exten, i->context, assignedids, requestor,
                i->amaflags, peer->endpoint, "IAX2/%s-%d", i->host, i->callno);
        }
        ao2_cleanup(peer);
    }
 
    if (!tmp) {
        tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode,
            i->exten, i->context, assignedids, requestor, i->amaflags, "IAX2/%s-%d",
            i->host, i->callno);
    }
 
    ast_mutex_lock(&iaxsl[callno]);
    if (i != iaxs[callno]) {
        if (tmp) {
            /* unlock and relock iaxsl[callno] to preserve locking order */
            ast_mutex_unlock(&iaxsl[callno]);
            ast_channel_unlock(tmp);
            tmp = ast_channel_release(tmp);
            ast_mutex_lock(&iaxsl[callno]);
        }
        ao2_ref(native, -1);
        return NULL;
    }
    if (!tmp) {
        ao2_ref(native, -1);
        return NULL;
    }
 
    ast_channel_stage_snapshot(tmp);
 
    if ((callid = iaxs[callno]->callid)) {
        ast_channel_callid_set(tmp, callid);
    }
 
    ast_channel_tech_set(tmp, &iax2_tech);
 
    /* We can support any format by default, until we get restricted */
    ast_channel_nativeformats_set(tmp, native);
    tmpfmt = ast_format_cap_get_format(native, 0);
 
    ast_channel_set_readformat(tmp, tmpfmt);
    ast_channel_set_rawreadformat(tmp, tmpfmt);
    ast_channel_set_writeformat(tmp, tmpfmt);
    ast_channel_set_rawwriteformat(tmp, tmpfmt);
 
    ao2_ref(tmpfmt, -1);
    ao2_ref(native, -1);
 
    ast_channel_tech_pvt_set(tmp, CALLNO_TO_PTR(i->callno));
 
    if (!ast_strlen_zero(i->parkinglot))
        ast_channel_parkinglot_set(tmp, i->parkinglot);
    /* Don't use ast_set_callerid() here because it will
     * generate a NewCallerID event before the NewChannel event */
    if (!ast_strlen_zero(i->ani)) {
        ast_channel_caller(tmp)->ani.number.valid = 1;
        ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->ani);
    } else if (!ast_strlen_zero(i->cid_num)) {
        ast_channel_caller(tmp)->ani.number.valid = 1;
        ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->cid_num);
    }
    ast_channel_dialed(tmp)->number.str = ast_strdup(i->dnid);
    if (!ast_strlen_zero(i->rdnis)) {
        ast_channel_redirecting(tmp)->from.number.valid = 1;
        ast_channel_redirecting(tmp)->from.number.str = ast_strdup(i->rdnis);
    }
    ast_channel_caller(tmp)->ani2 = i->calling_ani2;
    ast_channel_caller(tmp)->id.name.presentation = i->calling_pres;
    ast_channel_caller(tmp)->id.number.presentation = i->calling_pres;
    ast_channel_caller(tmp)->id.number.plan = i->calling_ton;
    ast_channel_dialed(tmp)->transit_network_select = i->calling_tns;
    if (!ast_strlen_zero(i->language))
        ast_channel_language_set(tmp, i->language);
    if (!ast_strlen_zero(i->accountcode))
        ast_channel_accountcode_set(tmp, i->accountcode);
    if (i->amaflags)
        ast_channel_amaflags_set(tmp, i->amaflags);
    ast_channel_context_set(tmp, i->context);
    ast_channel_exten_set(tmp, i->exten);
    if (i->adsi)
        ast_channel_adsicpe_set(tmp, i->peeradsicpe);
    else
        ast_channel_adsicpe_set(tmp, AST_ADSI_UNAVAILABLE);
    i->owner = tmp;
    i->capability = capability;
 
    if (!cachable) {
        ast_set_flag(ast_channel_flags(tmp), AST_FLAG_DISABLE_DEVSTATE_CACHE);
    }
 
    /* Set inherited variables */
    if (i->vars) {
        for (v = i->vars ; v ; v = v->next)
            pbx_builtin_setvar_helper(tmp, v->name, v->value);
    }
    if (i->iaxvars) {
        struct ast_datastore *variablestore;
        struct ast_variable *var, *prev = NULL;
        AST_LIST_HEAD(, ast_var_t) *varlist;
        ast_debug(1, "Loading up the channel with IAXVARs\n");
        varlist = ast_calloc(1, sizeof(*varlist));
        variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
        if (variablestore && varlist) {
            variablestore->data = varlist;
            variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
            AST_LIST_HEAD_INIT(varlist);
            for (var = i->iaxvars; var; var = var->next) {
                struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
                if (prev)
                    ast_free(prev);
                prev = var;
                if (!newvar) {
                    /* Don't abort list traversal, as this would leave i->iaxvars in an inconsistent state. */
                    ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                } else {
                    AST_LIST_INSERT_TAIL(varlist, newvar, entries);
                }
            }
            if (prev)
                ast_free(prev);
            i->iaxvars = NULL;
            ast_channel_datastore_add(i->owner, variablestore);
        } else {
            if (variablestore) {
                ast_datastore_free(variablestore);
            }
            if (varlist) {
                ast_free(varlist);
            }
        }
    }
 
    ast_channel_stage_snapshot_done(tmp);
    ast_channel_unlock(tmp);
 
    if (state != AST_STATE_DOWN) {
        if (ast_pbx_start(tmp)) {
            ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast_channel_name(tmp));
            /* unlock and relock iaxsl[callno] to preserve locking order */
            ast_mutex_unlock(&iaxsl[callno]);
            ast_hangup(tmp);
            ast_mutex_lock(&iaxsl[callno]);
            return NULL;
        }
    }
 
    ast_module_ref(ast_module_info->self);
    return tmp;
}

References chan_iax2_pvt::accountcode, chan_iax2_pvt::adsi, chan_iax2_pvt::amaflags, chan_iax2_pvt::ani, ast_party_caller::ani, ast_party_caller::ani2, ao2_cleanup, ao2_ref, AST_ADSI_UNAVAILABLE, ast_calloc, ast_channel_adsicpe_set(), ast_channel_alloc, ast_channel_alloc_with_endpoint, ast_channel_amaflags_set(), ast_channel_caller(), ast_channel_callid_set(), ast_channel_context_set(), ast_channel_datastore_add(), ast_channel_dialed(), ast_channel_exten_set(), ast_channel_flags(), ast_channel_name(), ast_channel_nativeformats_set(), ast_channel_redirecting(), ast_channel_release(), ast_channel_set_rawreadformat(), ast_channel_set_rawwriteformat(), ast_channel_set_readformat(), ast_channel_set_writeformat(), ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), ast_debug, AST_FLAG_DISABLE_DEVSTATE_CACHE, ast_format_cap_alloc, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_free, ast_hangup(), AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, ast_log, ast_module_ref, ast_mutex_lock, ast_mutex_unlock, ast_pbx_start(), ast_set_flag, AST_STATE_DOWN, ast_strdup, ast_strdupa, ast_strlen_zero(), ast_var_assign, chan_iax2_pvt::calling_ani2, chan_iax2_pvt::calling_pres, chan_iax2_pvt::calling_tns, chan_iax2_pvt::calling_ton, chan_iax2_pvt::callno, CALLNO_TO_PTR, chan_iax2_pvt::capability, chan_iax2_pvt::cid_name, chan_iax2_pvt::cid_num, chan_iax2_pvt::context, ast_datastore::data, DATASTORE_INHERIT_FOREVER, chan_iax2_pvt::dnid, iax2_peer::endpoint, ast_var_t::entries, chan_iax2_pvt::exten, find_peer(), ast_party_redirecting::from, chan_iax2_pvt::host, iax2_codec_pref_best_bitfield2cap(), iax2_tech, iax2_variable_datastore_info, iaxs, iaxsl, chan_iax2_pvt::iaxvars, ast_party_caller::id, ast_datastore::inheritance, chan_iax2_pvt::language, LOG_ERROR, LOG_WARNING, ast_party_id::name, ast_variable::name, ast_variable::next, NULL, ast_party_id::number, ast_party_dialed::number, chan_iax2_pvt::owner, chan_iax2_pvt::parkinglot, pbx_builtin_setvar_helper(), chan_iax2_pvt::peer, chan_iax2_pvt::peeradsicpe, ast_party_number::plan, ast_party_name::presentation, ast_party_number::presentation, chan_iax2_pvt::rdnis, ast_module_info::self, ast_party_number::str, ast_party_dialed::str, ast_party_dialed::transit_network_select, ast_party_number::valid, ast_variable::value, var, and chan_iax2_pvt::vars.

Referenced by iax2_request(), and socket_process_helper().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 15186 of file chan_iax2.c.

attempt_transmit()

static int attempt_transmit ( const void *  data )

static

Definition at line 3704 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__attempt_transmit, data))
#endif
        __attempt_transmit(data);
    return 0;
}

References __attempt_transmit(), ast_frame::data, and schedule_action.

Referenced by __attempt_transmit(), and transmit_frame().

auth_fail()

static int auth_fail ( int  callno, int  failcode  )

static

Definition at line 9498 of file chan_iax2.c.

{
    /* Schedule sending the authentication failure in one second, to prevent
       guessing */
    if (iaxs[callno]) {
        iaxs[callno]->authfail = failcode;
        if (delayreject) {
            iaxs[callno]->authid = iax2_sched_replace(iaxs[callno]->authid,
                sched, 1000, auth_reject, (void *)(long)callno);
        } else
            auth_reject((void *)(long)callno);
    }
    return 0;
}

References auth_reject(), chan_iax2_pvt::authfail, chan_iax2_pvt::authid, delayreject, iax2_sched_replace(), and iaxs.

Referenced by socket_process_helper().

auth_method_names()

static char * auth_method_names ( int  authmethods, char *restrict  buf  )

static

Get names of all auth methods.

Parameters

	Bit	field of auth methods
[out]	buf	Buffer into which to write the names. Must be of size AUTH_METHOD_NAMES_BUFSIZE.

Returns

Auth methods name

Definition at line 439 of file chan_iax2.c.

{
    char *pos = buf;
 
    *pos = '\0';
 
    if (authmethods & IAX_AUTH_RSA) {
        pos += sprintf(pos, "|RSA");
    }
    if (authmethods & IAX_AUTH_MD5) {
        pos += sprintf(pos, "|MD5");
    }
    if (authmethods & IAX_AUTH_PLAINTEXT) {
        pos += sprintf(pos, "|plaintext");
    }
 
    if (pos == buf) { /* No auth methods */
        strcpy(buf, "none");
        return buf;
    }
 
    return buf + 1; /* Skip leading | */
}

References buf, IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, and IAX_AUTH_RSA.

Referenced by socket_process_helper().

auth_reject()

static int auth_reject ( const void *  data )

static

Definition at line 9484 of file chan_iax2.c.

{
    int callno = (int)(long)(data);
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno])
        iaxs[callno]->authid = -1;
    ast_mutex_unlock(&iaxsl[callno]);
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__auth_reject, data))
#endif
        __auth_reject(data);
    return 0;
}

References __auth_reject(), ast_mutex_lock, ast_mutex_unlock, chan_iax2_pvt::authid, iaxs, iaxsl, and schedule_action.

Referenced by auth_fail().

authenticate()

static int authenticate ( const char *  challenge, const char *  secret, const char *  keyn, int  authmethods, struct iax_ie_data *  ied, struct ast_sockaddr *  addr, struct chan_iax2_pvt *  pvt  )

static

Definition at line 8505 of file chan_iax2.c.

{
    int res = -1;
    int x;
    if (!ast_strlen_zero(keyn)) {
        if (!(authmethods & IAX_AUTH_RSA)) {
            if (ast_strlen_zero(secret)) {
                ast_log(LOG_WARNING, "Asked to authenticate to %s with an RSA key, but they don't allow RSA authentication\n", ast_sockaddr_stringify_addr(addr));
            }
        } else if (ast_strlen_zero(challenge)) {
            ast_log(LOG_WARNING, "No challenge provided for RSA authentication to %s\n", ast_sockaddr_stringify_addr(addr));
        } else {
            char sig[256];
            struct ast_key *key;
            key = ast_key_get(keyn, AST_KEY_PRIVATE);
            if (!key) {
                ast_log(LOG_WARNING, "Unable to find private key '%s'\n", keyn);
            } else {
                if (ast_sign(key, (char*)challenge, sig)) {
                    ast_log(LOG_WARNING, "Unable to sign challenge with key\n");
                    res = -1;
                } else {
                    iax_ie_append_str(ied, IAX_IE_RSA_RESULT, sig);
                    if (pvt) {
                        pvt->eff_auth_method = IAX_AUTH_RSA;
                    }
                    res = 0;
                }
            }
 
            if (pvt && !ast_strlen_zero(secret)) {
                struct MD5Context md5;
                unsigned char digest[16];
 
                MD5Init(&md5);
                MD5Update(&md5, (unsigned char *) challenge, strlen(challenge));
                MD5Update(&md5, (unsigned char *) secret, strlen(secret));
                MD5Final(digest, &md5);
 
                build_encryption_keys(digest, pvt);
            }
        }
    }
    /* Fall back */
    if (res && !ast_strlen_zero(secret)) {
        if ((authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(challenge)) {
            struct MD5Context md5;
            unsigned char digest[16];
            char digres[128];
            MD5Init(&md5);
            MD5Update(&md5, (unsigned char *)challenge, strlen(challenge));
            MD5Update(&md5, (unsigned char *)secret, strlen(secret));
            MD5Final(digest, &md5);
            /* If they support md5, authenticate with it.  */
            for (x=0;x<16;x++)
                sprintf(digres + (x << 1),  "%02hhx", digest[x]); /* safe */
            if (pvt) {
                build_encryption_keys(digest, pvt);
                pvt->eff_auth_method = IAX_AUTH_MD5;
            }
            iax_ie_append_str(ied, IAX_IE_MD5_RESULT, digres);
            res = 0;
        } else if (authmethods & IAX_AUTH_PLAINTEXT) {
            iax_ie_append_str(ied, IAX_IE_PASSWORD, secret);
            if (pvt) {
                pvt->eff_auth_method = IAX_AUTH_PLAINTEXT;
            }
            res = 0;
        } else
            ast_log(LOG_WARNING, "No way to send secret to peer '%s' (their methods: %d)\n", ast_sockaddr_stringify_addr(addr), authmethods);
    }
    return res;
}

References ast_key_get(), AST_KEY_PRIVATE, ast_log, ast_sign(), ast_sockaddr_stringify_addr(), ast_strlen_zero(), build_encryption_keys(), challenge(), chan_iax2_pvt::eff_auth_method, IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, iax_ie_append_str(), IAX_IE_MD5_RESULT, IAX_IE_PASSWORD, IAX_IE_RSA_RESULT, LOG_WARNING, md5(), MD5Final(), MD5Init(), and MD5Update().

Referenced by authenticate_reply(), and registry_rerequest().

authenticate_reply()

static int authenticate_reply ( struct chan_iax2_pvt *  p, struct ast_sockaddr *  addr, struct iax_ies *  ies, const char *  override, const char *  okey  )

static

Note

This function calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno, so do not call this function with a pvt lock held.

Definition at line 8583 of file chan_iax2.c.

{
    struct iax2_peer *peer = NULL;
    /* Start pessimistic */
    int res = -1;
    int authmethods = 0;
    struct iax_ie_data ied;
    uint16_t callno = p->callno;
 
    memset(&ied, 0, sizeof(ied));
 
    if (ies->username)
        ast_string_field_set(p, username, ies->username);
    if (ies->challenge)
        ast_string_field_set(p, challenge, ies->challenge);
    if (ies->authmethods)
        authmethods = ies->authmethods;
    if (authmethods & IAX_AUTH_MD5)
        merge_encryption(p, ies->encmethods);
    else
        p->encmethods = 0;
 
    /* Check for override RSA authentication first */
    if (!ast_strlen_zero(override) || !ast_strlen_zero(okey)) {
        /* Normal password authentication */
        res = authenticate(p->challenge, override, okey, authmethods, &ied, addr, p);
    } else {
        struct ao2_iterator i = ao2_iterator_init(peers, 0);
        while ((peer = ao2_iterator_next(&i))) {
            struct ast_sockaddr peer_addr;
            struct ast_sockaddr tmp_sockaddr1;
            struct ast_sockaddr tmp_sockaddr2;
 
            ast_sockaddr_copy(&peer_addr, &peer->addr);
 
            ast_sockaddr_apply_netmask(addr, &peer->mask, &tmp_sockaddr1);
            ast_sockaddr_apply_netmask(&peer_addr, &peer->mask, &tmp_sockaddr2);
 
            if ((ast_strlen_zero(p->peer) || !strcmp(p->peer, peer->name))
                /* No peer specified at our end, or this is the peer */
                && (ast_strlen_zero(peer->username) || (!strcmp(peer->username, p->username)))
                /* No username specified in peer rule, or this is the right username */
                && (ast_sockaddr_isnull(&peer_addr) || !(ast_sockaddr_cmp_addr(&tmp_sockaddr1, &tmp_sockaddr2)))
                /* No specified host, or this is our host */
                ) {
                res = authenticate(p->challenge, peer->secret, peer->outkey, authmethods, &ied, addr, p);
                if (!res) {
                    peer_unref(peer);
                    break;
                }
            }
            peer_unref(peer);
        }
        ao2_iterator_destroy(&i);
        if (!peer) {
            /* We checked our list and didn't find one.  It's unlikely, but possible,
               that we're trying to authenticate *to* a realtime peer */
            const char *peer_name = ast_strdupa(p->peer);
            ast_mutex_unlock(&iaxsl[callno]);
            if ((peer = realtime_peer(peer_name, NULL))) {
                ast_mutex_lock(&iaxsl[callno]);
                if (!(p = iaxs[callno])) {
                    peer_unref(peer);
                    return -1;
                }
                res = authenticate(p->challenge, peer->secret,peer->outkey, authmethods, &ied, addr, p);
                peer_unref(peer);
            }
            if (!peer) {
                ast_mutex_lock(&iaxsl[callno]);
                if (!(p = iaxs[callno]))
                    return -1;
            }
        }
    }
 
    if (!(ies->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT)) && (ies->authmethods & IAX_AUTH_RSA) && ast_strlen_zero(okey)) {
        /* If the only thing available is RSA, and we don't have an outkey, we can't do it... */
        ast_log(LOG_WARNING, "Call terminated. RSA authentication requires an outkey\n");
        return -1;
    }
 
    if (ies->encmethods) {
        if (ast_strlen_zero(p->secret) &&
            ((ies->authmethods & IAX_AUTH_RSA) || (ies->authmethods & IAX_AUTH_MD5) || (ies->authmethods & IAX_AUTH_PLAINTEXT))) {
            ast_log(LOG_WARNING, "Call terminated. Encryption requested by peer but no secret available locally\n");
            return -1;
        }
        /* Don't even THINK about trying to encrypt or decrypt anything if we don't have valid keys, for some reason... */
        /* If either of these happens, it's our fault, not the user's. But we should abort rather than crash. */
        ast_assert_return(!invalid_key(&p->ecx), -1);
        ast_assert_return(!invalid_key(&p->dcx), -1);
        ast_set_flag64(p, IAX_ENCRYPTED | IAX_KEYPOPULATED);
    } else if (ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
        ast_log(LOG_NOTICE, "Call initiated without encryption while forceencryption=yes option is set\n");
        return -1;             /* if force encryption is yes, and no encryption methods, then return -1 to hangup */
    }
    if (!res) {
        struct ast_datastore *variablestore;
        struct ast_variable *var, *prev = NULL;
        AST_LIST_HEAD(, ast_var_t) *varlist;
        varlist = ast_calloc(1, sizeof(*varlist));
        variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
        if (variablestore && varlist && p->owner) {
            variablestore->data = varlist;
            variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
            AST_LIST_HEAD_INIT(varlist);
            for (var = ies->vars; var; var = var->next) {
                struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
                if (prev)
                    ast_free(prev);
                prev = var;
                if (!newvar) {
                    /* Don't abort list traversal, as this would leave ies->vars in an inconsistent state. */
                    ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                } else {
                    AST_LIST_INSERT_TAIL(varlist, newvar, entries);
                }
            }
            if (prev)
                ast_free(prev);
            ies->vars = NULL;
            ast_channel_datastore_add(p->owner, variablestore);
        } else {
            if (p->owner)
                ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
            if (variablestore)
                ast_datastore_free(variablestore);
            if (varlist)
                ast_free(varlist);
        }
    }
 
    if (!res)
        res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1);
    return res;
}

References iax2_peer::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_assert_return, ast_calloc, ast_channel_datastore_add(), ast_datastore_alloc, ast_datastore_free(), AST_FRAME_IAX, ast_free, AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_set_flag64, ast_sockaddr_apply_netmask(), ast_sockaddr_cmp_addr(), ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_var_assign, authenticate(), iax2_peer::authmethods, iax_ies::authmethods, iax_ie_data::buf, chan_iax2_pvt::callno, chan_iax2_pvt::challenge, iax_ies::challenge, challenge(), ast_datastore::data, DATASTORE_INHERIT_FOREVER, chan_iax2_pvt::dcx, chan_iax2_pvt::ecx, chan_iax2_pvt::encmethods, iax_ies::encmethods, ast_var_t::entries, iax2_variable_datastore_info, IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, IAX_COMMAND_AUTHREP, IAX_ENCRYPTED, IAX_FORCE_ENCRYPT, IAX_KEYPOPULATED, iaxs, iaxsl, ast_datastore::inheritance, invalid_key(), LOG_ERROR, LOG_NOTICE, LOG_WARNING, iax2_peer::mask, merge_encryption(), iax2_peer::name, NULL, iax2_peer::outkey, chan_iax2_pvt::owner, chan_iax2_pvt::peer, peer_unref(), iax_ie_data::pos, realtime_peer(), iax2_peer::secret, chan_iax2_pvt::secret, send_command(), iax2_peer::username, chan_iax2_pvt::username, iax_ies::username, var, and iax_ies::vars.

Referenced by socket_process_helper().

authenticate_request()

static int authenticate_request ( int  call_num )

static

Precondition

iaxsl[call_num] is locked

Note

Since this function calls send_command_final(), the pvt struct for the given call number may disappear while executing this function.

Definition at line 8197 of file chan_iax2.c.

{
    struct iax_ie_data ied;
    int res = -1, authreq_restrict = 0;
    char challenge[10];
    struct chan_iax2_pvt *p = iaxs[call_num];
 
    memset(&ied, 0, sizeof(ied));
 
    /* If an AUTHREQ restriction is in place, make sure we can send an AUTHREQ back */
    if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
        struct iax2_user *user;
 
        user = ao2_find(users, p->username, OBJ_KEY);
        if (user) {
            if (user->curauthreq == user->maxauthreq)
                authreq_restrict = 1;
            else
                user->curauthreq++;
            user = user_unref(user);
        }
    }
 
    /* If the AUTHREQ limit test failed, send back an error */
    if (authreq_restrict) {
        iax_ie_append_str(&ied, IAX_IE_CAUSE, "Unauthenticated call limit reached");
        iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_CALL_REJECTED);
        send_command_final(p, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
        return 0;
    }
 
    iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, p->authmethods);
    if (p->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA)) {
        snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
        ast_string_field_set(p, challenge, challenge);
        /* snprintf(p->challenge, sizeof(p->challenge), "%d", (int)ast_random()); */
        iax_ie_append_str(&ied, IAX_IE_CHALLENGE, p->challenge);
    }
    if (p->encmethods)
        iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, p->encmethods);
 
    iax_ie_append_str(&ied,IAX_IE_USERNAME, p->username);
 
    res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREQ, 0, ied.buf, ied.pos, -1);
 
    if (p->encmethods)
        ast_set_flag64(p, IAX_ENCRYPTED);
 
    return res;
}

References ao2_find, AST_CAUSE_CALL_REJECTED, AST_FRAME_IAX, ast_random(), ast_set_flag64, ast_string_field_set, ast_test_flag64, chan_iax2_pvt::authmethods, iax_ie_data::buf, chan_iax2_pvt::challenge, challenge(), chan_iax2_pvt::encmethods, IAX_AUTH_MD5, IAX_AUTH_RSA, IAX_COMMAND_AUTHREQ, IAX_COMMAND_REJECT, IAX_ENCRYPTED, iax_ie_append_byte(), iax_ie_append_short(), iax_ie_append_str(), IAX_IE_AUTHMETHODS, IAX_IE_CAUSE, IAX_IE_CAUSECODE, IAX_IE_CHALLENGE, IAX_IE_ENCRYPTION, IAX_IE_USERNAME, IAX_MAXAUTHREQ, iaxs, OBJ_KEY, iax_ie_data::pos, send_command(), send_command_final(), user, user_unref(), and chan_iax2_pvt::username.

Referenced by socket_process_helper().

authenticate_verify()

static int authenticate_verify ( struct chan_iax2_pvt *  p, struct iax_ies *  ies  )

static

Definition at line 8248 of file chan_iax2.c.

{
    char requeststr[256];
    char md5secret[256] = "";
    char secret[256] = "";
    char rsasecret[256] = "";
    int res = -1;
    int x;
    struct iax2_user *user;
 
    if (p->authrej) {
        return res;
    }
 
    user = ao2_find(users, p->username, OBJ_KEY);
    if (user) {
        if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
            ast_atomic_fetchadd_int(&user->curauthreq, -1);
            ast_clear_flag64(p, IAX_MAXAUTHREQ);
        }
        ast_string_field_set(p, host, user->name);
        user = user_unref(user);
    }
    if (ast_test_flag64(p, IAX_FORCE_ENCRYPT) && !p->encmethods) {
        ast_log(LOG_WARNING, "Call Terminated, incoming call is unencrypted while force encrypt is enabled.\n");
        return res;
    }
    if (!ast_test_flag(&p->state, IAX_STATE_AUTHENTICATED))
        return res;
    if (ies->password)
        ast_copy_string(secret, ies->password, sizeof(secret));
    if (ies->md5_result)
        ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
    if (ies->rsa_result)
        ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
    if ((p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(rsasecret) && !ast_strlen_zero(p->inkeys)) {
        struct ast_key *key;
        char *keyn;
        char *tmpkey;
        char *stringp=NULL;
        if (!(tmpkey = ast_strdup(p->inkeys))) {
            ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
            return res;
        }
        stringp = tmpkey;
        keyn = strsep(&stringp, ":");
        while(keyn) {
            key = ast_key_get(keyn, AST_KEY_PUBLIC);
            if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
                res = 0;
                p->eff_auth_method = IAX_AUTH_RSA;
                break;
            } else if (!key) {
                ast_log(LOG_WARNING, "Requested inkey '%s' for RSA authentication does not exist\n", keyn);
            }
            keyn = strsep(&stringp, ":");
        }
        ast_free(tmpkey);
        if (res && authdebug) {
            ast_log(LOG_WARNING, "No RSA public keys on file matched incoming call\n");
        }
    } else if (p->authmethods & IAX_AUTH_MD5) {
        struct MD5Context md5;
        unsigned char digest[16];
        char *tmppw, *stringp;
        tmppw = ast_strdupa(p->secret);
        stringp = tmppw;
        while((tmppw = strsep(&stringp, ";"))) {
            MD5Init(&md5);
            MD5Update(&md5, (unsigned char *)p->challenge, strlen(p->challenge));
            MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
            MD5Final(digest, &md5);
            /* If they support md5, authenticate with it.  */
            for (x=0;x<16;x++)
                sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
            if (!strcasecmp(requeststr, md5secret)) {
                res = 0;
                p->eff_auth_method = IAX_AUTH_MD5;
                break;
            } else if (authdebug) {
                ast_log(LOG_WARNING, "MD5 secret mismatch\n");
            }
        }
    } else if (p->authmethods & IAX_AUTH_PLAINTEXT) {
        if (!strcmp(secret, p->secret)) {
            res = 0;
            p->eff_auth_method = IAX_AUTH_PLAINTEXT;
        } else if (authdebug) {
            ast_log(LOG_WARNING, "Plaintext secret mismatch\n");
        }
    }
    return res;
}

References ao2_find, ast_atomic_fetchadd_int(), ast_check_signature(), ast_clear_flag64, ast_copy_string(), ast_free, ast_key_get(), AST_KEY_PUBLIC, ast_log, ast_strdup, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_test_flag64, authdebug, chan_iax2_pvt::authmethods, chan_iax2_pvt::authrej, chan_iax2_pvt::challenge, chan_iax2_pvt::eff_auth_method, chan_iax2_pvt::encmethods, IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, IAX_FORCE_ENCRYPT, IAX_MAXAUTHREQ, IAX_STATE_AUTHENTICATED, chan_iax2_pvt::inkeys, LOG_ERROR, LOG_WARNING, md5(), iax_ies::md5_result, MD5Final(), MD5Init(), MD5Update(), NULL, OBJ_KEY, iax_ies::password, iax_ies::rsa_result, iax2_user::secret, chan_iax2_pvt::secret, chan_iax2_pvt::state, strsep(), user, user_unref(), and chan_iax2_pvt::username.

Referenced by socket_process_helper().

auto_congest()

static int auto_congest ( const void *  data )

static

Definition at line 4835 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__auto_congest, data))
#endif
        __auto_congest(data);
    return 0;
}

References __auto_congest(), ast_frame::data, and schedule_action.

Referenced by iax2_call().

auto_hangup()

static int auto_hangup ( const void *  data )

static

Definition at line 9528 of file chan_iax2.c.

{
    int callno = (int)(long)(data);
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        iaxs[callno]->autoid = -1;
    }
    ast_mutex_unlock(&iaxsl[callno]);
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__auto_hangup, data))
#endif
        __auto_hangup(data);
    return 0;
}

References __auto_hangup(), ast_mutex_lock, ast_mutex_unlock, chan_iax2_pvt::autoid, iaxs, iaxsl, and schedule_action.

Referenced by iax2_dprequest(), and iax2_provision().

build_callno_limits()

static void build_callno_limits ( struct ast_variable *  v )

static

Definition at line 2813 of file chan_iax2.c.

{
    struct addr_range *addr_range = NULL;
    struct addr_range tmp;
    struct ast_ha *ha;
    int limit;
    int error;
    int found;
 
    for (; v; v = v->next) {
        limit = -1;
        error = 0;
        found = 0;
        ha = ast_append_ha("permit", v->name, NULL, &error);
 
        /* check for valid config information */
        if (error) {
            ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
            continue;
        } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
            ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
            ast_free_ha(ha);
            continue;
        }
 
        ast_copy_ha(ha, &tmp.ha);
        /* find or create the addr_range */
        if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
            ao2_lock(addr_range);
            found = 1;
        } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
            ast_free_ha(ha);
            return; /* out of memory */
        }
 
        /* copy over config data into addr_range object */
        ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
        ast_free_ha(ha); /* cleanup the tmp ha */
        addr_range->limit = limit;
        addr_range->delme = 0;
 
        /* cleanup */
        if (found) {
            ao2_unlock(addr_range);
        } else {
            ao2_link(callno_limits, addr_range);
        }
        ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
    }
}

References ao2_alloc, ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_append_ha(), ast_copy_ha(), ast_free_ha(), ast_log, callno_limits, addr_range::delme, error(), addr_range::ha, addr_range::limit, LOG_ERROR, ast_variable::name, ast_variable::next, NULL, OBJ_POINTER, and ast_variable::value.

Referenced by set_config().

build_context()

static struct iax2_context * build_context ( const char *  context )

static

Definition at line 12865 of file chan_iax2.c.

{
    struct iax2_context *con;
 
    if ((con = ast_calloc(1, sizeof(*con))))
        ast_copy_string(con->context, context, sizeof(con->context));
 
    return con;
}

References ast_calloc, ast_copy_string(), iax2_context::context, and voicemailpwcheck::context.

Referenced by build_user().

build_ecx_key()

static void build_ecx_key ( const unsigned char *  digest, struct chan_iax2_pvt *  pvt  )

static

Definition at line 6505 of file chan_iax2.c.

{
    /* it is required to hold the corresponding decrypt key to our encrypt key
     * in the pvt struct because queued frames occasionally need to be decrypted and
     * re-encrypted when updated for a retransmission */
    build_rand_pad(pvt->semirand, sizeof(pvt->semirand));
    ast_aes_set_encrypt_key(digest, &pvt->ecx);
    ast_aes_set_decrypt_key(digest, &pvt->mydcx);
}

References ast_aes_set_decrypt_key(), ast_aes_set_encrypt_key(), build_rand_pad(), chan_iax2_pvt::ecx, chan_iax2_pvt::mydcx, and chan_iax2_pvt::semirand.

Referenced by build_encryption_keys(), and iax2_key_rotate().

build_encryption_keys()

static void build_encryption_keys ( const unsigned char *  digest, struct chan_iax2_pvt *  pvt  )

static

Definition at line 6499 of file chan_iax2.c.

{
    build_ecx_key(digest, pvt);
    ast_aes_set_decrypt_key(digest, &pvt->dcx);
}

References ast_aes_set_decrypt_key(), build_ecx_key(), and chan_iax2_pvt::dcx.

Referenced by authenticate(), and decrypt_frame().

build_peer()

static struct iax2_peer * build_peer ( const char *  name, struct ast_variable *  v, struct ast_variable *  alt, int  temponly  )

static

Create peer structure based on configuration.

Definition at line 13014 of file chan_iax2.c.

{
    struct iax2_peer *peer = NULL;
    struct ast_acl_list *oldacl = NULL;
    int maskfound = 0;
    int found = 0;
    int firstpass = 1;
    int subscribe_acl_change = 0;
 
    if (!temponly) {
        peer = ao2_find(peers, name, OBJ_KEY);
        if (peer && !ast_test_flag64(peer, IAX_DELME))
            firstpass = 0;
    }
 
    if (peer) {
        found++;
        if (firstpass) {
            oldacl = peer->acl;
            peer->acl = NULL;
        }
        unlink_peer(peer);
    } else if ((peer = ao2_alloc(sizeof(*peer), peer_destructor))) {
        peer->expire = -1;
        peer->pokeexpire = -1;
        peer->sockfd = defaultsockfd;
        if (ast_string_field_init(peer, 32))
            peer = peer_unref(peer);
        if (!(peer->endpoint = ast_endpoint_create("IAX2", name))) {
            peer = peer_unref(peer);
        }
    }
 
    if (peer) {
        if (firstpass) {
            ast_copy_flags64(peer, &globalflags, IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
            peer->encmethods = iax2_encryption;
            peer->authmethods = iax2_authmethods;
            peer->adsi = adsi;
            ast_string_field_set(peer, secret, "");
            if (!found) {
                ast_string_field_set(peer, name, name);
                ast_sockaddr_parse(&peer->addr, "0.0.0.0", 0);
                ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
                peer->expiry = min_reg_expire;
            }
            peer->prefs = prefs_global;
            peer->capability = iax2_capability;
            peer->smoothing = 0;
            peer->pokefreqok = DEFAULT_FREQ_OK;
            peer->pokefreqnotok = DEFAULT_FREQ_NOTOK;
            peer->maxcallno = 0;
            peercnt_modify((unsigned char) 0, 0, &peer->addr);
            peer->calltoken_required = CALLTOKEN_DEFAULT;
            ast_string_field_set(peer,context,"");
            ast_string_field_set(peer,peercontext,"");
            ast_clear_flag64(peer, IAX_HASCALLERID);
            ast_string_field_set(peer, cid_name, "");
            ast_string_field_set(peer, cid_num, "");
            ast_string_field_set(peer, mohinterpret, mohinterpret);
            ast_string_field_set(peer, mohsuggest, mohsuggest);
        }
 
        if (!v) {
            v = alt;
            alt = NULL;
        }
        while(v) {
            if (!strcasecmp(v->name, "secret")) {
                ast_string_field_set(peer, secret, v->value);
            } else if (!strcasecmp(v->name, "mailbox")) {
                ast_string_field_set(peer, mailbox, v->value);
            } else if (!strcasecmp(v->name, "hasvoicemail")) {
                if (ast_true(v->value) && ast_strlen_zero(peer->mailbox)) {
                    /*
                     * hasvoicemail is a users.conf legacy voicemail enable method.
                     * hasvoicemail is only going to work for app_voicemail mailboxes.
                     */
                    if (strchr(name, '@')) {
                        ast_string_field_set(peer, mailbox, name);
                    } else {
                        ast_string_field_build(peer, mailbox, "%s@default", name);
                    }
                }
            } else if (!strcasecmp(v->name, "mohinterpret")) {
                ast_string_field_set(peer, mohinterpret, v->value);
            } else if (!strcasecmp(v->name, "mohsuggest")) {
                ast_string_field_set(peer, mohsuggest, v->value);
            } else if (!strcasecmp(v->name, "dbsecret")) {
                ast_string_field_set(peer, dbsecret, v->value);
            } else if (!strcasecmp(v->name, "description")) {
                ast_string_field_set(peer, description, v->value);
            } else if (!strcasecmp(v->name, "trunk")) {
                ast_set2_flag64(peer, ast_true(v->value), IAX_TRUNK);
                if (ast_test_flag64(peer, IAX_TRUNK) && !timer) {
                    ast_log(LOG_WARNING, "Unable to support trunking on peer '%s' without a timing interface\n", peer->name);
                    ast_clear_flag64(peer, IAX_TRUNK);
                }
            } else if (!strcasecmp(v->name, "auth")) {
                peer->authmethods = get_auth_methods(v->value);
                if (peer->authmethods & IAX_AUTH_PLAINTEXT) {
                    ast_log(LOG_WARNING, "Auth method for peer '%s' is set to deprecated 'plaintext' at line %d of iax.conf\n", peer->name, v->lineno);
                }
            } else if (!strcasecmp(v->name, "encryption")) {
                peer->encmethods |= get_encrypt_methods(v->value);
                if (!peer->encmethods) {
                    ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
                }
            } else if (!strcasecmp(v->name, "forceencryption")) {
                if (ast_false(v->value)) {
                    ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
                } else {
                    peer->encmethods |= get_encrypt_methods(v->value);
                    if (peer->encmethods) {
                        ast_set_flag64(peer, IAX_FORCE_ENCRYPT);
                    }
                }
            } else if (!strcasecmp(v->name, "transfer")) {
                if (!strcasecmp(v->value, "mediaonly")) {
                    ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
                } else if (ast_true(v->value)) {
                    ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
                } else
                    ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
            } else if (!strcasecmp(v->name, "jitterbuffer")) {
                ast_set2_flag64(peer, ast_true(v->value), IAX_USEJITTERBUF);
            } else if (!strcasecmp(v->name, "host")) {
                if (!strcasecmp(v->value, "dynamic")) {
                    /* They'll register with us */
                    ast_set_flag64(peer, IAX_DYNAMIC);
                    if (!found) {
                        int peer_port = ast_sockaddr_port(&peer->addr);
                        if (peer_port) {
                            ast_sockaddr_set_port(&peer->defaddr, peer_port);
                        }
                        ast_sockaddr_setnull(&peer->addr);
                    }
                } else {
                    /* Non-dynamic.  Make sure we become that way if we're not */
                    AST_SCHED_DEL(sched, peer->expire);
                    ast_clear_flag64(peer, IAX_DYNAMIC);
                    if (peer->dnsmgr) {
                        // Make sure we refresh dnsmgr if we're using it
                        ast_dnsmgr_refresh(peer->dnsmgr);
                    } else {
                        // Or just invalidate the address
                        peer->addr.ss.ss_family = AST_AF_UNSPEC;
                    }
                    if (ast_dnsmgr_lookup(v->value, &peer->addr, &peer->dnsmgr, srvlookup ? "_iax._udp" : NULL)) {
                        return peer_unref(peer);
                    }
                    if (!ast_sockaddr_port(&peer->addr)) {
                        ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
                    }
                }
            } else if (!strcasecmp(v->name, "defaultip")) {
                struct ast_sockaddr peer_defaddr_tmp;
                peer_defaddr_tmp.ss.ss_family = AF_UNSPEC;
                if (ast_get_ip(&peer_defaddr_tmp, v->value)) {
                    return peer_unref(peer);
                }
                ast_sockaddr_set_port(&peer_defaddr_tmp, ast_sockaddr_port(&peer->defaddr));
                ast_sockaddr_copy(&peer->defaddr, &peer_defaddr_tmp);
            } else if (!strcasecmp(v->name, "sourceaddress")) {
                peer_set_srcaddr(peer, v->value);
            } else if (!strcasecmp(v->name, "permit") ||
                       !strcasecmp(v->name, "deny") ||
                       !strcasecmp(v->name, "acl")) {
                ast_append_acl(v->name, v->value, &peer->acl, NULL, &subscribe_acl_change);
            } else if (!strcasecmp(v->name, "mask")) {
                maskfound++;
                ast_sockaddr_parse(&peer->mask, v->value, 0);
            } else if (!strcasecmp(v->name, "context")) {
                ast_string_field_set(peer, context, v->value);
            } else if (!strcasecmp(v->name, "regexten")) {
                ast_string_field_set(peer, regexten, v->value);
            } else if (!strcasecmp(v->name, "peercontext")) {
                ast_string_field_set(peer, peercontext, v->value);
            } else if (!strcasecmp(v->name, "port")) {
                int bindport;
                if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
                    bindport = IAX_DEFAULT_PORTNO;
                }
                if (ast_test_flag64(peer, IAX_DYNAMIC)) {
                    ast_sockaddr_set_port(&peer->defaddr, bindport);
                } else {
                    ast_sockaddr_set_port(&peer->addr, bindport);
                }
            } else if (!strcasecmp(v->name, "username")) {
                ast_string_field_set(peer, username, v->value);
            } else if (!strcasecmp(v->name, "allow")) {
                iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
            } else if (!strcasecmp(v->name, "disallow")) {
                iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
            } else if (!strcasecmp(v->name, "callerid")) {
                if (!ast_strlen_zero(v->value)) {
                    char name2[80];
                    char num2[80];
                    ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
                    ast_string_field_set(peer, cid_name, name2);
                    ast_string_field_set(peer, cid_num, num2);
                } else {
                    ast_string_field_set(peer, cid_name, "");
                    ast_string_field_set(peer, cid_num, "");
                }
                ast_set_flag64(peer, IAX_HASCALLERID);
            } else if (!strcasecmp(v->name, "fullname")) {
                ast_string_field_set(peer, cid_name, S_OR(v->value, ""));
                ast_set_flag64(peer, IAX_HASCALLERID);
            } else if (!strcasecmp(v->name, "cid_number")) {
                ast_string_field_set(peer, cid_num, S_OR(v->value, ""));
                ast_set_flag64(peer, IAX_HASCALLERID);
            } else if (!strcasecmp(v->name, "sendani")) {
                ast_set2_flag64(peer, ast_true(v->value), IAX_SENDANI);
            } else if (!strcasecmp(v->name, "inkeys")) {
                ast_string_field_set(peer, inkeys, v->value);
            } else if (!strcasecmp(v->name, "outkey")) {
                ast_string_field_set(peer, outkey, v->value);
            } else if (!strcasecmp(v->name, "qualify")) {
                if (!strcasecmp(v->value, "no")) {
                    peer->maxms = 0;
                } else if (!strcasecmp(v->value, "yes")) {
                    peer->maxms = DEFAULT_MAXMS;
                } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
                    ast_log(LOG_WARNING, "Qualification of peer '%s' should be 'yes', 'no', or a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
                    peer->maxms = 0;
                }
            } else if (!strcasecmp(v->name, "qualifysmoothing")) {
                peer->smoothing = ast_true(v->value);
            } else if (!strcasecmp(v->name, "qualifyfreqok")) {
                if (sscanf(v->value, "%30d", &peer->pokefreqok) != 1) {
                    ast_log(LOG_WARNING, "Qualification testing frequency of peer '%s' when OK should a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
                }
            } else if (!strcasecmp(v->name, "qualifyfreqnotok")) {
                if (sscanf(v->value, "%30d", &peer->pokefreqnotok) != 1) {
                    ast_log(LOG_WARNING, "Qualification testing frequency of peer '%s' when NOT OK should be a number of milliseconds at line %d of iax.conf\n", peer->name, v->lineno);
                }
            } else if (!strcasecmp(v->name, "timezone")) {
                ast_string_field_set(peer, zonetag, v->value);
            } else if (!strcasecmp(v->name, "adsi")) {
                peer->adsi = ast_true(v->value);
            } else if (!strcasecmp(v->name, "connectedline")) {
                if (ast_true(v->value)) {
                    ast_set_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
                } else if (!strcasecmp(v->value, "send")) {
                    ast_clear_flag64(peer, IAX_RECVCONNECTEDLINE);
                    ast_set_flag64(peer, IAX_SENDCONNECTEDLINE);
                } else if (!strcasecmp(v->value, "receive")) {
                    ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE);
                    ast_set_flag64(peer, IAX_RECVCONNECTEDLINE);
                } else {
                    ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
                }
            } else if (!strcasecmp(v->name, "maxcallnumbers")) {
                if (sscanf(v->value, "%10hu", &peer->maxcallno) != 1) {
                    ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d.\n", v->value, v->lineno);
                } else {
                    peercnt_modify((unsigned char) 1, peer->maxcallno, &peer->addr);
                }
            } else if (!strcasecmp(v->name, "requirecalltoken")) {
                /* default is required unless in optional ip list */
                if (ast_false(v->value)) {
                    peer->calltoken_required = CALLTOKEN_NO;
                } else if (!strcasecmp(v->value, "auto")) {
                    peer->calltoken_required = CALLTOKEN_AUTO;
                } else if (ast_true(v->value)) {
                    peer->calltoken_required = CALLTOKEN_YES;
                } else {
                    ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
                }
            } /* else if (strcasecmp(v->name,"type")) */
            /*  ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
            v = v->next;
            if (!v) {
                v = alt;
                alt = NULL;
            }
        }
        if (!peer->authmethods)
            peer->authmethods = IAX_AUTH_MD5;
        ast_clear_flag64(peer, IAX_DELME);
    }
 
    if (!maskfound && !ast_sockaddr_isnull(&peer->addr)) {
        if (ast_sockaddr_is_ipv4_mapped(&peer->addr)) {
            ast_sockaddr_parse(&peer->mask, "::ffff:ffff:ffff", 0);
        } else if (ast_sockaddr_is_ipv6(&peer->addr)) {
            ast_sockaddr_parse(&peer->mask, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
        } else {
            ast_sockaddr_parse(&peer->mask, "255.255.255.255", 0);
        }
    }
 
    if (oldacl) {
        ast_free_acl_list(oldacl);
    }
 
    if (!ast_strlen_zero(peer->mailbox) && !peer->mwi_event_sub) {
        /* The MWI subscriptions exist just so the core knows we care about those
         * mailboxes.  However, we just grab the events out of the cache when it
         * is time to send MWI, since it is only sent with a REGACK. */
        peer->mwi_event_sub = ast_mwi_subscribe_pool(peer->mailbox, stasis_subscription_cb_noop, NULL);
    }
 
    if (subscribe_acl_change) {
        acl_change_stasis_subscribe();
    }
 
    return peer;
}

References iax2_peer::acl, acl_change_stasis_subscribe(), iax2_peer::addr, adsi, iax2_peer::adsi, ao2_alloc, ao2_find, AST_AF_UNSPEC, ast_append_acl(), ast_callerid_split(), ast_clear_flag64, ast_copy_flags64, ast_dnsmgr_lookup(), ast_dnsmgr_refresh(), ast_endpoint_create(), ast_false(), ast_free_acl_list(), ast_get_ip(), ast_log, ast_mwi_subscribe_pool(), ast_parse_arg(), AST_SCHED_DEL, ast_set2_flag64, ast_set_flag64, ast_set_flags_to64, ast_sockaddr_copy(), ast_sockaddr_is_ipv4_mapped(), ast_sockaddr_is_ipv6(), ast_sockaddr_isnull(), ast_sockaddr_parse(), ast_sockaddr_port, ast_sockaddr_set_port, ast_sockaddr_setnull(), ast_string_field_build, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_true(), iax2_peer::authmethods, CALLTOKEN_AUTO, CALLTOKEN_DEFAULT, CALLTOKEN_NO, iax2_peer::calltoken_required, CALLTOKEN_YES, iax2_peer::capability, voicemailpwcheck::context, iax2_peer::defaddr, DEFAULT_FREQ_NOTOK, DEFAULT_FREQ_OK, DEFAULT_MAXMS, defaultsockfd, iax2_peer::dnsmgr, iax2_peer::encmethods, iax2_peer::endpoint, iax2_peer::expire, iax2_peer::expiry, get_auth_methods(), get_encrypt_methods(), globalflags, iax2_authmethods, iax2_capability, iax2_encryption, iax2_parse_allow_disallow(), IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_DEFAULT_PORTNO, IAX_DELME, IAX_DYNAMIC, IAX_FORCE_ENCRYPT, IAX_HASCALLERID, IAX_NOTRANSFER, IAX_RECVCONNECTEDLINE, IAX_SENDANI, IAX_SENDCONNECTEDLINE, IAX_TRANSFERMEDIA, IAX_TRUNK, IAX_USEJITTERBUF, ast_variable::lineno, LOG_WARNING, iax2_peer::mailbox, voicemailpwcheck::mailbox, iax2_peer::mask, iax2_peer::maxcallno, iax2_peer::maxms, min_reg_expire, mohinterpret, mohsuggest, iax2_peer::mwi_event_sub, name, iax2_peer::name, ast_variable::name, ast_variable::next, NULL, OBJ_KEY, PARSE_IN_RANGE, PARSE_UINT32, peer_destructor(), peer_set_srcaddr(), peer_unref(), peercnt_modify(), iax2_peer::pokeexpire, iax2_peer::pokefreqnotok, iax2_peer::pokefreqok, iax2_peer::prefs, prefs_global, S_OR, iax2_peer::smoothing, iax2_peer::sockfd, srvlookup, ast_sockaddr::ss, stasis_subscription_cb_noop(), timer, unlink_peer(), ast_variable::value, and zonetag.

Referenced by realtime_peer(), and set_config().

build_rand_pad()

static void build_rand_pad ( unsigned char *  buf, ssize_t  len  )

static

Definition at line 6473 of file chan_iax2.c.

{
    long tmp;
    for (tmp = ast_random(); len > 0; tmp = ast_random()) {
        memcpy(buf, (unsigned char *) &tmp, (len > sizeof(tmp)) ? sizeof(tmp) : len);
        buf += sizeof(tmp);
        len -= sizeof(tmp);
    }
}

References ast_random(), buf, and len().

Referenced by build_ecx_key(), and update_packet().

build_user()

static struct iax2_user * build_user ( const char *  name, struct ast_variable *  v, struct ast_variable *  alt, int  temponly  )

static

Create in-memory user structure from configuration.

Definition at line 13339 of file chan_iax2.c.

{
    struct iax2_user *user = NULL;
    struct iax2_context *con, *conl = NULL;
    struct ast_acl_list *oldacl = NULL;
    struct iax2_context *oldcon = NULL;
    int format;
    int firstpass=1;
    int oldcurauthreq = 0;
    int subscribe_acl_change = 0;
    char *varname = NULL, *varval = NULL;
    struct ast_variable *tmpvar = NULL;
 
    if (!temponly) {
        user = ao2_find(users, name, OBJ_KEY);
        if (user && !ast_test_flag64(user, IAX_DELME))
            firstpass = 0;
    }
 
    if (user) {
        if (firstpass) {
            oldcurauthreq = user->curauthreq;
            oldacl = user->acl;
            oldcon = user->contexts;
            user->acl = NULL;
            user->contexts = NULL;
        }
        /* Already in the list, remove it and it will be added back (or FREE'd) */
        ao2_unlink(users, user);
    } else {
        user = ao2_alloc(sizeof(*user), user_destructor);
    }
 
    if (user) {
        if (firstpass) {
            ast_string_field_free_memory(user);
            memset(user, 0, sizeof(struct iax2_user));
            if (ast_string_field_init(user, 32)) {
                user = user_unref(user);
                goto cleanup;
            }
            user->maxauthreq = maxauthreq;
            user->curauthreq = oldcurauthreq;
            user->prefs = prefs_global;
            user->capability = iax2_capability;
            user->encmethods = iax2_encryption;
            user->authmethods = iax2_authmethods;
            user->adsi = adsi;
            user->calltoken_required = CALLTOKEN_DEFAULT;
            ast_string_field_set(user, name, name);
            ast_string_field_set(user, language, language);
            ast_copy_flags64(user, &globalflags, IAX_USEJITTERBUF | IAX_CODEC_USER_FIRST | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
            ast_clear_flag64(user, IAX_HASCALLERID);
            ast_string_field_set(user, cid_name, "");
            ast_string_field_set(user, cid_num, "");
            ast_string_field_set(user, accountcode, accountcode);
            ast_string_field_set(user, mohinterpret, mohinterpret);
            ast_string_field_set(user, mohsuggest, mohsuggest);
        }
        if (!v) {
            v = alt;
            alt = NULL;
        }
        while(v) {
            if (!strcasecmp(v->name, "context")) {
                con = build_context(v->value);
                if (con) {
                    if (conl)
                        conl->next = con;
                    else
                        user->contexts = con;
                    conl = con;
                }
            } else if (!strcasecmp(v->name, "permit") ||
                       !strcasecmp(v->name, "deny") ||
                       !strcasecmp(v->name, "acl")) {
                ast_append_acl(v->name, v->value, &user->acl, NULL, &subscribe_acl_change);
            } else if (!strcasecmp(v->name, "setvar")) {
                varname = ast_strdupa(v->value);
                if ((varval = strchr(varname, '='))) {
                    *varval = '\0';
                    varval++;
                    if ((tmpvar = ast_variable_new(varname, varval, ""))) {
                        if (ast_variable_list_replace(&user->vars, tmpvar)) {
                            tmpvar->next = user->vars;
                            user->vars = tmpvar;
                        }
                    }
                }
            } else if (!strcasecmp(v->name, "allow")) {
                iax2_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
            } else if (!strcasecmp(v->name, "disallow")) {
                iax2_parse_allow_disallow(&user->prefs, &user->capability,v->value, 0);
            } else if (!strcasecmp(v->name, "trunk")) {
                ast_set2_flag64(user, ast_true(v->value), IAX_TRUNK);
                if (ast_test_flag64(user, IAX_TRUNK) && !timer) {
                    ast_log(LOG_WARNING, "Unable to support trunking on user '%s' without a timing interface\n", user->name);
                    ast_clear_flag64(user, IAX_TRUNK);
                }
            } else if (!strcasecmp(v->name, "auth")) {
                user->authmethods = get_auth_methods(v->value);
                if (user->authmethods & IAX_AUTH_PLAINTEXT) {
                    ast_log(LOG_WARNING, "Auth method for user '%s' is set to deprecated 'plaintext' at line %d of iax.conf\n", user->name, v->lineno);
                }
            } else if (!strcasecmp(v->name, "encryption")) {
                user->encmethods |= get_encrypt_methods(v->value);
                if (!user->encmethods) {
                    ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
                }
            } else if (!strcasecmp(v->name, "forceencryption")) {
                if (ast_false(v->value)) {
                    ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
                } else {
                    user->encmethods |= get_encrypt_methods(v->value);
                    if (user->encmethods) {
                        ast_set_flag64(user, IAX_FORCE_ENCRYPT);
                    }
                }
            } else if (!strcasecmp(v->name, "transfer")) {
                if (!strcasecmp(v->value, "mediaonly")) {
                    ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
                } else if (ast_true(v->value)) {
                    ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
                } else
                    ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
            } else if (!strcasecmp(v->name, "codecpriority")) {
                if(!strcasecmp(v->value, "caller"))
                    ast_set_flag64(user, IAX_CODEC_USER_FIRST);
                else if(!strcasecmp(v->value, "disabled"))
                    ast_set_flag64(user, IAX_CODEC_NOPREFS);
                else if(!strcasecmp(v->value, "reqonly")) {
                    ast_set_flag64(user, IAX_CODEC_NOCAP);
                    ast_set_flag64(user, IAX_CODEC_NOPREFS);
                }
            } else if (!strcasecmp(v->name, "immediate")) {
                ast_set2_flag64(user, ast_true(v->value), IAX_IMMEDIATE);
            } else if (!strcasecmp(v->name, "jitterbuffer")) {
                ast_set2_flag64(user, ast_true(v->value), IAX_USEJITTERBUF);
            } else if (!strcasecmp(v->name, "dbsecret")) {
                ast_string_field_set(user, dbsecret, v->value);
            } else if (!strcasecmp(v->name, "secret")) {
                if (!ast_strlen_zero(user->secret)) {
                    char *old = ast_strdupa(user->secret);
 
                    ast_string_field_build(user, secret, "%s;%s", old, v->value);
                } else
                    ast_string_field_set(user, secret, v->value);
            } else if (!strcasecmp(v->name, "callerid")) {
                if (!ast_strlen_zero(v->value) && strcasecmp(v->value, "asreceived")) {
                    char name2[80];
                    char num2[80];
                    ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
                    ast_string_field_set(user, cid_name, name2);
                    ast_string_field_set(user, cid_num, num2);
                    ast_set_flag64(user, IAX_HASCALLERID);
                } else {
                    ast_clear_flag64(user, IAX_HASCALLERID);
                    ast_string_field_set(user, cid_name, "");
                    ast_string_field_set(user, cid_num, "");
                }
            } else if (!strcasecmp(v->name, "fullname")) {
                if (!ast_strlen_zero(v->value)) {
                    ast_string_field_set(user, cid_name, v->value);
                    ast_set_flag64(user, IAX_HASCALLERID);
                } else {
                    ast_string_field_set(user, cid_name, "");
                    if (ast_strlen_zero(user->cid_num))
                        ast_clear_flag64(user, IAX_HASCALLERID);
                }
            } else if (!strcasecmp(v->name, "cid_number")) {
                if (!ast_strlen_zero(v->value)) {
                    ast_string_field_set(user, cid_num, v->value);
                    ast_set_flag64(user, IAX_HASCALLERID);
                } else {
                    ast_string_field_set(user, cid_num, "");
                    if (ast_strlen_zero(user->cid_name))
                        ast_clear_flag64(user, IAX_HASCALLERID);
                }
            } else if (!strcasecmp(v->name, "accountcode")) {
                ast_string_field_set(user, accountcode, v->value);
            } else if (!strcasecmp(v->name, "mohinterpret")) {
                ast_string_field_set(user, mohinterpret, v->value);
            } else if (!strcasecmp(v->name, "mohsuggest")) {
                ast_string_field_set(user, mohsuggest, v->value);
            } else if (!strcasecmp(v->name, "parkinglot")) {
                ast_string_field_set(user, parkinglot, v->value);
            } else if (!strcasecmp(v->name, "language")) {
                ast_string_field_set(user, language, v->value);
            } else if (!strcasecmp(v->name, "amaflags")) {
                format = ast_channel_string2amaflag(v->value);
                if (format < 0) {
                    ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
                } else {
                    user->amaflags = format;
                }
            } else if (!strcasecmp(v->name, "inkeys")) {
                ast_string_field_set(user, inkeys, v->value);
            } else if (!strcasecmp(v->name, "maxauthreq")) {
                user->maxauthreq = atoi(v->value);
                if (user->maxauthreq < 0)
                    user->maxauthreq = 0;
            } else if (!strcasecmp(v->name, "adsi")) {
                user->adsi = ast_true(v->value);
            } else if (!strcasecmp(v->name, "connectedline")) {
                if (ast_true(v->value)) {
                    ast_set_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
                } else if (!strcasecmp(v->value, "send")) {
                    ast_clear_flag64(user, IAX_RECVCONNECTEDLINE);
                    ast_set_flag64(user, IAX_SENDCONNECTEDLINE);
                } else if (!strcasecmp(v->value, "receive")) {
                    ast_clear_flag64(user, IAX_SENDCONNECTEDLINE);
                    ast_set_flag64(user, IAX_RECVCONNECTEDLINE);
                } else {
                    ast_clear_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
                }
            } else if (!strcasecmp(v->name, "requirecalltoken")) {
                /* default is required unless in optional ip list */
                if (ast_false(v->value)) {
                    user->calltoken_required = CALLTOKEN_NO;
                } else if (!strcasecmp(v->value, "auto")) {
                    user->calltoken_required = CALLTOKEN_AUTO;
                } else if (ast_true(v->value)) {
                    user->calltoken_required = CALLTOKEN_YES;
                } else {
                    ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
                }
            } /* else if (strcasecmp(v->name,"type")) */
            /*  ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
            v = v->next;
            if (!v) {
                v = alt;
                alt = NULL;
            }
        }
        if (!user->authmethods) {
            if (!ast_strlen_zero(user->secret)) {
                user->authmethods = IAX_AUTH_MD5;
                if (!ast_strlen_zero(user->inkeys))
                    user->authmethods |= IAX_AUTH_RSA;
            } else if (!ast_strlen_zero(user->inkeys)) {
                user->authmethods = IAX_AUTH_RSA;
            } else {
                user->authmethods = IAX_AUTH_MD5;
            }
        }
        ast_clear_flag64(user, IAX_DELME);
    }
cleanup:
    if (oldacl) {
        ast_free_acl_list(oldacl);
    }
    if (oldcon) {
        free_context(oldcon);
    }
 
    if (subscribe_acl_change) {
        acl_change_stasis_subscribe();
    }
 
    return user;
}

References accountcode, acl_change_stasis_subscribe(), adsi, ao2_alloc, ao2_find, ao2_unlink, ast_append_acl(), ast_callerid_split(), ast_channel_string2amaflag(), ast_clear_flag64, ast_copy_flags64, ast_false(), ast_free_acl_list(), ast_log, ast_set2_flag64, ast_set_flag64, ast_set_flags_to64, ast_strdupa, ast_string_field_build, ast_string_field_free_memory, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_true(), ast_variable_list_replace(), ast_variable_new, build_context(), CALLTOKEN_AUTO, CALLTOKEN_DEFAULT, CALLTOKEN_NO, CALLTOKEN_YES, cleanup(), free_context(), get_auth_methods(), get_encrypt_methods(), globalflags, iax2_authmethods, iax2_capability, iax2_encryption, iax2_parse_allow_disallow(), IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, IAX_CODEC_NOCAP, IAX_CODEC_NOPREFS, IAX_CODEC_USER_FIRST, IAX_DELME, IAX_FORCE_ENCRYPT, IAX_HASCALLERID, IAX_IMMEDIATE, IAX_NOTRANSFER, IAX_RECVCONNECTEDLINE, IAX_SENDCONNECTEDLINE, IAX_TRANSFERMEDIA, IAX_TRUNK, IAX_USEJITTERBUF, language, ast_variable::lineno, LOG_WARNING, maxauthreq, mohinterpret, mohsuggest, name, ast_variable::name, iax2_context::next, ast_variable::next, NULL, OBJ_KEY, prefs_global, timer, user, user_destructor(), user_unref(), and ast_variable::value.

Referenced by realtime_user(), and set_config().

cache_get_callno_locked()

static int cache_get_callno_locked ( const char *  data )

static

Definition at line 14284 of file chan_iax2.c.

{
    struct ast_sockaddr addr;
    int x;
    int callno;
    struct iax_ie_data ied;
    struct create_addr_info cai;
    struct parsed_dial_string pds;
    char *tmpstr;
 
    for (x = 0; x < ARRAY_LEN(iaxs); x++) {
        /* Look for an *exact match* call.  Once a call is negotiated, it can only
           look up entries for a single context */
        if (!ast_mutex_trylock(&iaxsl[x])) {
            if (iaxs[x] && !strcasecmp(data, iaxs[x]->dproot))
                return x;
            ast_mutex_unlock(&iaxsl[x]);
        }
    }
 
    /* No match found, we need to create a new one */
 
    memset(&cai, 0, sizeof(cai));
    memset(&ied, 0, sizeof(ied));
    memset(&pds, 0, sizeof(pds));
 
    tmpstr = ast_strdupa(data);
    parse_dial_string(tmpstr, &pds);
 
    if (ast_strlen_zero(pds.peer)) {
        ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
        return -1;
    }
 
    /* Populate our address from the given */
    if (create_addr(pds.peer, NULL, &addr, &cai))
        return -1;
 
    ast_debug(1, "peer: %s, username: %s, password: %s, context: %s\n",
        pds.peer, pds.username, pds.password, pds.context);
 
    callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
    if (callno < 1) {
        ast_log(LOG_WARNING, "Unable to create call\n");
        return -1;
    }
 
    ast_string_field_set(iaxs[callno], dproot, data);
    iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH;
 
    iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
    iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, "TBD");
    /* the string format is slightly different from a standard dial string,
       because the context appears in the 'exten' position
    */
    if (pds.exten)
        iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.exten);
    if (pds.username)
        iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
    iax_ie_append_int(&ied, IAX_IE_FORMAT, IAX_CAPABILITY_FULLBANDWIDTH);
    iax_ie_append_int(&ied, IAX_IE_CAPABILITY, IAX_CAPABILITY_FULLBANDWIDTH);
    /* Keep password handy */
    if (pds.password)
        ast_string_field_set(iaxs[callno], secret, pds.password);
    if (pds.key)
        ast_string_field_set(iaxs[callno], outkey, pds.key);
    /* Start the call going */
    add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
    send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
 
    return callno;
}

References add_empty_calltoken_ie(), ARRAY_LEN, ast_debug, AST_FRAME_IAX, ast_log, ast_mutex_trylock, ast_mutex_unlock, ast_strdupa, ast_string_field_set, ast_strlen_zero(), iax_ie_data::buf, chan_iax2_pvt::capability, parsed_dial_string::context, create_addr(), parsed_dial_string::exten, find_callno_locked(), IAX_CAPABILITY_FULLBANDWIDTH, IAX_COMMAND_NEW, iax_ie_append_int(), iax_ie_append_short(), iax_ie_append_str(), IAX_IE_CALLED_CONTEXT, IAX_IE_CALLED_NUMBER, IAX_IE_CAPABILITY, IAX_IE_FORMAT, IAX_IE_USERNAME, IAX_IE_VERSION, IAX_PROTO_VERSION, iaxs, iaxsl, parsed_dial_string::key, LOG_WARNING, NEW_FORCE, NULL, parse_dial_string(), parsed_dial_string::password, parsed_dial_string::peer, iax_ie_data::pos, send_command(), create_addr_info::sockfd, and parsed_dial_string::username.

Referenced by find_cache().

calc_rxstamp()

static unsigned int calc_rxstamp ( struct chan_iax2_pvt *  p, unsigned int  offset  )

static

Definition at line 6324 of file chan_iax2.c.

{
    /* Returns where in "receive time" we are.  That is, how many ms
       since we received (or would have received) the frame with timestamp 0 */
    int ms;
#ifdef IAXTESTS
    int jit;
#endif /* IAXTESTS */
    /* Setup rxcore if necessary */
    if (ast_tvzero(p->rxcore)) {
        p->rxcore = ast_tvnow();
        if (iaxdebug)
            ast_debug(1, "calc_rxstamp: call=%d: rxcore set to %d.%6.6d - %ums\n",
                    p->callno, (int)(p->rxcore.tv_sec), (int)(p->rxcore.tv_usec), offset);
        p->rxcore = ast_tvsub(p->rxcore, ast_samp2tv(offset, 1000));
#if 1
        if (iaxdebug)
            ast_debug(1, "calc_rxstamp: call=%d: works out as %d.%6.6d\n",
                    p->callno, (int)(p->rxcore.tv_sec),(int)( p->rxcore.tv_usec));
#endif
    }
 
    ms = ast_tvdiff_ms(ast_tvnow(), p->rxcore);
#ifdef IAXTESTS
    if (test_jit) {
        if (!test_jitpct || ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_jitpct)) {
            jit = (int)((float)test_jit * ast_random() / (RAND_MAX + 1.0));
            if ((int)(2.0 * ast_random() / (RAND_MAX + 1.0)))
                jit = -jit;
            ms += jit;
        }
    }
    if (test_late) {
        ms += test_late;
        test_late = 0;
    }
#endif /* IAXTESTS */
    return ms;
}

References ast_debug, ast_random(), ast_samp2tv(), ast_tvdiff_ms(), ast_tvnow(), ast_tvsub(), ast_tvzero(), chan_iax2_pvt::callno, iaxdebug, and chan_iax2_pvt::rxcore.

Referenced by schedule_delivery().

calc_timestamp()

static unsigned int calc_timestamp ( struct chan_iax2_pvt *  p, unsigned int  ts, struct ast_frame *  f  )

static

Definition at line 6189 of file chan_iax2.c.

{
    int ms;
    int voice = 0;
    int genuine = 0;
    int adjust;
    int rate = 0;
    struct timeval *delivery = NULL;
 
 
    /* What sort of frame do we have?: voice is self-explanatory
       "genuine" means an IAX frame - things like LAGRQ/RP, PING/PONG, ACK
       non-genuine frames are CONTROL frames [ringing etc], DTMF
       The "genuine" distinction is needed because genuine frames must get a clock-based timestamp,
       the others need a timestamp slaved to the voice frames so that they go in sequence
    */
    if (f->frametype == AST_FRAME_VOICE) {
        voice = 1;
        rate = ast_format_get_sample_rate(f->subclass.format) / 1000;
        delivery = &f->delivery;
    } else if (f->frametype == AST_FRAME_IAX) {
        genuine = 1;
    } else if (f->frametype == AST_FRAME_CNG) {
        p->notsilenttx = 0;
    }
 
    if (ast_tvzero(p->offset)) {
        p->offset = ast_tvnow();
        /* Round to nearest 20ms for nice looking traces */
        p->offset.tv_usec -= p->offset.tv_usec % 20000;
    }
    /* If the timestamp is specified, just send it as is */
    if (ts)
        return ts;
    /* If we have a time that the frame arrived, always use it to make our timestamp */
    if (delivery && !ast_tvzero(*delivery)) {
        ms = ast_tvdiff_ms(*delivery, p->offset);
        if (ms < 0) {
            ms = 0;
        }
        if (iaxdebug)
            ast_debug(3, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
    } else {
        ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
        if (ms < 0)
            ms = 0;
        if (voice) {
            /* On a voice frame, use predicted values if appropriate */
            adjust = (ms - p->nextpred);
            if (p->notsilenttx && abs(adjust) <= MAX_TIMESTAMP_SKEW) {
                /* Adjust our txcore, keeping voice and non-voice synchronized */
                /* AN EXPLANATION:
                   When we send voice, we usually send "calculated" timestamps worked out
                   on the basis of the number of samples sent. When we send other frames,
                   we usually send timestamps worked out from the real clock.
                   The problem is that they can tend to drift out of step because the
                       source channel's clock and our clock may not be exactly at the same rate.
                   We fix this by continuously "tweaking" p->offset.  p->offset is "time zero"
                   for this call.  Moving it adjusts timestamps for non-voice frames.
                   We make the adjustment in the style of a moving average.  Each time we
                   adjust p->offset by 10% of the difference between our clock-derived
                   timestamp and the predicted timestamp.  That's why you see "10000"
                   below even though IAX2 timestamps are in milliseconds.
                   The use of a moving average avoids offset moving too radically.
                   Generally, "adjust" roams back and forth around 0, with offset hardly
                   changing at all.  But if a consistent different starts to develop it
                   will be eliminated over the course of 10 frames (200-300msecs)
                */
                if (adjust < 0)
                    p->offset = ast_tvsub(p->offset, ast_samp2tv(abs(adjust), 10000));
                else if (adjust > 0)
                    p->offset = ast_tvadd(p->offset, ast_samp2tv(adjust, 10000));
 
                if (!p->nextpred) {
                    p->nextpred = ms; /*f->samples / rate;*/
                    if (p->nextpred <= p->lastsent)
                        p->nextpred = p->lastsent + 3;
                }
                ms = p->nextpred;
            } else {
                   /* in this case, just use the actual
                * time, since we're either way off
                * (shouldn't happen), or we're  ending a
                * silent period -- and seed the next
                * predicted time.  Also, round ms to the
                * next multiple of frame size (so our
                * silent periods are multiples of
                * frame size too) */
 
                if (iaxdebug && abs(adjust) > MAX_TIMESTAMP_SKEW )
                    ast_debug(1, "predicted timestamp skew (%d) > max (%d), using real ts instead.\n",
                        abs(adjust), MAX_TIMESTAMP_SKEW);
 
                if (f->samples >= rate) /* check to make sure we don't core dump */
                {
                    int diff = ms % (f->samples / rate);
                    if (diff)
                        ms += f->samples/rate - diff;
                }
 
                p->nextpred = ms;
                p->notsilenttx = 1;
            }
        } else if ( f->frametype == AST_FRAME_VIDEO ) {
            /*
            * IAX2 draft 03 says that timestamps MUST be in order.
            * It does not say anything about several frames having the same timestamp
            * When transporting video, we can have a frame that spans multiple iax packets
            * (so called slices), so it would make sense to use the same timestamp for all of
            * them
            * We do want to make sure that frames don't go backwards though
            */
            if ( (unsigned int)ms < p->lastsent )
                ms = p->lastsent;
        } else {
            /* On a dataframe, use last value + 3 (to accommodate jitter buffer shrinking) if appropriate unless
               it's a genuine frame */
            adjust = (ms - p->lastsent);
            if (genuine) {
                /* genuine (IAX LAGRQ etc) must keep their clock-based stamps */
                if (ms <= p->lastsent)
                    ms = p->lastsent + 3;
            } else if (abs(adjust) <= MAX_TIMESTAMP_SKEW) {
                /* non-genuine frames (!?) (DTMF, CONTROL) should be pulled into the predicted stream stamps */
                ms = p->lastsent + 3;
            }
        }
    }
    p->lastsent = ms;
    if (voice) {
        p->nextpred = p->nextpred + f->samples / rate;
    }
    return ms;
}

References abs, ast_debug, ast_format_get_sample_rate(), AST_FRAME_CNG, AST_FRAME_IAX, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_samp2tv(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvsub(), ast_tvzero(), chan_iax2_pvt::callno, ast_frame::delivery, ast_frame_subclass::format, ast_frame::frametype, iaxdebug, iaxs, chan_iax2_pvt::lastsent, MAX_TIMESTAMP_SKEW, chan_iax2_pvt::nextpred, chan_iax2_pvt::notsilenttx, NULL, chan_iax2_pvt::offset, chan_iax2_pvt::peercallno, ast_frame::samples, and ast_frame::subclass.

Referenced by iax2_send(), and socket_process_helper().

calc_txpeerstamp()

static unsigned int calc_txpeerstamp ( struct iax2_trunk_peer *  tpeer, int  sampms, struct timeval *  now  )

static

Definition at line 6145 of file chan_iax2.c.

{
    unsigned long int mssincetx; /* unsigned to handle overflows */
    long int ms, pred;
 
    tpeer->trunkact = *now;
    mssincetx = ast_tvdiff_ms(*now, tpeer->lasttxtime);
    if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
        /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
        tpeer->txtrunktime = *now;
        tpeer->lastsent = 999999;
    }
    /* Update last transmit time now */
    tpeer->lasttxtime = *now;
 
    /* Calculate ms offset */
    ms = ast_tvdiff_ms(*now, tpeer->txtrunktime);
    /* Predict from last value */
    pred = tpeer->lastsent + sampms;
    if (labs(ms - pred) < MAX_TIMESTAMP_SKEW)
        ms = pred;
 
    /* We never send the same timestamp twice, so fudge a little if we must */
    if (ms == tpeer->lastsent)
        ms = tpeer->lastsent + 1;
    tpeer->lastsent = ms;
    return ms;
}

References ast_tvdiff_ms(), ast_tvzero(), iax2_trunk_peer::lastsent, iax2_trunk_peer::lasttxtime, MAX_TIMESTAMP_SKEW, iax2_trunk_peer::trunkact, and iax2_trunk_peer::txtrunktime.

Referenced by send_trunk().

calltoken_required()

static int calltoken_required ( struct ast_sockaddr *  addr, const char *  name, int  subclass  )

static

Definition at line 2567 of file chan_iax2.c.

{
    struct addr_range *addr_range;
    struct iax2_peer *peer = NULL;
    struct iax2_user *user = NULL;
    /* if no username is given, check for guest accounts */
    const char *find = S_OR(name, "guest");
    int res = 1;  /* required by default */
    int optional = 0;
    enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
    /* There are only two cases in which calltoken validation is not required.
     * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
     *         the peer definition has not set the requirecalltoken option.
     * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
     */
 
    /* ----- Case 1 ----- */
    if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, addr))) {
        ao2_ref(addr_range, -1);
        optional = 1;
    }
 
    /* ----- Case 2 ----- */
    if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
        calltoken_required = user->calltoken_required;
    } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, addr))) {
        calltoken_required = user->calltoken_required;
    } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
        calltoken_required = peer->calltoken_required;
    } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, addr))) {
        calltoken_required = peer->calltoken_required;
    }
 
    if (peer) {
        peer_unref(peer);
    }
    if (user) {
        user_unref(user);
    }
 
    ast_debug(1, "Determining if address %s with username %s requires calltoken validation.  Optional = %d  calltoken_required = %u \n", ast_sockaddr_stringify_addr(addr), name, optional, calltoken_required);
    if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
        (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
        res = 0;
    }
 
    return res;
}

References addr_range_match_address_cb(), ao2_callback, ao2_ref, ast_debug, ast_sockaddr_stringify_addr(), CALLTOKEN_AUTO, CALLTOKEN_DEFAULT, calltoken_ignores, CALLTOKEN_NO, iax2_peer::calltoken_required, calltoken_required(), find_peer(), find_user(), IAX_COMMAND_NEW, name, NULL, peer_unref(), realtime_peer(), realtime_user(), S_OR, and user_unref().

Referenced by calltoken_required(), and handle_call_token().

check_access()

static int check_access ( int  callno, struct ast_sockaddr *  addr, struct iax_ies *  ies  )

static

Definition at line 7927 of file chan_iax2.c.

{
    /* Start pessimistic */
    int res = -1;
    int version = 2;
    struct iax2_user *user = NULL, *best = NULL;
    int bestscore = 0;
    int gotcapability = 0;
    struct ast_variable *v = NULL, *tmpvar = NULL;
    struct ao2_iterator i;
 
    if (!iaxs[callno])
        return res;
    if (ies->called_number)
        ast_string_field_set(iaxs[callno], exten, ies->called_number);
    if (ies->calling_number) {
        if (ast_test_flag64(&globalflags, IAX_SHRINKCALLERID)) {
            ast_shrink_phone_number(ies->calling_number);
        }
        ast_string_field_set(iaxs[callno], cid_num, ies->calling_number);
    }
    if (ies->calling_name)
        ast_string_field_set(iaxs[callno], cid_name, ies->calling_name);
    if (ies->calling_ani)
        ast_string_field_set(iaxs[callno], ani, ies->calling_ani);
    if (ies->dnid)
        ast_string_field_set(iaxs[callno], dnid, ies->dnid);
    if (ies->rdnis)
        ast_string_field_set(iaxs[callno], rdnis, ies->rdnis);
    if (ies->called_context)
        ast_string_field_set(iaxs[callno], context, ies->called_context);
    if (ies->language)
        ast_string_field_set(iaxs[callno], language, ies->language);
    if (ies->username)
        ast_string_field_set(iaxs[callno], username, ies->username);
    if (ies->calling_ton > -1)
        iaxs[callno]->calling_ton = ies->calling_ton;
    if (ies->calling_tns > -1)
        iaxs[callno]->calling_tns = ies->calling_tns;
    if (ies->calling_pres > -1)
        iaxs[callno]->calling_pres = ies->calling_pres;
    if (ies->calling_ani2 > -1)
        iaxs[callno]->calling_ani2 = ies->calling_ani2;
    if (ies->format)
        iaxs[callno]->peerformat = ies->format;
    if (ies->adsicpe)
        iaxs[callno]->peeradsicpe = ies->adsicpe;
    if (ies->capability) {
        gotcapability = 1;
        iaxs[callno]->peercapability = ies->capability;
    }
    if (ies->version)
        version = ies->version;
 
    /* Use provided preferences until told otherwise for actual preferences */
    if (ies->codec_prefs) {
        iax2_codec_pref_convert(&iaxs[callno]->rprefs, ies->codec_prefs, 32, 0);
    } else {
        memset(&iaxs[callno]->rprefs, 0, sizeof(iaxs[callno]->rprefs));
    }
    iaxs[callno]->prefs = iaxs[callno]->rprefs;
 
    if (!gotcapability) {
        iaxs[callno]->peercapability = iaxs[callno]->peerformat;
    }
    if (version > IAX_PROTO_VERSION) {
        ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
                ast_sockaddr_stringify_addr(addr), version);
        return res;
    }
    /* Search the userlist for a compatible entry, and fill in the rest */
    i = ao2_iterator_init(users, 0);
    while ((user = ao2_iterator_next(&i))) {
        if ((ast_strlen_zero(iaxs[callno]->username) ||             /* No username specified */
            !strcmp(iaxs[callno]->username, user->name))    /* Or this username specified */
            && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_ALLOW)   /* Access is permitted from this IP */
            && (ast_strlen_zero(iaxs[callno]->context) ||           /* No context specified */
                 apply_context(user->contexts, iaxs[callno]->context))) {           /* Context is permitted */
            if (!ast_strlen_zero(iaxs[callno]->username)) {
                /* Exact match, stop right now. */
                if (best)
                    user_unref(best);
                best = user;
                break;
            } else if (ast_strlen_zero(user->secret) && ast_strlen_zero(user->dbsecret) && ast_strlen_zero(user->inkeys)) {
                /* No required authentication */
                if (user->acl) {
                    /* There was host authentication and we passed, bonus! */
                    if (bestscore < 4) {
                        bestscore = 4;
                        if (best)
                            user_unref(best);
                        best = user;
                        continue;
                    }
                } else {
                    /* No host access, but no secret, either, not bad */
                    if (bestscore < 3) {
                        bestscore = 3;
                        if (best)
                            user_unref(best);
                        best = user;
                        continue;
                    }
                }
            } else {
                if (user->acl) {
                    /* Authentication, but host access too, eh, it's something.. */
                    if (bestscore < 2) {
                        bestscore = 2;
                        if (best)
                            user_unref(best);
                        best = user;
                        continue;
                    }
                } else {
                    /* Authentication and no host access...  This is our baseline */
                    if (bestscore < 1) {
                        bestscore = 1;
                        if (best)
                            user_unref(best);
                        best = user;
                        continue;
                    }
                }
            }
        }
        user_unref(user);
    }
    ao2_iterator_destroy(&i);
    user = best;
    if (!user && !ast_strlen_zero(iaxs[callno]->username)) {
        user = realtime_user(iaxs[callno]->username, addr);
        if (user && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_DENY        /* Access is denied from this IP */
            || (!ast_strlen_zero(iaxs[callno]->context) &&                  /* No context specified */
                !apply_context(user->contexts, iaxs[callno]->context)))) {  /* Context is permitted */
            user = user_unref(user);
        }
    }
    if (user) {
        /* We found our match (use the first) */
        /* copy vars */
        for (v = user->vars ; v ; v = v->next) {
            if ((tmpvar = ast_variable_new(v->name, v->value, v->file))) {
                if (ast_variable_list_replace(&iaxs[callno]->vars, tmpvar)) {
                    tmpvar->next = iaxs[callno]->vars;
                    iaxs[callno]->vars = tmpvar;
                }
            }
        }
        /* If a max AUTHREQ restriction is in place, activate it */
        if (user->maxauthreq > 0)
            ast_set_flag64(iaxs[callno], IAX_MAXAUTHREQ);
        iaxs[callno]->prefs = user->prefs;
        ast_copy_flags64(iaxs[callno], user, IAX_CODEC_USER_FIRST | IAX_IMMEDIATE | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_FORCE_ENCRYPT);
        iaxs[callno]->encmethods = user->encmethods;
        /* Store the requested username if not specified */
        if (ast_strlen_zero(iaxs[callno]->username))
            ast_string_field_set(iaxs[callno], username, user->name);
        /* Store whether this is a trunked call, too, of course, and move if appropriate */
        ast_copy_flags64(iaxs[callno], user, IAX_TRUNK);
        iaxs[callno]->capability = user->capability;
        /* And use the default context */
        if (ast_strlen_zero(iaxs[callno]->context)) {
            if (user->contexts)
                ast_string_field_set(iaxs[callno], context, user->contexts->context);
            else
                ast_string_field_set(iaxs[callno], context, DEFAULT_CONTEXT);
        }
        /* And any input keys */
        ast_string_field_set(iaxs[callno], inkeys, user->inkeys);
        /* And the permitted authentication methods */
        iaxs[callno]->authmethods = user->authmethods;
        iaxs[callno]->adsi = user->adsi;
        /* If the user has callerid, override the remote caller id. */
        if (ast_test_flag64(user, IAX_HASCALLERID)) {
            iaxs[callno]->calling_tns = 0;
            iaxs[callno]->calling_ton = 0;
            ast_string_field_set(iaxs[callno], cid_num, user->cid_num);
            ast_string_field_set(iaxs[callno], cid_name, user->cid_name);
            ast_string_field_set(iaxs[callno], ani, user->cid_num);
            iaxs[callno]->calling_pres = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
        } else if (ast_strlen_zero(iaxs[callno]->cid_num) && ast_strlen_zero(iaxs[callno]->cid_name)) {
            iaxs[callno]->calling_pres = AST_PRES_NUMBER_NOT_AVAILABLE;
        } /* else user is allowed to set their own CID settings */
        if (!ast_strlen_zero(user->accountcode))
            ast_string_field_set(iaxs[callno], accountcode, user->accountcode);
        if (!ast_strlen_zero(user->mohinterpret))
            ast_string_field_set(iaxs[callno], mohinterpret, user->mohinterpret);
        if (!ast_strlen_zero(user->mohsuggest))
            ast_string_field_set(iaxs[callno], mohsuggest, user->mohsuggest);
        if (!ast_strlen_zero(user->parkinglot))
            ast_string_field_set(iaxs[callno], parkinglot, user->parkinglot);
        if (user->amaflags)
            iaxs[callno]->amaflags = user->amaflags;
        if (!ast_strlen_zero(user->language))
            ast_string_field_set(iaxs[callno], language, user->language);
        ast_copy_flags64(iaxs[callno], user, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
        /* Keep this check last */
        if (!ast_strlen_zero(user->dbsecret)) {
            char *family, *key=NULL;
            char buf[80];
            family = ast_strdupa(user->dbsecret);
            key = strchr(family, '/');
            if (key) {
                *key = '\0';
                key++;
            }
            if (!key || ast_db_get(family, key, buf, sizeof(buf)))
                ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", user->dbsecret);
            else
                ast_string_field_set(iaxs[callno], secret, buf);
        } else
            ast_string_field_set(iaxs[callno], secret, user->secret);
        res = 0;
        user = user_unref(user);
    } else {
         /* user was not found, but we should still fake an AUTHREQ.
          * Set authmethods to the last known authmethod used by the system
          * Set a fake secret, it's not looked at, just required to attempt authentication.
          * Set authrej so the AUTHREP is rejected without even looking at its contents */
        iaxs[callno]->authmethods = last_authmethod ? last_authmethod : IAX_AUTH_MD5;
        ast_string_field_set(iaxs[callno], secret, "badsecret");
        iaxs[callno]->authrej = 1;
        if (!ast_strlen_zero(iaxs[callno]->username)) {
            /* only send the AUTHREQ if a username was specified. */
            res = 0;
        }
    }
    ast_set2_flag64(iaxs[callno], iax2_getpeertrunk(*addr), IAX_TRUNK);
    return res;
}

References accountcode, chan_iax2_pvt::adsi, iax_ies::adsicpe, chan_iax2_pvt::amaflags, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, apply_context(), ast_apply_acl(), ast_copy_flags64, ast_db_get(), ast_log, AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, AST_PRES_NUMBER_NOT_AVAILABLE, AST_SENSE_ALLOW, AST_SENSE_DENY, ast_set2_flag64, ast_set_flag64, ast_shrink_phone_number(), ast_sockaddr_stringify_addr(), ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_variable_list_replace(), ast_variable_new, chan_iax2_pvt::authmethods, chan_iax2_pvt::authrej, buf, iax_ies::called_context, iax_ies::called_number, iax_ies::calling_ani, chan_iax2_pvt::calling_ani2, iax_ies::calling_ani2, iax_ies::calling_name, iax_ies::calling_number, chan_iax2_pvt::calling_pres, iax_ies::calling_pres, chan_iax2_pvt::calling_tns, iax_ies::calling_tns, chan_iax2_pvt::calling_ton, iax_ies::calling_ton, chan_iax2_pvt::capability, iax_ies::capability, iax_ies::codec_prefs, chan_iax2_pvt::context, voicemailpwcheck::context, DEFAULT_CONTEXT, iax_ies::dnid, chan_iax2_pvt::encmethods, ast_variable::file, iax_ies::format, globalflags, iax2_codec_pref_convert(), iax2_getpeertrunk(), IAX_AUTH_MD5, IAX_CODEC_NOCAP, IAX_CODEC_NOPREFS, IAX_CODEC_USER_FIRST, IAX_FORCE_ENCRYPT, IAX_HASCALLERID, IAX_IMMEDIATE, IAX_MAXAUTHREQ, IAX_NOTRANSFER, IAX_PROTO_VERSION, IAX_RECVCONNECTEDLINE, IAX_SENDCONNECTEDLINE, IAX_SHRINKCALLERID, IAX_TRANSFERMEDIA, IAX_TRUNK, IAX_USEJITTERBUF, iaxs, language, iax_ies::language, last_authmethod, LOG_WARNING, mohinterpret, mohsuggest, ast_variable::name, ast_variable::next, NULL, chan_iax2_pvt::peeradsicpe, chan_iax2_pvt::peercapability, chan_iax2_pvt::peerformat, chan_iax2_pvt::prefs, iax_ies::rdnis, realtime_user(), chan_iax2_pvt::rprefs, user, user_unref(), iax_ies::username, ast_variable::value, chan_iax2_pvt::vars, version, and iax_ies::version.

Referenced by socket_process_helper().

check_provisioning()

static int check_provisioning ( struct ast_sockaddr *  addr, int  sockfd, char *  si, unsigned int  ver  )

static

Definition at line 9781 of file chan_iax2.c.

{
    unsigned int ourver;
    char rsi[80];
    snprintf(rsi, sizeof(rsi), "si-%s", si);
    if (iax_provision_version(&ourver, rsi, 1))
        return 0;
    ast_debug(1, "Service identifier '%s', we think '%08x', they think '%08x'\n", si, ourver, ver);
    if (ourver != ver)
        iax2_provision(addr, sockfd, NULL, rsi, 1);
    return 0;
}

References ast_debug, iax2_provision(), iax_provision_version(), and NULL.

Referenced by socket_process_helper().

check_srcaddr()

static int check_srcaddr ( struct ast_sockaddr *  addr )

static

Check if address can be used as packet source.

Return values

0	address available
1	address unavailable
-1	error

Definition at line 12893 of file chan_iax2.c.

{
    int sd;
 
    sd = socket(addr->ss.ss_family, SOCK_DGRAM, 0);
    if (sd < 0) {
        ast_log(LOG_ERROR, "Socket: %s\n", strerror(errno));
        return -1;
    }
 
    if (ast_bind(sd, addr) < 0) {
        ast_debug(1, "Can't bind: %s\n", strerror(errno));
        close(sd);
        return 1;
    }
 
    close(sd);
    return 0;
}

References ast_bind(), ast_debug, ast_log, errno, LOG_ERROR, and ast_sockaddr::ss.

Referenced by peer_set_srcaddr().

cleanup_thread_list()

static void cleanup_thread_list ( void *  head )

static

Definition at line 14793 of file chan_iax2.c.

{
    AST_LIST_HEAD(iax2_thread_list, iax2_thread);
    struct iax2_thread_list *list_head = head;
    struct iax2_thread *thread;
 
    AST_LIST_LOCK(list_head);
    while ((thread = AST_LIST_REMOVE_HEAD(list_head, list))) {
        pthread_t thread_id = thread->threadid;
 
        thread->stop = 1;
        signal_condition(&thread->lock, &thread->cond);
 
        AST_LIST_UNLOCK(list_head);
        pthread_join(thread_id, NULL);
        AST_LIST_LOCK(list_head);
    }
    AST_LIST_UNLOCK(list_head);
}

References AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, iax2_thread::list, NULL, signal_condition(), and thread.

Referenced by __unload_module().

codec_choose_from_prefs()

static struct ast_format * codec_choose_from_prefs ( struct iax2_codec_pref *  pref, struct ast_format_cap *  cap  )

static

Definition at line 1920 of file chan_iax2.c.

{
    int x;
    struct ast_format *found_format = NULL;
 
    for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
        struct ast_format *pref_format;
        uint64_t pref_bitfield;
 
        pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
        if (!pref_bitfield) {
            break;
        }
 
        pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
        if (!pref_format) {
            /* The bitfield is not associated with any format. */
            continue;
        }
        found_format = ast_format_cap_get_compatible_format(cap, pref_format);
        if (found_format) {
            break;
        }
    }
 
    if (found_format && (ast_format_get_type(found_format) == AST_MEDIA_TYPE_AUDIO)) {
        return found_format;
    }
 
    ast_debug(4, "Could not find preferred codec - Returning zero codec.\n");
    ao2_cleanup(found_format);
    return NULL;
}

References ao2_cleanup, ARRAY_LEN, ast_debug, ast_format_cap_get_compatible_format(), ast_format_compatibility_bitfield2format(), ast_format_get_type(), AST_MEDIA_TYPE_AUDIO, iax2_codec_pref_order_value_to_format_bitfield(), NULL, and iax2_codec_pref::order.

Referenced by iax2_codec_choose().

complete_dpreply()

static int complete_dpreply ( struct chan_iax2_pvt *  pvt, struct iax_ies *  ies  )

static

Definition at line 8784 of file chan_iax2.c.

{
    char exten[256] = "";
    int status = CACHE_FLAG_UNKNOWN, expiry = iaxdefaultdpcache, x, matchmore = 0;
    struct iax2_dpcache *dp = NULL;
 
    if (ies->called_number)
        ast_copy_string(exten, ies->called_number, sizeof(exten));
 
    if (ies->dpstatus & IAX_DPSTATUS_EXISTS)
        status = CACHE_FLAG_EXISTS;
    else if (ies->dpstatus & IAX_DPSTATUS_CANEXIST)
        status = CACHE_FLAG_CANEXIST;
    else if (ies->dpstatus & IAX_DPSTATUS_NONEXISTENT)
        status = CACHE_FLAG_NONEXISTENT;
 
    if (ies->refresh)
        expiry = ies->refresh;
    if (ies->dpstatus & IAX_DPSTATUS_MATCHMORE)
        matchmore = CACHE_FLAG_MATCHMORE;
 
    AST_LIST_LOCK(&dpcache);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, peer_list) {
        if (strcmp(dp->exten, exten))
            continue;
        AST_LIST_REMOVE_CURRENT(peer_list);
        dp->callno = 0;
        dp->expiry.tv_sec = dp->orig.tv_sec + expiry;
        if (dp->flags & CACHE_FLAG_PENDING) {
            dp->flags &= ~CACHE_FLAG_PENDING;
            dp->flags |= status;
            dp->flags |= matchmore;
        }
        /* Wake up waiters */
        for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
            if (dp->waiters[x] > -1) {
                if (write(dp->waiters[x], "asdf", 4) < 0) {
                }
            }
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
    AST_LIST_UNLOCK(&dpcache);
 
    return 0;
}

References ARRAY_LEN, ast_copy_string(), AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, CACHE_FLAG_CANEXIST, CACHE_FLAG_EXISTS, CACHE_FLAG_MATCHMORE, CACHE_FLAG_NONEXISTENT, CACHE_FLAG_PENDING, CACHE_FLAG_UNKNOWN, iax_ies::called_number, iax2_dpcache::callno, iax_ies::dpstatus, iax2_dpcache::expiry, iax2_dpcache::exten, iax2_dpcache::flags, IAX_DPSTATUS_CANEXIST, IAX_DPSTATUS_EXISTS, IAX_DPSTATUS_MATCHMORE, IAX_DPSTATUS_NONEXISTENT, iaxdefaultdpcache, matchmore(), NULL, iax2_dpcache::orig, iax2_dpcache::peer_list, iax_ies::refresh, status, and iax2_dpcache::waiters.

Referenced by socket_process_helper().

complete_iax2_peers()

static char * complete_iax2_peers ( const char *  line, const char *  word, int  pos, int  state, uint64_t  flags  )

static

Definition at line 3964 of file chan_iax2.c.

{
    int which = 0;
    struct iax2_peer *peer;
    char *res = NULL;
    int wordlen = strlen(word);
    struct ao2_iterator i;
 
    i = ao2_iterator_init(peers, 0);
    while ((peer = ao2_iterator_next(&i))) {
        if (!strncasecmp(peer->name, word, wordlen) && ++which > state
            && (!flags || ast_test_flag64(peer, flags))) {
            res = ast_strdup(peer->name);
            peer_unref(peer);
            break;
        }
        peer_unref(peer);
    }
    ao2_iterator_destroy(&i);
 
    return res;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_strdup, ast_test_flag64, ao2_iterator::flags, iax2_peer::name, NULL, and peer_unref().

Referenced by handle_cli_iax2_prune_realtime(), handle_cli_iax2_set_debug(), and handle_cli_iax2_show_peer().

complete_iax2_unregister()

static char * complete_iax2_unregister ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 7288 of file chan_iax2.c.

{
    int which = 0;
    struct iax2_peer *p = NULL;
    char *res = NULL;
    int wordlen = strlen(word);
 
    /* 0 - iax2; 1 - unregister; 2 - <peername> */
    if (pos == 2) {
        struct ao2_iterator i = ao2_iterator_init(peers, 0);
        while ((p = ao2_iterator_next(&i))) {
            if (!strncasecmp(p->name, word, wordlen) &&
                ++which > state && p->expire > -1) {
                res = ast_strdup(p->name);
                peer_unref(p);
                break;
            }
            peer_unref(p);
        }
        ao2_iterator_destroy(&i);
    }
 
    return res;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_strdup, iax2_peer::expire, iax2_peer::name, NULL, and peer_unref().

Referenced by handle_cli_iax2_unregister().

complete_transfer()

static int complete_transfer ( int  callno, struct iax_ies *  ies  )

static

Definition at line 8831 of file chan_iax2.c.

{
    int peercallno = 0;
    struct chan_iax2_pvt *pvt = iaxs[callno];
    struct iax_frame *cur;
    jb_frame frame;
 
    if (ies->callno)
        peercallno = ies->callno;
 
    if (peercallno < 1) {
        ast_log(LOG_WARNING, "Invalid transfer request\n");
        return -1;
    }
    remove_by_transfercallno(pvt);
    /* since a transfer has taken place, the address will change.
     * This must be accounted for in the peercnts table.  Remove
     * the old address and add the new one */
    peercnt_remove_by_addr(&pvt->addr);
    peercnt_add(&pvt->transfer);
    /* now copy over the new address */
    memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
    memset(&pvt->transfer, 0, sizeof(pvt->transfer));
    /* Reset sequence numbers */
    pvt->oseqno = 0;
    pvt->rseqno = 0;
    pvt->iseqno = 0;
    pvt->aseqno = 0;
 
    if (pvt->peercallno) {
        remove_by_peercallno(pvt);
    }
    pvt->peercallno = peercallno;
    /*this is where the transferring call switches hash tables */
    store_by_peercallno(pvt);
    pvt->transferring = TRANSFER_NONE;
    pvt->svoiceformat = -1;
    pvt->voiceformat = 0;
    pvt->svideoformat = -1;
    pvt->videoformat = 0;
    pvt->transfercallno = 0;
    memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
    memset(&pvt->offset, 0, sizeof(pvt->offset));
    /* reset jitterbuffer */
    while(jb_getall(pvt->jb,&frame) == JB_OK)
        iax2_frame_free(frame.data);
    jb_reset(pvt->jb);
    pvt->lag = 0;
    pvt->last = 0;
    pvt->lastsent = 0;
    pvt->nextpred = 0;
    pvt->pingtime = DEFAULT_RETRY_TIME;
    AST_LIST_TRAVERSE(&frame_queue[callno], cur, list) {
        /* We must cancel any packets that would have been transmitted
           because now we're talking to someone new.  It's okay, they
           were transmitted to someone that didn't care anyway. */
        cur->retries = -1;
    }
    return 0;
}

References chan_iax2_pvt::addr, chan_iax2_pvt::aseqno, AST_LIST_TRAVERSE, ast_log, chan_iax2_pvt::callno, iax_ies::callno, iax_frame::callno, jb_frame::data, DEFAULT_RETRY_TIME, frame_queue, iax2_frame_free(), iaxs, chan_iax2_pvt::iseqno, chan_iax2_pvt::jb, jb_getall(), JB_OK, jb_reset(), chan_iax2_pvt::lag, chan_iax2_pvt::last, chan_iax2_pvt::lastsent, iax_frame::list, LOG_WARNING, chan_iax2_pvt::nextpred, chan_iax2_pvt::offset, chan_iax2_pvt::oseqno, chan_iax2_pvt::peercallno, peercnt_add(), peercnt_remove_by_addr(), chan_iax2_pvt::pingtime, remove_by_peercallno(), remove_by_transfercallno(), iax_frame::retries, chan_iax2_pvt::rseqno, chan_iax2_pvt::rxcore, store_by_peercallno(), chan_iax2_pvt::svideoformat, chan_iax2_pvt::svoiceformat, chan_iax2_pvt::transfer, TRANSFER_NONE, chan_iax2_pvt::transfercallno, chan_iax2_pvt::transferring, chan_iax2_pvt::videoformat, and chan_iax2_pvt::voiceformat.

Referenced by socket_process_helper().

compress_subclass()

static unsigned char compress_subclass ( iax2_format  subclass )

static

Definition at line 1886 of file chan_iax2.c.

{
    int x;
    int power=-1;
    /* If it's 64 or smaller, just return it */
    if (subclass < IAX_FLAG_SC_LOG)
        return subclass;
    /* Otherwise find its power */
    for (x = 0; x < IAX_MAX_SHIFT; x++) {
        if (subclass & (1LL << x)) {
            if (power > -1) {
                ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
                return 0;
            } else
                power = x;
        }
    }
    return power | IAX_FLAG_SC_LOG;
}

References ast_log, IAX_FLAG_SC_LOG, IAX_MAX_SHIFT, and LOG_WARNING.

Referenced by iax2_send(), raw_hangup(), and send_apathetic_reply().

construct_rr()

static void construct_rr ( struct chan_iax2_pvt *  pvt, struct iax_ie_data *  iep  )

static

Definition at line 9794 of file chan_iax2.c.

{
    jb_info stats;
    jb_getinfo(pvt->jb, &stats);
 
    memset(iep, 0, sizeof(*iep));
 
    iax_ie_append_int(iep,IAX_IE_RR_JITTER, stats.jitter);
    if(stats.frames_in == 0) stats.frames_in = 1;
    iax_ie_append_int(iep,IAX_IE_RR_LOSS, ((0xff & (stats.losspct/1000)) << 24 | (stats.frames_lost & 0x00ffffff)));
    iax_ie_append_int(iep,IAX_IE_RR_PKTS, stats.frames_in);
    iax_ie_append_short(iep,IAX_IE_RR_DELAY, stats.current - stats.min);
    iax_ie_append_int(iep,IAX_IE_RR_DROPPED, stats.frames_dropped);
    iax_ie_append_int(iep,IAX_IE_RR_OOO, stats.frames_ooo);
}

References jb_info::current, jb_info::frames_dropped, jb_info::frames_in, jb_info::frames_lost, jb_info::frames_ooo, iax_ie_append_int(), iax_ie_append_short(), IAX_IE_RR_DELAY, IAX_IE_RR_DROPPED, IAX_IE_RR_JITTER, IAX_IE_RR_LOSS, IAX_IE_RR_OOO, IAX_IE_RR_PKTS, chan_iax2_pvt::jb, jb_getinfo(), jb_info::jitter, jb_info::losspct, and jb_info::min.

Referenced by socket_process_helper().

create_addr()

static int create_addr ( const char *  peername, struct ast_channel *  c, struct ast_sockaddr *  addr, struct create_addr_info *  cai  )

static

Definition at line 4706 of file chan_iax2.c.

{
    struct iax2_peer *peer;
    int res = -1;
 
    ast_clear_flag64(cai, IAX_SENDANI | IAX_TRUNK);
    cai->sockfd = defaultsockfd;
    cai->maxtime = 0;
 
    if (!(peer = find_peer(peername, 1))) {
        struct ast_sockaddr peer_addr;
 
        peer_addr.ss.ss_family = AST_AF_UNSPEC;
        cai->found = 0;
        if (ast_get_ip_or_srv(&peer_addr, peername, srvlookup ? "_iax._udp" : NULL)) {
            ast_log(LOG_WARNING, "No such host: %s\n", peername);
            return -1;
        }
 
        if (!ast_sockaddr_port(&peer_addr)) {
            ast_sockaddr_set_port(&peer_addr, IAX_DEFAULT_PORTNO);
        }
 
        ast_sockaddr_copy(addr, &peer_addr);
        /*
         * Use The global iax prefs for unknown peer/user.
         * However, move the calling channel's native codec to
         * the top of the preference list.
         */
        cai->prefs = prefs_global;
        if (c) {
            int i;
 
            for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
                struct ast_format *format = ast_format_cap_get_format(
                    ast_channel_nativeformats(c), i);
                iax2_codec_pref_prepend(&cai->prefs, format,
                    ast_format_cap_get_format_framing(ast_channel_nativeformats(c), format),
                    1);
                ao2_ref(format, -1);
            }
        }
        return 0;
    }
 
    cai->found = 1;
 
    /* if the peer has no address (current or default), return failure */
    if (ast_sockaddr_isnull(&peer->addr) && ast_sockaddr_isnull(&peer->defaddr)) {
        goto return_unref;
    }
 
    /* if the peer is being monitored and is currently unreachable, return failure */
    if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
        goto return_unref;
 
    ast_copy_flags64(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
    cai->maxtime = peer->maxms;
    cai->capability = peer->capability;
    cai->encmethods = peer->encmethods;
    cai->authmethods = peer->authmethods;
    cai->sockfd = peer->sockfd;
    cai->adsi = peer->adsi;
    cai->prefs = peer->prefs;
    /* Move the calling channel's native codec to the top of the preference list */
    if (c) {
        int i;
 
        for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
            struct ast_format *tmpfmt = ast_format_cap_get_format(
                ast_channel_nativeformats(c), i);
            iax2_codec_pref_prepend(&cai->prefs, tmpfmt,
                ast_format_cap_get_format_framing(ast_channel_nativeformats(c), tmpfmt),
                1);
            ao2_ref(tmpfmt, -1);
        }
    }
    ast_copy_string(cai->context, peer->context, sizeof(cai->context));
    ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
    ast_copy_string(cai->username, peer->username, sizeof(cai->username));
    ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
    ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
    ast_copy_string(cai->cid_num, peer->cid_num, sizeof(cai->cid_num));
    ast_copy_string(cai->cid_name, peer->cid_name, sizeof(cai->cid_name));
    ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
    ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
    if (ast_strlen_zero(peer->dbsecret)) {
        ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
    } else {
        char *family;
        char *key = NULL;
 
        family = ast_strdupa(peer->dbsecret);
        key = strchr(family, '/');
        if (key)
            *key++ = '\0';
        if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
            ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
            goto return_unref;
        }
    }
 
    if (!ast_sockaddr_isnull(&peer->addr)) {
        ast_sockaddr_copy(addr, &peer->addr);
    } else {
        ast_sockaddr_copy(addr, &peer->defaddr);
    }
 
    res = 0;
 
return_unref:
    peer_unref(peer);
 
    return res;
}

References iax2_peer::addr, iax2_peer::adsi, create_addr_info::adsi, ao2_ref, AST_AF_UNSPEC, ast_channel_nativeformats(), ast_clear_flag64, ast_copy_flags64, ast_copy_string(), ast_db_get(), ast_format_cap_count(), ast_format_cap_get_format(), ast_format_cap_get_format_framing(), ast_get_ip_or_srv(), ast_log, ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_port, ast_sockaddr_set_port, ast_strdupa, ast_strlen_zero(), iax2_peer::authmethods, create_addr_info::authmethods, c, iax2_peer::capability, create_addr_info::capability, iax2_peer::cid_name, create_addr_info::cid_name, iax2_peer::cid_num, create_addr_info::cid_num, iax2_peer::context, create_addr_info::context, iax2_peer::dbsecret, iax2_peer::defaddr, defaultsockfd, iax2_peer::encmethods, create_addr_info::encmethods, find_peer(), create_addr_info::found, iax2_codec_pref_prepend(), IAX_DEFAULT_PORTNO, IAX_FORCE_ENCRYPT, IAX_NOTRANSFER, IAX_RECVCONNECTEDLINE, IAX_SENDANI, IAX_SENDCONNECTEDLINE, IAX_TRANSFERMEDIA, IAX_TRUNK, IAX_USEJITTERBUF, iax2_peer::lastms, LOG_WARNING, iax2_peer::maxms, create_addr_info::maxtime, iax2_peer::mohinterpret, create_addr_info::mohinterpret, iax2_peer::mohsuggest, create_addr_info::mohsuggest, NULL, iax2_peer::outkey, create_addr_info::outkey, peer_unref(), iax2_peer::peercontext, create_addr_info::peercontext, iax2_peer::prefs, create_addr_info::prefs, prefs_global, iax2_peer::secret, create_addr_info::secret, iax2_peer::sockfd, create_addr_info::sockfd, srvlookup, ast_sockaddr::ss, create_addr_info::timezone, iax2_peer::username, create_addr_info::username, and iax2_peer::zonetag.

Referenced by cache_get_callno_locked(), iax2_call(), iax2_provision(), and iax2_request().

create_callno_pools()

static int create_callno_pools ( void  )

static

Definition at line 3094 of file chan_iax2.c.

{
    uint16_t i;
 
    callno_pool.available = callno_pool_trunk.available = 0;
 
    /* We start at 2.  0 and 1 are reserved. */
    for (i = 2; i < TRUNK_CALL_START; i++) {
        callno_pool.numbers[callno_pool.available] = i;
        callno_pool.available++;
    }
 
    for (i = TRUNK_CALL_START; i < IAX_MAX_CALLS; i++) {
        callno_pool_trunk.numbers[callno_pool_trunk.available] = i;
        callno_pool_trunk.available++;
    }
 
    callno_pool.capacity = callno_pool.available;
    callno_pool_trunk.capacity = callno_pool_trunk.available;
 
    ast_assert(callno_pool.capacity && callno_pool_trunk.capacity);
 
    return 0;
}

References ast_assert, call_number_pool::available, callno_pool, callno_pool_trunk, call_number_pool::capacity, IAX_MAX_CALLS, call_number_pool::numbers, and TRUNK_CALL_START.

Referenced by load_objects().

decode_frame()

static int decode_frame ( ast_aes_decrypt_key *  dcx, struct ast_iax2_full_hdr *  fh, struct ast_frame *  f, int *  datalen  )

static

Definition at line 6563 of file chan_iax2.c.

{
    int padding;
    unsigned char *workspace;
 
    workspace = ast_alloca(*datalen);
    memset(f, 0, sizeof(*f));
    if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
        struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
        if (*datalen < 16 + sizeof(struct ast_iax2_full_hdr))
            return -1;
        /* Decrypt */
        memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr), dcx);
 
        padding = 16 + (workspace[15] & 0x0f);
        if (iaxdebug)
            ast_debug(1, "Decoding full frame with length %d (padding = %d) (15=%02hhx)\n", *datalen, padding, workspace[15]);
        if (*datalen < padding + sizeof(struct ast_iax2_full_hdr))
            return -1;
 
        *datalen -= padding;
        memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
        f->frametype = fh->type;
        if (f->frametype == AST_FRAME_VIDEO) {
            f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1));
            if (!f->subclass.format) {
                f->subclass.format = ast_format_none;
            }
        } else if (f->frametype == AST_FRAME_VOICE) {
            f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
            if (!f->subclass.format) {
                f->subclass.format = ast_format_none;
            }
        } else {
            f->subclass.integer = uncompress_subclass(fh->csub);
        }
    } else {
        struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
        if (iaxdebug)
            ast_debug(5, "Decoding mini with length %d\n", *datalen);
        if (*datalen < 16 + sizeof(struct ast_iax2_mini_hdr))
            return -1;
        /* Decrypt */
        memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), dcx);
        padding = 16 + (workspace[15] & 0x0f);
        if (*datalen < padding + sizeof(struct ast_iax2_mini_hdr))
            return -1;
        *datalen -= padding;
        memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
    }
    return 0;
}

References ast_alloca, ast_debug, ast_format_compatibility_bitfield2format(), ast_format_none, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_iax2_full_hdr::csub, ast_iax2_full_enc_hdr::encdata, ast_iax2_mini_enc_hdr::encdata, ast_frame_subclass::format, ast_frame::frametype, IAX_FLAG_FULL, iaxdebug, ast_frame_subclass::integer, memcpy_decrypt(), ast_iax2_full_hdr::scallno, ast_frame::subclass, ast_iax2_full_hdr::type, and uncompress_subclass().

Referenced by decrypt_frame(), and update_packet().

decrypt_frame()

static int decrypt_frame ( int  callno, struct ast_iax2_full_hdr *  fh, struct ast_frame *  f, int *  datalen  )

static

Definition at line 6655 of file chan_iax2.c.

{
    int res=-1;
    if (!ast_test_flag64(iaxs[callno], IAX_KEYPOPULATED)) {
        /* Search for possible keys, given secrets */
        struct MD5Context md5;
        unsigned char digest[16];
        char *tmppw, *stringp;
 
        tmppw = ast_strdupa(iaxs[callno]->secret);
        stringp = tmppw;
        while ((tmppw = strsep(&stringp, ";"))) {
            MD5Init(&md5);
            MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
            MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
            MD5Final(digest, &md5);
            build_encryption_keys(digest, iaxs[callno]);
            res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
            if (!res) {
                ast_set_flag64(iaxs[callno], IAX_KEYPOPULATED);
                break;
            }
        }
    } else
        res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
    return res;
}

References ast_set_flag64, ast_strdupa, ast_test_flag64, build_encryption_keys(), ast_iax2_mini_enc_hdr::callno, challenge(), decode_frame(), IAX_KEYPOPULATED, iaxs, md5(), MD5Final(), MD5Init(), MD5Update(), and strsep().

Referenced by socket_process_helper().

defer_full_frame()

static void defer_full_frame ( struct iax2_thread *  from_here, struct iax2_thread *  to_here  )

static

Queue the last read full frame for processing by a certain thread.

If there are already any full frames queued, they are sorted by sequence number.

Definition at line 9924 of file chan_iax2.c.

{
    struct iax2_pkt_buf *pkt_buf, *cur_pkt_buf;
    struct ast_iax2_full_hdr *fh, *cur_fh;
 
    if (!(pkt_buf = ast_calloc(1, sizeof(*pkt_buf) + from_here->buf_len)))
        return;
 
    pkt_buf->len = from_here->buf_len;
    memcpy(pkt_buf->buf, from_here->buf, pkt_buf->len);
 
    fh = (struct ast_iax2_full_hdr *) pkt_buf->buf;
    ast_mutex_lock(&to_here->lock);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&to_here->full_frames, cur_pkt_buf, entry) {
        cur_fh = (struct ast_iax2_full_hdr *) cur_pkt_buf->buf;
        if (fh->oseqno < cur_fh->oseqno) {
            AST_LIST_INSERT_BEFORE_CURRENT(pkt_buf, entry);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END
 
    if (!cur_pkt_buf)
        AST_LIST_INSERT_TAIL(&to_here->full_frames, pkt_buf, entry);
 
    to_here->iostate = IAX_IOSTATE_READY;
    ast_cond_signal(&to_here->cond);
 
    ast_mutex_unlock(&to_here->lock);
}

References ast_calloc, ast_cond_signal, AST_LIST_INSERT_BEFORE_CURRENT, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_mutex_lock, ast_mutex_unlock, iax2_pkt_buf::buf, iax2_thread::buf, iax2_thread::buf_len, iax2_thread::cond, iax2_thread::full_frames, IAX_IOSTATE_READY, if(), iax2_thread::iostate, iax2_pkt_buf::len, iax2_thread::lock, and ast_iax2_full_hdr::oseqno.

Referenced by socket_read().

delete_users()

static void delete_users ( void  )

static

Definition at line 13619 of file chan_iax2.c.

{
    struct iax2_registry *reg;
 
    ao2_callback(users, OBJ_NODATA, user_delme_cb, NULL);
 
    AST_LIST_LOCK(&registrations);
    while ((reg = AST_LIST_REMOVE_HEAD(&registrations, entry))) {
        if (sched) {
            AST_SCHED_DEL(sched, reg->expire);
        }
        if (reg->callno) {
            int callno = reg->callno;
            ast_mutex_lock(&iaxsl[callno]);
            if (iaxs[callno]) {
                iaxs[callno]->reg = NULL;
                iax2_destroy(callno);
            }
            ast_mutex_unlock(&iaxsl[callno]);
        }
        if (reg->dnsmgr)
            ast_dnsmgr_release(reg->dnsmgr);
        ast_free(reg);
    }
    AST_LIST_UNLOCK(&registrations);
 
    ao2_callback(peers, OBJ_NODATA, peer_delme_cb, NULL);
}

References ao2_callback, ast_dnsmgr_release(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, AST_SCHED_DEL, iax2_registry::callno, iax2_registry::dnsmgr, iax2_registry::entry, iax2_registry::expire, iax2_destroy(), iaxs, iaxsl, NULL, OBJ_NODATA, peer_delme_cb(), chan_iax2_pvt::reg, and user_delme_cb().

Referenced by __unload_module(), and set_config_destroy().

dp_lookup()

static void dp_lookup ( int  callno, const char *  context, const char *  callednum, const char *  callerid, int  skiplock  )

static

Definition at line 9720 of file chan_iax2.c.

{
    unsigned short dpstatus = 0;
    struct iax_ie_data ied1;
    int mm;
 
    memset(&ied1, 0, sizeof(ied1));
    mm = ast_matchmore_extension(NULL, context, callednum, 1, callerid);
    /* Must be started */
    if (ast_exists_extension(NULL, context, callednum, 1, callerid)) {
        dpstatus = IAX_DPSTATUS_EXISTS;
    } else if (ast_canmatch_extension(NULL, context, callednum, 1, callerid)) {
        dpstatus = IAX_DPSTATUS_CANEXIST;
    } else {
        dpstatus = IAX_DPSTATUS_NONEXISTENT;
    }
    if (ast_ignore_pattern(context, callednum))
        dpstatus |= IAX_DPSTATUS_IGNOREPAT;
    if (mm)
        dpstatus |= IAX_DPSTATUS_MATCHMORE;
    if (!skiplock)
        ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        iax_ie_append_str(&ied1, IAX_IE_CALLED_NUMBER, callednum);
        iax_ie_append_short(&ied1, IAX_IE_DPSTATUS, dpstatus);
        iax_ie_append_short(&ied1, IAX_IE_REFRESH, iaxdefaultdpcache);
        send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREP, 0, ied1.buf, ied1.pos, -1);
    }
    if (!skiplock)
        ast_mutex_unlock(&iaxsl[callno]);
}

References ast_canmatch_extension(), ast_exists_extension(), AST_FRAME_IAX, ast_ignore_pattern(), ast_matchmore_extension(), ast_mutex_lock, ast_mutex_unlock, iax_ie_data::buf, voicemailpwcheck::context, IAX_COMMAND_DPREP, IAX_DPSTATUS_CANEXIST, IAX_DPSTATUS_EXISTS, IAX_DPSTATUS_IGNOREPAT, IAX_DPSTATUS_MATCHMORE, IAX_DPSTATUS_NONEXISTENT, iax_ie_append_short(), iax_ie_append_str(), IAX_IE_CALLED_NUMBER, IAX_IE_DPSTATUS, IAX_IE_REFRESH, iaxdefaultdpcache, iaxs, iaxsl, NULL, iax_ie_data::pos, and send_command().

Referenced by dp_lookup_thread(), and socket_process_helper().

dp_lookup_thread()

static void * dp_lookup_thread ( void *  data )

static

Definition at line 9752 of file chan_iax2.c.

{
    /* Look up for dpreq */
    struct dpreq_data *dpr = data;
    dp_lookup(dpr->callno, dpr->context, dpr->callednum, dpr->callerid, 0);
    if (dpr->callerid)
        ast_free(dpr->callerid);
    ast_free(dpr);
    return NULL;
}

References ast_free, dpreq_data::callednum, dpreq_data::callerid, dpreq_data::callno, dpreq_data::context, dp_lookup(), and NULL.

Referenced by spawn_dp_lookup().

encmethods_to_str()

static void encmethods_to_str ( int  e, struct ast_str **  buf  )

static

Definition at line 1823 of file chan_iax2.c.

{
    ast_str_set(buf, 0, "(");
    if (e & IAX_ENCRYPT_AES128) {
        ast_str_append(buf, 0, "aes128");
    }
    if (e & IAX_ENCRYPT_KEYROTATE) {
        ast_str_append(buf, 0, ",keyrotate");
    }
    if (ast_str_strlen(*buf) > 1) {
        ast_str_append(buf, 0, ")");
    } else {
        ast_str_set(buf, 0, "No");
    }
}

References ast_str_append(), ast_str_set(), ast_str_strlen(), buf, IAX_ENCRYPT_AES128, and IAX_ENCRYPT_KEYROTATE.

Referenced by _iax2_show_peers_one(), and handle_cli_iax2_show_peer().

encrypt_frame()

static int encrypt_frame ( ast_aes_encrypt_key *  ecx, struct ast_iax2_full_hdr *  fh, unsigned char *  poo, int *  datalen  )

static

Definition at line 6616 of file chan_iax2.c.

{
    int padding;
    unsigned char *workspace;
    workspace = ast_alloca(*datalen + 32);
    if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
        struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
        if (iaxdebug)
            ast_debug(1, "Encoding full frame %d/%d with length %d\n", fh->type, fh->csub, *datalen);
        padding = 16 - ((*datalen - sizeof(struct ast_iax2_full_enc_hdr)) % 16);
        padding = 16 + (padding & 0xf);
        memcpy(workspace, poo, padding);
        memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
        workspace[15] &= 0xf0;
        workspace[15] |= (padding & 0xf);
        if (iaxdebug)
            ast_debug(1, "Encoding full frame %d/%d with length %d + %d padding (15=%02hhx)\n", fh->type, fh->csub, *datalen, padding, workspace[15]);
        *datalen += padding;
        memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_full_enc_hdr), ecx);
        if (*datalen >= 32 + sizeof(struct ast_iax2_full_enc_hdr))
            memcpy(poo, workspace + *datalen - 32, 32);
    } else {
        struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
        if (iaxdebug)
            ast_debug(5, "Encoding mini frame with length %d\n", *datalen);
        padding = 16 - ((*datalen - sizeof(struct ast_iax2_mini_enc_hdr)) % 16);
        padding = 16 + (padding & 0xf);
        memcpy(workspace, poo, padding);
        memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
        workspace[15] &= 0xf0;
        workspace[15] |= (padding & 0x0f);
        *datalen += padding;
        memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), ecx);
        if (*datalen >= 32 + sizeof(struct ast_iax2_mini_enc_hdr))
            memcpy(poo, workspace + *datalen - 32, 32);
    }
    return 0;
}

References ast_alloca, ast_debug, ast_iax2_full_hdr::csub, ast_iax2_full_enc_hdr::encdata, ast_iax2_mini_enc_hdr::encdata, IAX_FLAG_FULL, iaxdebug, memcpy_encrypt(), ast_iax2_full_hdr::scallno, and ast_iax2_full_hdr::type.

Referenced by iax2_send(), and update_packet().

expire_registry()

static int expire_registry ( const void *  data )

static

Definition at line 9121 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__expire_registry, data))
#endif
        __expire_registry(data);
    return 0;
}

References __expire_registry(), and schedule_action.

Referenced by handle_cli_iax2_prune_realtime(), handle_cli_iax2_unregister(), realtime_peer(), reg_source_db(), and update_registry().

find_cache()

static struct iax2_dpcache * find_cache ( struct ast_channel *  chan, const char *  data, const char *  context, const char *  exten, int  priority  )

static

Definition at line 14357 of file chan_iax2.c.

{
    struct iax2_dpcache *dp = NULL;
    struct timeval now = ast_tvnow();
    int x, com[2], timeout, doabort, callno;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, cache_list) {
        if (ast_tvcmp(now, dp->expiry) > 0) {
            AST_LIST_REMOVE_CURRENT(cache_list);
            if ((dp->flags & CACHE_FLAG_PENDING) || dp->callno)
                ast_log(LOG_WARNING, "DP still has peer field or pending or callno (flags = %d, peer = blah, callno = %d)\n", dp->flags, dp->callno);
            else
                ast_free(dp);
            continue;
        }
        if (!strcmp(dp->peercontext, data) && !strcmp(dp->exten, exten))
            break;
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (!dp) {
        /* No matching entry.  Create a new one. */
        /* First, can we make a callno? */
        if ((callno = cache_get_callno_locked(data)) < 0) {
            ast_log(LOG_WARNING, "Unable to generate call for '%s'\n", data);
            return NULL;
        }
        if (!(dp = ast_calloc(1, sizeof(*dp)))) {
            ast_mutex_unlock(&iaxsl[callno]);
            return NULL;
        }
        ast_copy_string(dp->peercontext, data, sizeof(dp->peercontext));
        ast_copy_string(dp->exten, exten, sizeof(dp->exten));
        dp->expiry = ast_tvnow();
        dp->orig = dp->expiry;
        /* Expires in 30 mins by default */
        dp->expiry.tv_sec += iaxdefaultdpcache;
        dp->flags = CACHE_FLAG_PENDING;
        for (x = 0; x < ARRAY_LEN(dp->waiters); x++)
            dp->waiters[x] = -1;
        /* Insert into the lists */
        AST_LIST_INSERT_TAIL(&dpcache, dp, cache_list);
        AST_LIST_INSERT_TAIL(&iaxs[callno]->dpentries, dp, peer_list);
        /* Send the request if we're already up */
        if (ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
            iax2_dprequest(dp, callno);
        ast_mutex_unlock(&iaxsl[callno]);
    }
 
    /* By here we must have a dp */
    if (dp->flags & CACHE_FLAG_PENDING) {
        int res;
        struct pollfd pfd;
        /* Okay, here it starts to get nasty.  We need a pipe now to wait
           for a reply to come back so long as it's pending */
        for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
            /* Find an empty slot */
            if (dp->waiters[x] < 0)
                break;
        }
        if (x >= ARRAY_LEN(dp->waiters)) {
            ast_log(LOG_WARNING, "No more waiter positions available\n");
            return NULL;
        }
        if (pipe(com)) {
            ast_log(LOG_WARNING, "Unable to create pipe for comm\n");
            return NULL;
        }
        dp->waiters[x] = com[1];
        /* Okay, now we wait */
        timeout = iaxdefaulttimeout * 1000;
        /* Temporarily unlock */
        AST_LIST_UNLOCK(&dpcache);
        doabort = 0;
 
        /* chan is in autoservice here, so do NOT service it here! */
        pfd.fd = com[0];
        pfd.events = POLLIN;
        pfd.revents = 0;
        /* Wait for pipe activity... if the channel hangs up, we'll catch it on the way out. */
        res = ast_poll(&pfd, 1, timeout);
        if (res < 0) {
            ast_log(LOG_WARNING, "poll returned < 0: %s\n", strerror(errno));
            return NULL;
        } else if (!pfd.revents) {
            ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten);
        }
 
        if (chan && ast_check_hangup(chan)) {
            doabort = 1;
        }
 
        AST_LIST_LOCK(&dpcache);
        dp->waiters[x] = -1;
        close(com[1]);
        close(com[0]);
        if (doabort) {
            /* Don't interpret anything, just abort. */
            return NULL;
        }
        if (!(dp->flags & CACHE_FLAG_TIMEOUT)) {
            /* Now to do non-independent analysis the results of our wait */
            if (dp->flags & CACHE_FLAG_PENDING) {
                /* Still pending... It's a timeout.  Wake everybody up.  Consider it no longer
                   pending.  Don't let it take as long to timeout. */
                dp->flags &= ~CACHE_FLAG_PENDING;
                dp->flags |= CACHE_FLAG_TIMEOUT;
                /* Expire after only 60 seconds now.  This is designed to help reduce backlog in heavily loaded
                   systems without leaving it unavailable once the server comes back online */
                dp->expiry.tv_sec = dp->orig.tv_sec + 60;
                for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
                    if (dp->waiters[x] > -1) {
                        if (write(dp->waiters[x], "asdf", 4) < 0) {
                            ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
                        }
                    }
                }
            }
        }
        /* Our caller will obtain the rest */
    }
    return dp;
}

References ARRAY_LEN, ast_calloc, ast_check_hangup(), ast_copy_string(), ast_free, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log, ast_mutex_unlock, ast_poll, ast_test_flag, ast_tvcmp(), ast_tvnow(), CACHE_FLAG_PENDING, CACHE_FLAG_TIMEOUT, cache_get_callno_locked(), iax2_dpcache::callno, errno, iax2_dpcache::expiry, iax2_dpcache::exten, iax2_dpcache::flags, iax2_dprequest(), IAX_STATE_STARTED, iaxdefaultdpcache, iaxdefaulttimeout, iaxs, iaxsl, LOG_WARNING, NULL, iax2_dpcache::orig, iax2_dpcache::peercontext, and iax2_dpcache::waiters.

Referenced by iax2_canmatch(), iax2_exec(), iax2_exists(), and iax2_matchmore().

find_callno()

static int find_callno ( unsigned short  callno, unsigned short  dcallno, struct ast_sockaddr *  addr, int  new, int  sockfd, int  full_frame  )

static

Definition at line 3307 of file chan_iax2.c.

                                                                                                                                      {
    return __find_callno(callno, dcallno, addr, new, sockfd, 0, full_frame);
}

References __find_callno(), chan_iax2_pvt::addr, chan_iax2_pvt::callno, and chan_iax2_pvt::sockfd.

Referenced by iax2_poke_peer(), and socket_process_helper().

find_callno_locked()

static int find_callno_locked ( unsigned short  callno, unsigned short  dcallno, struct ast_sockaddr *  addr, int  new, int  sockfd, int  full_frame  )

static

Definition at line 3311 of file chan_iax2.c.

                                                                                                                                             {
 
    return __find_callno(callno, dcallno, addr, new, sockfd, 1, full_frame);
}

References __find_callno(), chan_iax2_pvt::addr, chan_iax2_pvt::callno, and chan_iax2_pvt::sockfd.

Referenced by cache_get_callno_locked(), iax2_do_register(), iax2_provision(), iax2_request(), and socket_process_meta().

find_idle_thread()

static struct iax2_thread * find_idle_thread ( void  )

static

Definition at line 1658 of file chan_iax2.c.

{
    struct iax2_thread *thread = NULL;
 
    /* Pop the head of the idle list off */
    AST_LIST_LOCK(&idle_list);
    thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
    AST_LIST_UNLOCK(&idle_list);
 
    /* If we popped a thread off the idle list, just return it */
    if (thread) {
        memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
        return thread;
    }
 
    /* Pop the head of the dynamic list off */
    AST_LIST_LOCK(&dynamic_list);
    thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
    AST_LIST_UNLOCK(&dynamic_list);
 
    /* If we popped a thread off the dynamic list, just return it */
    if (thread) {
        memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
        return thread;
    }
 
    /* If we can't create a new dynamic thread for any reason, return no thread at all */
    if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
        return NULL;
 
    /* Set default values */
    ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
    thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
    thread->type = IAX_THREAD_TYPE_DYNAMIC;
 
    /* Initialize lock and condition */
    ast_mutex_init(&thread->lock);
    ast_cond_init(&thread->cond, NULL);
    ast_mutex_init(&thread->init_lock);
    ast_cond_init(&thread->init_cond, NULL);
    ast_mutex_lock(&thread->init_lock);
 
    /* Create thread and send it on it's way */
    if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
        ast_cond_destroy(&thread->cond);
        ast_mutex_destroy(&thread->lock);
        ast_mutex_unlock(&thread->init_lock);
        ast_cond_destroy(&thread->init_cond);
        ast_mutex_destroy(&thread->init_lock);
        ast_free(thread);
        return NULL;
    }
 
    /* this thread is not processing a full frame (since it is idle),
       so ensure that the field for the full frame call number is empty */
    memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
 
    /* Wait for the thread to be ready before returning it to the caller */
    ast_cond_wait(&thread->init_cond, &thread->init_lock);
 
    /* Done with init_lock */
    ast_mutex_unlock(&thread->init_lock);
 
    return thread;
}

References ast_atomic_fetchadd_int(), ast_calloc, ast_cond_destroy, ast_cond_init, ast_cond_wait, ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_background, iax2_process_thread(), IAX_THREAD_TYPE_DYNAMIC, iaxdynamicthreadcount, iaxdynamicthreadnum, iaxmaxthreadcount, iax2_thread::list, NULL, and thread.

Referenced by __schedule_action(), and socket_read().

find_peer()

static struct iax2_peer * find_peer ( const char *  name, int  realtime  )

static

Note

This function calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno, so do not call it with a pvt lock held.

Definition at line 2082 of file chan_iax2.c.

{
    struct iax2_peer *peer = NULL;
 
    peer = ao2_find(peers, name, OBJ_KEY);
 
    /* Now go for realtime if applicable */
    if (!peer && realtime) {
        peer = realtime_peer(name, NULL);
    }
    return peer;
}

References ao2_find, name, NULL, OBJ_KEY, and realtime_peer().

Referenced by ast_iax2_new(), calltoken_required(), create_addr(), function_iaxpeer(), handle_cli_iax2_prune_realtime(), handle_cli_iax2_set_debug(), handle_cli_iax2_show_peer(), handle_cli_iax2_unregister(), iax2_devicestate(), register_verify(), registry_authrequest(), requirecalltoken_mark_auto(), and update_registry().

find_tpeer()

static struct iax2_trunk_peer * find_tpeer ( struct ast_sockaddr *  addr, int  fd  )

static

Definition at line 6364 of file chan_iax2.c.

{
    struct iax2_trunk_peer *tpeer = NULL;
 
    /* Finds and locks trunk peer */
    AST_LIST_LOCK(&tpeers);
 
    AST_LIST_TRAVERSE(&tpeers, tpeer, list) {
        if (!ast_sockaddr_cmp(&tpeer->addr, addr)) {
            ast_mutex_lock(&tpeer->lock);
            break;
        }
    }
 
    if (!tpeer) {
        if ((tpeer = ast_calloc(1, sizeof(*tpeer)))) {
            ast_mutex_init(&tpeer->lock);
            tpeer->lastsent = 9999;
            ast_sockaddr_copy(&tpeer->addr, addr);
            tpeer->trunkact = ast_tvnow();
            ast_mutex_lock(&tpeer->lock);
            tpeer->sockfd = fd;
 
#ifdef SO_NO_CHECK
            setsockopt(tpeer->sockfd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
#endif
            ast_debug(1, "Created trunk peer for '%s'\n", ast_sockaddr_stringify(&tpeer->addr));
            AST_LIST_INSERT_TAIL(&tpeers, tpeer, list);
        }
    }
 
    AST_LIST_UNLOCK(&tpeers);
 
    return tpeer;
}

References iax2_trunk_peer::addr, ast_calloc, ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_init, ast_mutex_lock, ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_stringify(), ast_tvnow(), iax2_trunk_peer::lastsent, iax2_trunk_peer::list, iax2_trunk_peer::lock, NULL, iax2_trunk_peer::sockfd, and iax2_trunk_peer::trunkact.

Referenced by iax2_trunk_queue(), and socket_process_meta().

find_user()

static struct iax2_user * find_user ( const char *  name )

static

Definition at line 2107 of file chan_iax2.c.

{
    return ao2_find(users, name, OBJ_KEY);
}

References ao2_find, name, and OBJ_KEY.

Referenced by calltoken_required(), handle_cli_iax2_prune_realtime(), and requirecalltoken_mark_auto().

firmware_show_callback()

static int firmware_show_callback ( struct ast_iax2_firmware_header *  header, void *  user_data  )

static

Definition at line 7345 of file chan_iax2.c.

{
    int *fd = user_data;
 
    ast_cli(*fd, "%-15.15s  %-15d %-15d\n",
        header->devname,
        ntohs(header->version),
        (int) ntohl(header->datalen));
 
    return 0;
}

References ast_cli().

Referenced by handle_cli_iax2_show_firmware().

fix_peerts()

static unsigned int fix_peerts ( struct timeval *  rxtrunktime, int  callno, unsigned int  ts  )

static

Definition at line 6174 of file chan_iax2.c.

{
    long ms;    /* NOT unsigned */
    if (ast_tvzero(iaxs[callno]->rxcore)) {
        /* Initialize rxcore time if appropriate */
        iaxs[callno]->rxcore = ast_tvnow();
        /* Round to nearest 20ms so traces look pretty */
        iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
    }
    /* Calculate difference between trunk and channel */
    ms = ast_tvdiff_ms(*rxtrunktime, iaxs[callno]->rxcore);
    /* Return as the sum of trunk time and the difference between trunk and real time */
    return ms + ts;
}

References ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), iaxs, and chan_iax2_pvt::rxcore.

Referenced by socket_process_meta().

free_context()

static void free_context ( struct iax2_context *  con )

static

Definition at line 12666 of file chan_iax2.c.

{
    struct iax2_context *conl;
    while(con) {
        conl = con;
        con = con->next;
        ast_free(conl);
    }
}

References ast_free, and iax2_context::next.

Referenced by build_user(), and user_destructor().

free_signaling_queue_entry()

static void free_signaling_queue_entry ( struct signaling_queue_entry *  s )

static

Definition at line 2221 of file chan_iax2.c.

{
    if (s->f.datalen) {
        ast_free(s->f.data.ptr);
    }
    ast_free(s);
}

References ast_free, ast_frame::data, ast_frame::datalen, signaling_queue_entry::f, and ast_frame::ptr.

Referenced by pvt_destructor(), queue_signalling(), and send_signaling().

function_iaxpeer()

static int function_iaxpeer ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 14602 of file chan_iax2.c.

{
    struct iax2_peer *peer;
    char *peername, *colname;
 
    peername = ast_strdupa(data);
 
    /* if our channel, return the IP address of the endpoint of current channel */
    if (!strcmp(peername,"CURRENTCHANNEL")) {
            unsigned short callno;
        if (!chan || ast_channel_tech(chan) != &iax2_tech) {
            return -1;
        }
        callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
        ast_copy_string(buf, !ast_sockaddr_isnull(&iaxs[callno]->addr) ? ast_sockaddr_stringify_addr(&iaxs[callno]->addr) : "", len);
        return 0;
    }
 
    if ((colname = strchr(peername, ',')))
        *colname++ = '\0';
    else
        colname = "ip";
 
    if (!(peer = find_peer(peername, 1)))
        return -1;
 
    if (!strcasecmp(colname, "ip")) {
        ast_copy_string(buf, ast_sockaddr_stringify_addr(&peer->addr), len);
    } else  if (!strcasecmp(colname, "status")) {
        peer_status(peer, buf, len);
    } else  if (!strcasecmp(colname, "mailbox")) {
        ast_copy_string(buf, peer->mailbox, len);
    } else  if (!strcasecmp(colname, "context")) {
        ast_copy_string(buf, peer->context, len);
    } else  if (!strcasecmp(colname, "expire")) {
        snprintf(buf, len, "%d", peer->expire);
    } else  if (!strcasecmp(colname, "dynamic")) {
        ast_copy_string(buf, (ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no"), len);
    } else  if (!strcasecmp(colname, "callerid_name")) {
        ast_copy_string(buf, peer->cid_name, len);
    } else  if (!strcasecmp(colname, "callerid_num")) {
        ast_copy_string(buf, peer->cid_num, len);
    } else  if (!strcasecmp(colname, "codecs")) {
        struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
        iax2_getformatname_multiple(peer->capability, &codec_buf);
        ast_copy_string(buf, ast_str_buffer(codec_buf), len);
    } else  if (!strncasecmp(colname, "codec[", 6)) {
        char *codecnum, *ptr;
        struct ast_format *tmpfmt;
 
        /* skip over "codec" to the '[' */
        codecnum = colname + 5;
        *codecnum = '\0';
        codecnum++;
        if ((ptr = strchr(codecnum, ']'))) {
            *ptr = '\0';
        }
        if((iax2_codec_pref_index(&peer->prefs, atoi(codecnum), &tmpfmt))) {
            ast_copy_string(buf, ast_format_get_name(tmpfmt), len);
        } else {
            buf[0] = '\0';
        }
    } else {
        buf[0] = '\0';
    }
 
    peer_unref(peer);
 
    return 0;
}

References iax2_peer::addr, ast_channel_tech(), ast_channel_tech_pvt(), ast_copy_string(), AST_FORMAT_CAP_NAMES_LEN, ast_format_get_name(), ast_sockaddr_isnull(), ast_sockaddr_stringify_addr(), ast_str_alloca, ast_str_buffer(), ast_strdupa, ast_test_flag64, buf, iax2_peer::callno, iax2_peer::capability, iax2_peer::cid_name, iax2_peer::cid_num, iax2_peer::context, iax2_peer::expire, find_peer(), iax2_codec_pref_index(), iax2_getformatname_multiple(), iax2_tech, IAX_DYNAMIC, iaxs, len(), iax2_peer::mailbox, peer_status(), peer_unref(), iax2_peer::prefs, and PTR_TO_CALLNO.

get_auth_methods()

static int get_auth_methods ( const char *  value )

static

Definition at line 12875 of file chan_iax2.c.

{
    int methods = 0;
    if (strstr(value, "rsa"))
        methods |= IAX_AUTH_RSA;
    if (strstr(value, "md5"))
        methods |= IAX_AUTH_MD5;
    if (strstr(value, "plaintext"))
        methods |= IAX_AUTH_PLAINTEXT;
    return methods;
}

References IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, methods, and value.

Referenced by build_peer(), build_user(), and set_config().

get_encrypt_methods()

static int get_encrypt_methods ( const char *  s )

static

Definition at line 1839 of file chan_iax2.c.

{
    int e;
    if (!strcasecmp(s, "aes128"))
        e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
    else if (ast_true(s))
        e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
    else
        e = 0;
    return e;
}

References ast_true(), IAX_ENCRYPT_AES128, and IAX_ENCRYPT_KEYROTATE.

Referenced by build_peer(), build_user(), and set_config().

get_from_jb()

static int get_from_jb ( const void *  p )

static

Definition at line 4301 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__get_from_jb, data))
#endif
        __get_from_jb(data);
    return 0;
}

References __get_from_jb(), ast_frame::data, and schedule_action.

Referenced by update_jbsched().

get_unused_callno()

static int get_unused_callno ( enum callno_type  type, int  validated, callno_entry *  entry  )

static

Definition at line 2978 of file chan_iax2.c.

{
    struct call_number_pool *pool = NULL;
    callno_entry swap;
    size_t choice;
 
    switch (type) {
    case CALLNO_TYPE_NORMAL:
        pool = &callno_pool;
        break;
    case CALLNO_TYPE_TRUNK:
        pool = &callno_pool_trunk;
        break;
    default:
        ast_assert(0);
        break;
    }
 
    /* If we fail, make sure this has a defined value */
    *entry = 0;
 
    /* We lock here primarily to ensure thread safety of the
     * total_nonval_callno_used check and increment */
    ast_mutex_lock(&callno_pool_lock);
 
    /* Bail out if we don't have any available call numbers */
    if (!pool->available) {
        ast_log(LOG_WARNING, "Out of call numbers\n");
        ast_mutex_unlock(&callno_pool_lock);
        return 1;
    }
 
    /* Only a certain number of non-validated call numbers should be allocated.
     * If there ever is an attack, this separates the calltoken validating users
     * from the non-calltoken validating users. */
    if (!validated && total_nonval_callno_used >= global_maxcallno_nonval) {
        ast_log(LOG_WARNING,
            "NON-CallToken callnumber limit is reached. Current: %d Max: %d\n",
            total_nonval_callno_used,
            global_maxcallno_nonval);
        ast_mutex_unlock(&callno_pool_lock);
        return 1;
    }
 
    /* We use a modified Fisher-Yates-Durstenfeld Shuffle to maintain a list of
     * available call numbers.  The array of call numbers begins as an ordered
     * list from 1 -> n, and we keep a running tally of how many remain unclaimed
     * - let's call that x.  When a call number is needed we pick a random index
     * into the array between 0 and x and use that as our call number.  In a
     * typical FYD shuffle, we would swap the value that we are extracting with
     * the number at x, but in our case we swap and don't touch the value at x
     * because it is effectively invisible.  We rely on the rest of the IAX2 core
     * to return the number to us at some point.  Finally, we decrement x by 1
     * which establishes our new unused range.
     *
     * When numbers are returned to the pool, we put them just past x and bump x
     * by 1 so that this number is now available for re-use. */
 
    choice = ast_random() % pool->available;
 
    *entry = pool->numbers[choice];
    swap = pool->numbers[pool->available - 1];
 
    pool->numbers[choice] = swap;
    pool->available--;
 
    if (validated) {
        CALLNO_ENTRY_SET_VALIDATED(*entry);
    } else {
        total_nonval_callno_used++;
    }
 
    ast_mutex_unlock(&callno_pool_lock);
 
    return 0;
}

References ast_assert, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_random(), call_number_pool::available, CALLNO_ENTRY_SET_VALIDATED, callno_pool, callno_pool_lock, callno_pool_trunk, CALLNO_TYPE_NORMAL, CALLNO_TYPE_TRUNK, global_maxcallno_nonval, LOG_WARNING, NULL, call_number_pool::numbers, total_nonval_callno_used, and type.

Referenced by __find_callno(), and make_trunk().

handle_call_token()

static int handle_call_token ( struct ast_iax2_full_hdr *  fh, struct iax_ies *  ies, struct ast_sockaddr *  addr, int  fd  )

static

Definition at line 5030 of file chan_iax2.c.

{
#define CALLTOKEN_HASH_FORMAT "%s%u%d"  /* address + port + ts + randomcalldata */
#define CALLTOKEN_IE_FORMAT   "%u?%s"     /* time + ? + (40 char hash) */
    struct ast_str *buf = ast_str_alloca(256);
    time_t t = time(NULL);
    char hash[41]; /* 40 char sha1 hash */
    int subclass = uncompress_subclass(fh->csub);
 
    /* ----- Case 1 ----- */
    if (ies->calltoken && !ies->calltokendata) {  /* empty calltoken is provided, client supports calltokens */
        struct iax_ie_data ied = {
            .buf = { 0 },
            .pos = 0,
        };
 
        /* create the hash with their address data and our timestamp */
        ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) t, randomcalltokendata);
        ast_sha1_hash(hash, ast_str_buffer(buf));
 
        ast_str_set(&buf, 0, CALLTOKEN_IE_FORMAT, (unsigned int) t, hash);
        iax_ie_append_str(&ied, IAX_IE_CALLTOKEN, ast_str_buffer(buf));
        send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_CALLTOKEN, ntohl(fh->ts), fh->iseqno + 1, fd, &ied);
 
        return 1;
 
    /* ----- Case 2 ----- */
    } else if (ies->calltoken && ies->calltokendata) { /* calltoken received, check to see if it is valid */
        char *rec_hash = NULL;    /* the received hash, make sure it matches with ours. */
        char *rec_ts = NULL;      /* received timestamp */
        unsigned int rec_time;  /* received time_t */
 
        /* split the timestamp from the hash data */
        rec_hash = strchr((char *) ies->calltokendata, '?');
        if (rec_hash) {
            *rec_hash++ = '\0';
            rec_ts = (char *) ies->calltokendata;
        }
 
        /* check that we have valid data before we do any comparisons */
        if (!rec_hash || !rec_ts) {
            goto reject;
        } else if (sscanf(rec_ts, "%u", &rec_time) != 1) {
            goto reject;
        }
 
        /* create a hash with their address and the _TOKEN'S_ timestamp */
        ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) rec_time, randomcalltokendata);
        ast_sha1_hash(hash, ast_str_buffer(buf));
 
        /* compare hashes and then check timestamp delay */
        if (strcmp(hash, rec_hash)) {
            ast_log(LOG_WARNING, "Address %s failed CallToken hash inspection\n", ast_sockaddr_stringify(addr));
            goto reject; /* received hash does not match ours, reject */
        } else if ((t < rec_time) || ((t - rec_time) >= max_calltoken_delay)) {
            ast_log(LOG_WARNING, "Too much delay in IAX2 calltoken timestamp from address %s\n", ast_sockaddr_stringify(addr));
            goto reject; /* too much delay, reject */
        }
 
        /* at this point the call token is valid, returning 0
         * will allow socket_process to continue as usual */
        requirecalltoken_mark_auto(ies->username, subclass);
        return 0;
 
    /* ----- Case 3 ----- */
    } else { /* calltokens are not supported for this client, how do we respond? */
        if (calltoken_required(addr, ies->username, subclass)) {
            ast_log(LOG_ERROR, "Call rejected, CallToken Support required. If unexpected, resolve by placing address %s in the calltokenoptional list or setting user %s requirecalltoken=no\n", ast_sockaddr_stringify(addr), S_OR(ies->username, "guest"));
            goto reject;
        }
        return 0; /* calltoken is not required for this addr, so permit it. */
    }
 
reject:
    /* received frame has failed calltoken inspection, send apathetic reject messages */
    if (subclass == IAX_COMMAND_REGREQ || subclass == IAX_COMMAND_REGREL) {
        send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
    } else {
        send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
    }
 
    return 1;
}

References ast_log, ast_sha1_hash(), ast_sockaddr_stringify(), ast_str_alloca, ast_str_buffer(), ast_str_set(), iax_ie_data::buf, buf, iax_ies::calltoken, CALLTOKEN_HASH_FORMAT, CALLTOKEN_IE_FORMAT, calltoken_required(), iax_ies::calltokendata, ast_iax2_full_hdr::csub, IAX_COMMAND_CALLTOKEN, IAX_COMMAND_REGREJ, IAX_COMMAND_REGREL, IAX_COMMAND_REGREQ, IAX_COMMAND_REJECT, iax_ie_append_str(), IAX_IE_CALLTOKEN, ast_iax2_full_hdr::iseqno, LOG_ERROR, LOG_WARNING, max_calltoken_delay, NULL, randomcalltokendata, requirecalltoken_mark_auto(), S_OR, ast_iax2_full_hdr::scallno, send_apathetic_reply(), ast_iax2_full_hdr::ts, uncompress_subclass(), and iax_ies::username.

Referenced by socket_process_helper().

handle_cli_iax2_provision()

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

static

Definition at line 12496 of file chan_iax2.c.

{
    int force = 0;
    int res;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 provision";
        e->usage =
            "Usage: iax2 provision <host> <template> [forced]\n"
            "       Provisions the given peer or IP address using a template\n"
            "       matching either 'template' or '*' if the template is not\n"
            "       found.  If 'forced' is specified, even empty provisioning\n"
            "       fields will be provisioned as empty fields.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 3)
            return iax_prov_complete_template(a->line, a->word, a->pos, a->n);
        return NULL;
    }
 
    if (a->argc < 4)
        return CLI_SHOWUSAGE;
    if (a->argc > 4) {
        if (!strcasecmp(a->argv[4], "forced"))
            force = 1;
        else
            return CLI_SHOWUSAGE;
    }
    res = iax2_provision(NULL, -1, a->argv[2], a->argv[3], force);
    if (res < 0)
        ast_cli(a->fd, "Unable to find peer/address '%s'\n", a->argv[2]);
    else if (res < 1)
        ast_cli(a->fd, "No template (including wildcard) matching '%s'\n", a->argv[3]);
    else
        ast_cli(a->fd, "Provisioning '%s' with template '%s'%s\n", a->argv[2], a->argv[3], force ? ", forced" : "");
    return CLI_SUCCESS;
}

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

handle_cli_iax2_prune_realtime()

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

static

Definition at line 3713 of file chan_iax2.c.

{
    struct iax2_peer *peer = NULL;
    struct iax2_user *user = NULL;
    static const char * const choices[] = { "all", NULL };
    char *cmplt;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 prune realtime";
        e->usage =
            "Usage: iax2 prune realtime [<peername>|all]\n"
            "       Prunes object(s) from the cache\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 3) {
            cmplt = ast_cli_complete(a->word, choices, a->n);
            if (!cmplt)
                cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
            return cmplt;
        }
        return NULL;
    }
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
    if (!strcmp(a->argv[3], "all")) {
        prune_users();
        prune_peers();
        ast_cli(a->fd, "Cache flushed successfully.\n");
        return CLI_SUCCESS;
    }
    peer = find_peer(a->argv[3], 0);
    user = find_user(a->argv[3]);
    if (peer || user) {
        if (peer) {
            if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
                ast_set_flag64(peer, IAX_RTAUTOCLEAR);
                expire_registry(peer_ref(peer));
                ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
            } else {
                ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
            }
            peer_unref(peer);
        }
        if (user) {
            if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
                ast_set_flag64(user, IAX_RTAUTOCLEAR);
                ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
            } else {
                ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
            }
            ao2_unlink(users,user);
            user_unref(user);
        }
    } else {
        ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
    }
 
    return CLI_SUCCESS;
}

References a, ao2_unlink, ast_cli(), ast_cli_complete(), ast_set_flag64, ast_test_flag64, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_iax2_peers(), expire_registry(), find_peer(), find_user(), IAX_RTAUTOCLEAR, IAX_RTCACHEFRIENDS, NULL, peer_ref(), peer_unref(), prune_peers(), prune_users(), ast_cli_entry::usage, and user_unref().

handle_cli_iax2_reload()

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

static

Definition at line 14261 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 reload";
        e->usage =
            "Usage: iax2 reload\n"
            "       Reloads IAX configuration from iax.conf\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    reload_config(0);
 
    return CLI_SUCCESS;
}

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

handle_cli_iax2_set_debug()

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

static

Definition at line 7724 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 set debug {on|off|peer}";
        e->usage =
            "Usage: iax2 set debug {on|off|peer peername}\n"
            "       Enables/Disables dumping of IAX packets for debugging purposes.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4 && !strcasecmp(a->argv[3], "peer"))
            return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
        return NULL;
    }
 
    if (a->argc < e->args  || a->argc > e->args + 1)
        return CLI_SHOWUSAGE;
 
    if (!strcasecmp(a->argv[3], "peer")) {
        struct iax2_peer *peer;
 
        if (a->argc != e->args + 1)
            return CLI_SHOWUSAGE;
 
        peer = find_peer(a->argv[4], 1);
 
        if (!peer) {
            ast_cli(a->fd, "IAX2 peer '%s' does not exist\n", a->argv[e->args-1]);
            return CLI_FAILURE;
        }
 
        ast_sockaddr_copy(&debugaddr, &peer->addr);
 
        ast_cli(a->fd, "IAX2 Debugging Enabled for IP: %s\n", ast_sockaddr_stringify_port(&debugaddr));
 
        ao2_ref(peer, -1);
    } else if (!strncasecmp(a->argv[3], "on", 2)) {
        iaxdebug = 1;
        ast_cli(a->fd, "IAX2 Debugging Enabled\n");
    } else {
        iaxdebug = 0;
        memset(&debugaddr, 0, sizeof(debugaddr));
        ast_cli(a->fd, "IAX2 Debugging Disabled\n");
    }
    return CLI_SUCCESS;
}

References a, iax2_peer::addr, ao2_ref, ast_cli_entry::args, ast_cli(), ast_sockaddr_copy(), ast_sockaddr_stringify_port(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_iax2_peers(), debugaddr, find_peer(), iaxdebug, NULL, and ast_cli_entry::usage.

handle_cli_iax2_set_debug_jb()

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

static

Definition at line 7797 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 set debug jb {on|off}";
        e->usage =
            "Usage: iax2 set debug jb {on|off}\n"
            "       Enables/Disables jitterbuffer debugging information\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
 
    if (!strncasecmp(a->argv[e->args -1], "on", 2)) {
        jb_setoutput(jb_error_output, jb_warning_output, jb_debug_output);
        ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Enabled\n");
    } else {
        jb_setoutput(jb_error_output, jb_warning_output, NULL);
        ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Disabled\n");
    }
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, jb_debug_output(), jb_error_output(), jb_setoutput(), jb_warning_output(), NULL, and ast_cli_entry::usage.

handle_cli_iax2_set_debug_trunk()

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

static

Definition at line 7771 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 set debug trunk {on|off}";
        e->usage =
            "Usage: iax2 set debug trunk {on|off}\n"
            "       Enables/Disables debugging of IAX trunking\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != e->args)
        return CLI_SHOWUSAGE;
 
    if (!strncasecmp(a->argv[e->args - 1], "on", 2)) {
        iaxtrunkdebug = 1;
        ast_cli(a->fd, "IAX2 Trunk Debugging Enabled\n");
    } else {
        iaxtrunkdebug = 0;
        ast_cli(a->fd, "IAX2 Trunk Debugging Disabled\n");
    }
    return CLI_SUCCESS;
}

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

handle_cli_iax2_set_mtu()

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

static

Set trunk MTU from CLI.

Definition at line 4033 of file chan_iax2.c.

{
    int mtuv;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 set mtu";
        e->usage =
            "Usage: iax2 set mtu <value>\n"
            "       Set the system-wide IAX IP mtu to <value> bytes net or\n"
            "       zero to disable. Disabling means that the operating system\n"
            "       must handle fragmentation of UDP packets when the IAX2 trunk\n"
            "       packet exceeds the UDP payload size. This is substantially\n"
            "       below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
            "       greater for G.711 samples.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
    if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
        mtuv = MAX_TRUNK_MTU;
    else
        mtuv = atoi(a->argv[3]);
 
    if (mtuv == 0) {
        ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
        global_max_trunk_mtu = 0;
        return CLI_SUCCESS;
    }
    if (mtuv < 172 || mtuv > 4000) {
        ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n");
        return CLI_SHOWUSAGE;
    }
    ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
    global_max_trunk_mtu = mtuv;
    return CLI_SUCCESS;
}

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

handle_cli_iax2_show_cache()

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

static

Definition at line 4074 of file chan_iax2.c.

{
    struct iax2_dpcache *dp = NULL;
    char tmp[1024], *pc = NULL;
    int s, x, y;
    struct timeval now = ast_tvnow();
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show cache";
        e->usage =
            "Usage: iax2 show cache\n"
            "       Display currently cached IAX Dialplan results.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    AST_LIST_LOCK(&dpcache);
 
    ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
 
    AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
        s = dp->expiry.tv_sec - now.tv_sec;
        tmp[0] = '\0';
        if (dp->flags & CACHE_FLAG_EXISTS)
            strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_NONEXISTENT)
            strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_CANEXIST)
            strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_PENDING)
            strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_TIMEOUT)
            strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_TRANSMITTED)
            strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_MATCHMORE)
            strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
        if (dp->flags & CACHE_FLAG_UNKNOWN)
            strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
        /* Trim trailing pipe */
        if (!ast_strlen_zero(tmp)) {
            tmp[strlen(tmp) - 1] = '\0';
        } else {
            ast_copy_string(tmp, "(none)", sizeof(tmp));
        }
        y = 0;
        pc = strchr(dp->peercontext, '@');
        if (!pc) {
            pc = dp->peercontext;
        } else {
            pc++;
        }
        for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
            if (dp->waiters[x] > -1)
                y++;
        }
        if (s > 0) {
            ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
        } else {
            ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
        }
    }
 
    AST_LIST_UNLOCK(&dpcache);
 
    return CLI_SUCCESS;
}

References a, ARRAY_LEN, ast_cli(), ast_copy_string(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_tvnow(), CACHE_FLAG_CANEXIST, CACHE_FLAG_EXISTS, CACHE_FLAG_MATCHMORE, CACHE_FLAG_NONEXISTENT, CACHE_FLAG_PENDING, CACHE_FLAG_TIMEOUT, CACHE_FLAG_TRANSMITTED, CACHE_FLAG_UNKNOWN, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, iax2_dpcache::expiry, iax2_dpcache::exten, iax2_dpcache::flags, NULL, iax2_dpcache::peercontext, ast_cli_entry::usage, and iax2_dpcache::waiters.

handle_cli_iax2_show_callno_limits()

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

static

Definition at line 2909 of file chan_iax2.c.

{
    struct ao2_iterator i;
    struct peercnt *peercnt;
    struct ast_sockaddr addr;
    int found = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show callnumber usage";
        e->usage =
            "Usage: iax2 show callnumber usage [IP address]\n"
            "       Shows current IP addresses which are consuming iax2 call numbers\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    case CLI_HANDLER:
        if (a->argc < 4 || a->argc > 5)
            return CLI_SHOWUSAGE;
 
        if (a->argc == 4) {
            ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
        }
 
        i = ao2_iterator_init(peercnts, 0);
        while ((peercnt = ao2_iterator_next(&i))) {
            ast_sockaddr_copy(&addr, &peercnt->addr);
 
            if (a->argc == 5) {
                if (!strcasecmp(a->argv[4], ast_sockaddr_stringify(&addr))) {
                    ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
                    ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
                    ao2_ref(peercnt, -1);
                    found = 1;
                    break;
                }
            } else {
                ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
            }
            ao2_ref(peercnt, -1);
        }
        ao2_iterator_destroy(&i);
 
        if (a->argc == 4) {
            size_t pool_avail = callno_pool.available;
            size_t trunk_pool_avail = callno_pool_trunk.available;
 
            ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
                             "Non-CallToken Validated Callno Used:   %d\n",
                global_maxcallno_nonval,
                total_nonval_callno_used);
 
            ast_cli(a->fd,   "Total Available Callno:                %zu\n"
                             "Regular Callno Available:              %zu\n"
                             "Trunk Callno Available:                %zu\n",
                pool_avail + trunk_pool_avail,
                pool_avail,
                trunk_pool_avail);
        } else if (a->argc == 5 && !found) {
            ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
        }
 
 
        return CLI_SUCCESS;
    default:
        return NULL;
    }
}

References a, peercnt::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli(), ast_sockaddr_copy(), ast_sockaddr_stringify(), call_number_pool::available, callno_pool, callno_pool_trunk, CLI_GENERATE, CLI_HANDLER, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, peercnt::cur, global_maxcallno_nonval, peercnt::limit, NULL, peercnts, total_nonval_callno_used, and ast_cli_entry::usage.

handle_cli_iax2_show_channels()

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

static

Definition at line 7551 of file chan_iax2.c.

{
#define FORMAT2 "%-20.20s  %-40.40s  %-10.10s  %-11.11s  %-11.11s  %-7.7s  %-6.6s  %-6.6s  %s  %s  %9s\n"
#define FORMAT  "%-20.20s  %-40.40s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  %-5.5dms  %-4.4dms  %-4.4dms  %-6.6s  %s%s  %3s%s\n"
#define FORMATB "%-20.20s  %-40.40s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  [Native Bridged to ID=%5.5d]\n"
    int x;
    int numchans = 0;
    char first_message[10] = { 0, };
    char last_message[10] = { 0, };
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show channels";
        e->usage =
            "Usage: iax2 show channels\n"
            "       Lists all currently active IAX channels.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, FORMAT2, "Channel", "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "JitBuf", "Format", "FirstMsg", "LastMsg");
    for (x = 0; x < ARRAY_LEN(iaxs); x++) {
        ast_mutex_lock(&iaxsl[x]);
        if (iaxs[x]) {
            int lag, jitter, localdelay;
            jb_info jbinfo;
            if (ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
                jb_getinfo(iaxs[x]->jb, &jbinfo);
                jitter = jbinfo.jitter;
                localdelay = jbinfo.current - jbinfo.min;
            } else {
                jitter = -1;
                localdelay = 0;
            }
 
            iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
            iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
            lag = iaxs[x]->remote_rr.delay;
            ast_cli(a->fd, FORMAT,
                iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
                ast_sockaddr_stringify_addr(&iaxs[x]->addr),
                S_OR(iaxs[x]->username, "(None)"),
                iaxs[x]->callno, iaxs[x]->peercallno,
                iaxs[x]->oseqno, iaxs[x]->iseqno,
                lag,
                jitter,
                localdelay,
                iax2_getformatname(iaxs[x]->voiceformat),
                (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                first_message,
                (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
                last_message);
            numchans++;
        }
        ast_mutex_unlock(&iaxsl[x]);
    }
    ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
    return CLI_SUCCESS;
#undef FORMAT
#undef FORMAT2
#undef FORMATB
}

References a, iax2_registry::addr, ARRAY_LEN, ast_channel_name(), ast_cli(), ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_stringify_addr(), ast_test_flag64, iax2_registry::callno, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, jb_info::current, iax_rr::delay, FORMAT, FORMAT2, iax2_getformatname(), iax_frame_subclass2str(), IAX_USEJITTERBUF, iaxs, iaxsl, jb_getinfo(), jb_info::jitter, MARK_IAX_SUBCLASS_TX, jb_info::min, NULL, chan_iax2_pvt::owner, chan_iax2_pvt::remote_rr, S_OR, ast_cli_entry::usage, and iax2_registry::username.

handle_cli_iax2_show_firmware()

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

static

Definition at line 7358 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show firmware";
        e->usage =
            "Usage: iax2 show firmware\n"
            "       Lists all known IAX firmware images.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3 && a->argc != 4)
        return CLI_SHOWUSAGE;
 
    ast_cli(a->fd, "%-15.15s  %-15.15s %-15.15s\n", "Device", "Version", "Size");
 
    iax_firmware_traverse(
        a->argc == 3 ? NULL : a->argv[3],
        firmware_show_callback,
        (void *) &a->fd);
 
    return CLI_SUCCESS;
}

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

handle_cli_iax2_show_netstats()

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

static

Definition at line 7701 of file chan_iax2.c.

{
    int numchans = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show netstats";
        e->usage =
            "Usage: iax2 show netstats\n"
            "       Lists network status for all currently active IAX channels.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, "                                -------- LOCAL ---------------------  -------- REMOTE --------------------\n");
    ast_cli(a->fd, "Channel                    RTT  Jit  Del  Lost   %%  Drop  OOO  Kpkts  Jit  Del  Lost   %%  Drop  OOO  Kpkts FirstMsg    LastMsg\n");
    numchans = ast_cli_netstats(NULL, a->fd, 1);
    ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
    return CLI_SUCCESS;
}

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

handle_cli_iax2_show_peer()

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

static

Show one peer in detail.

Definition at line 3888 of file chan_iax2.c.

{
    char status[64];
    char cbuf[256];
    struct iax2_peer *peer;
    struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
    struct ast_str *encmethods = ast_str_alloca(256);
    int load_realtime = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show peer";
        e->usage =
            "Usage: iax2 show peer <name>\n"
            "       Display details on specific IAX peer\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 3)
            return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
        return NULL;
    }
 
    if (a->argc < 4)
        return CLI_SHOWUSAGE;
 
    load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
 
    peer = find_peer(a->argv[3], load_realtime);
    if (peer) {
        char *str_addr, *str_defaddr;
        char *str_port, *str_defport;
 
        str_addr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
        str_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
        str_defaddr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->defaddr));
        str_defport = ast_strdupa(ast_sockaddr_stringify_port(&peer->defaddr));
 
        encmethods_to_str(peer->encmethods, &encmethods);
        ast_cli(a->fd, "\n\n");
        ast_cli(a->fd, "  * Name       : %s\n", peer->name);
        ast_cli(a->fd, "  Description  : %s\n", peer->description);
        ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
        ast_cli(a->fd, "  Context      : %s\n", peer->context);
        ast_cli(a->fd, "  Parking lot  : %s\n", peer->parkinglot);
        ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
        ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
        ast_cli(a->fd, "  Callnum limit: %d\n", peer->maxcallno);
        ast_cli(a->fd, "  Calltoken req: %s\n", (peer->calltoken_required == CALLTOKEN_YES) ? "Yes" : ((peer->calltoken_required == CALLTOKEN_AUTO) ? "Auto" : "No"));
        ast_cli(a->fd, "  Trunk        : %s\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
        ast_cli(a->fd, "  Encryption   : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
        ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
        ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
        ast_cli(a->fd, "  ACL          : %s\n", (ast_acl_list_is_empty(peer->acl) ? "No" : "Yes"));
        ast_cli(a->fd, "  Addr->IP     : %s Port %s\n",  str_addr ? str_addr : "(Unspecified)", str_port);
        ast_cli(a->fd, "  Defaddr->IP  : %s Port %s\n", str_defaddr, str_defport);
        ast_cli(a->fd, "  Username     : %s\n", peer->username);
        ast_cli(a->fd, "  Codecs       : %s\n", iax2_getformatname_multiple(peer->capability, &codec_buf));
 
        if (iax2_codec_pref_string(&peer->prefs, cbuf, sizeof(cbuf)) < 0) {
            strcpy(cbuf, "Error"); /* Safe */
        }
        ast_cli(a->fd, "  Codec Order  : %s\n", cbuf);
 
        peer_status(peer, status, sizeof(status));
        ast_cli(a->fd, "  Status       : %s\n", status);
        ast_cli(a->fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
        ast_cli(a->fd, "\n");
        peer_unref(peer);
    } else {
        ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
        ast_cli(a->fd, "\n");
    }
 
    return CLI_SUCCESS;
}

References a, iax2_peer::acl, iax2_peer::addr, ast_acl_list_is_empty(), ast_callerid_merge(), ast_cli(), AST_FORMAT_CAP_NAMES_LEN, ast_sockaddr_stringify_addr(), ast_sockaddr_stringify_port(), ast_str_alloca, ast_str_buffer(), ast_strdupa, ast_strlen_zero(), ast_test_flag64, CALLTOKEN_AUTO, iax2_peer::calltoken_required, CALLTOKEN_YES, iax2_peer::capability, iax2_peer::cid_name, iax2_peer::cid_num, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_iax2_peers(), iax2_peer::context, iax2_peer::defaddr, iax2_peer::description, iax2_peer::encmethods, encmethods_to_str(), iax2_peer::expire, find_peer(), iax2_codec_pref_string(), iax2_getformatname_multiple(), IAX_DYNAMIC, IAX_TRUNK, iax2_peer::mailbox, iax2_peer::maxcallno, iax2_peer::name, NULL, iax2_peer::parkinglot, peer_status(), peer_unref(), iax2_peer::pokefreqnotok, iax2_peer::pokefreqok, iax2_peer::prefs, iax2_peer::secret, iax2_peer::smoothing, status, ast_cli_entry::usage, and iax2_peer::username.

handle_cli_iax2_show_peers()

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

static

Definition at line 7313 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show peers";
        e->usage =
            "Usage: iax2 show peers [registered] [like <pattern>]\n"
            "       Lists all known IAX2 peers.\n"
            "       Optional 'registered' argument lists only peers with known addresses.\n"
            "       Optional regular expression pattern is used to filter the peer list.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    switch (__iax2_show_peers(a->fd, NULL, NULL, a->argc, a->argv)) {
    case RESULT_SHOWUSAGE:
        return CLI_SHOWUSAGE;
    case RESULT_FAILURE:
        return CLI_FAILURE;
    default:
        return CLI_SUCCESS;
    }
}

References __iax2_show_peers(), a, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, RESULT_FAILURE, RESULT_SHOWUSAGE, and ast_cli_entry::usage.

handle_cli_iax2_show_registry()

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

static

Definition at line 7468 of file chan_iax2.c.

{
#define FORMAT2 "%-45.45s  %-6.6s  %-10.10s  %-45.45s %8.8s  %s\n"
#define FORMAT  "%-45.45s  %-6.6s  %-10.10s  %-45.45s %8d  %s\n"
 
    struct iax2_registry *reg = NULL;
    char host[80];
    char perceived[80];
    int counter = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show registry";
        e->usage =
            "Usage: iax2 show registry\n"
            "       Lists all registration requests and status.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
    ast_cli(a->fd, FORMAT2, "Host", "dnsmgr", "Username", "Perceived", "Refresh", "State");
    AST_LIST_LOCK(&registrations);
    AST_LIST_TRAVERSE(&registrations, reg, entry) {
        snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
 
        snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
 
        ast_cli(a->fd, FORMAT, host,
                (reg->dnsmgr) ? "Y" : "N",
                reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
        counter++;
    }
    AST_LIST_UNLOCK(&registrations);
    ast_cli(a->fd, "%d IAX2 registrations.\n", counter);
    return CLI_SUCCESS;
#undef FORMAT
#undef FORMAT2
}

References a, iax2_registry::addr, ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_sockaddr_isnull(), ast_sockaddr_stringify(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, iax2_registry::dnsmgr, iax2_registry::entry, FORMAT, FORMAT2, NULL, iax2_registry::refresh, iax2_registry::regstate, regstate2str(), iax2_registry::us, ast_cli_entry::usage, and iax2_registry::username.

handle_cli_iax2_show_stats()

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

static

Definition at line 3987 of file chan_iax2.c.

{
    struct iax_frame *cur;
    int cnt = 0, dead = 0, final = 0, i = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show stats";
        e->usage =
            "Usage: iax2 show stats\n"
            "       Display statistics on IAX channel driver.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
 
    for (i = 0; i < ARRAY_LEN(frame_queue); i++) {
        ast_mutex_lock(&iaxsl[i]);
        AST_LIST_TRAVERSE(&frame_queue[i], cur, list) {
            if (cur->retries < 0)
                dead++;
            if (cur->final)
                final++;
            cnt++;
        }
        ast_mutex_unlock(&iaxsl[i]);
    }
 
    ast_cli(a->fd, "    IAX Statistics\n");
    ast_cli(a->fd, "---------------------\n");
    ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
    ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
        trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
    ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
 
    trunk_timed = trunk_untimed = 0;
    if (trunk_maxmtu > trunk_nmaxmtu)
        trunk_nmaxmtu = trunk_maxmtu;
 
    return CLI_SUCCESS;
}

References a, ARRAY_LEN, ast_cli(), AST_LIST_TRAVERSE, ast_mutex_lock, ast_mutex_unlock, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, iax_frame::final, frame_queue, global_max_trunk_mtu, iax_get_frames(), iax_get_iframes(), iax_get_oframes(), iaxsl, iax_frame::list, NULL, iax_frame::retries, trunk_maxmtu, trunk_nmaxmtu, trunk_timed, trunk_untimed, and ast_cli_entry::usage.

handle_cli_iax2_show_threads()

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

static

Definition at line 7178 of file chan_iax2.c.

{
    struct iax2_thread *thread = NULL;
    time_t t;
    int threadcount = 0, dynamiccount = 0;
    char type;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show threads";
        e->usage =
            "Usage: iax2 show threads\n"
            "       Lists status of IAX helper threads\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
 
    ast_cli(a->fd, "IAX2 Thread Information\n");
    time(&t);
    ast_cli(a->fd, "Idle Threads:\n");
    AST_LIST_LOCK(&idle_list);
    AST_LIST_TRAVERSE(&idle_list, thread, list) {
#ifdef DEBUG_SCHED_MULTITHREAD
        ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
            thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
#else
        ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
            thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
#endif
        threadcount++;
    }
    AST_LIST_UNLOCK(&idle_list);
    ast_cli(a->fd, "Active Threads:\n");
    AST_LIST_LOCK(&active_list);
    AST_LIST_TRAVERSE(&active_list, thread, list) {
        if (thread->type == IAX_THREAD_TYPE_DYNAMIC)
            type = 'D';
        else
            type = 'P';
#ifdef DEBUG_SCHED_MULTITHREAD
        ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d, func='%s'\n",
            type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
#else
        ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d\n",
            type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
#endif
        threadcount++;
    }
    AST_LIST_UNLOCK(&active_list);
    ast_cli(a->fd, "Dynamic Threads:\n");
    AST_LIST_LOCK(&dynamic_list);
    AST_LIST_TRAVERSE(&dynamic_list, thread, list) {
#ifdef DEBUG_SCHED_MULTITHREAD
        ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
            thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
#else
        ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
            thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
#endif
        dynamiccount++;
    }
    AST_LIST_UNLOCK(&dynamic_list);
    ast_cli(a->fd, "%d of %d threads accounted for with %d dynamic threads\n", threadcount, iaxthreadcount, dynamiccount);
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, IAX_THREAD_TYPE_DYNAMIC, iaxthreadcount, iax2_thread::list, NULL, thread, type, and ast_cli_entry::usage.

handle_cli_iax2_show_users()

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

static

Definition at line 6897 of file chan_iax2.c.

{
    regex_t regexbuf;
    int havepattern = 0;
 
#define FORMAT "%-15.15s  %-20.20s  %-15.15s  %-15.15s  %-5.5s  %-5.10s\n"
#define FORMAT2 "%-15.15s  %-20.20s  %-15.15d  %-15.15s  %-5.5s  %-5.10s\n"
 
    struct iax2_user *user = NULL;
    char auth[90];
    char *pstr = "";
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 show users [like]";
        e->usage =
            "Usage: iax2 show users [like <pattern>]\n"
            "       Lists all known IAX2 users.\n"
            "       Optional regular expression pattern is used to filter the user list.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    switch (a->argc) {
    case 5:
        if (!strcasecmp(a->argv[3], "like")) {
            if (regcomp(&regexbuf, a->argv[4], REG_EXTENDED | REG_NOSUB))
                return CLI_SHOWUSAGE;
            havepattern = 1;
        } else
            return CLI_SHOWUSAGE;
    case 3:
        break;
    default:
        return CLI_SHOWUSAGE;
    }
 
    ast_cli(a->fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C","Codec Pref");
    i = ao2_iterator_init(users, 0);
    for (; (user = ao2_iterator_next(&i)); user_unref(user)) {
        if (havepattern && regexec(&regexbuf, user->name, 0, NULL, 0))
            continue;
 
        if (!ast_strlen_zero(user->secret)) {
            ast_copy_string(auth,user->secret, sizeof(auth));
        } else if (!ast_strlen_zero(user->inkeys)) {
            snprintf(auth, sizeof(auth), "Key: %-15.15s ", user->inkeys);
        } else
            ast_copy_string(auth, "-no secret-", sizeof(auth));
 
        if(ast_test_flag64(user, IAX_CODEC_NOCAP))
            pstr = "REQ Only";
        else if(ast_test_flag64(user, IAX_CODEC_NOPREFS))
            pstr = "Disabled";
        else
            pstr = ast_test_flag64(user, IAX_CODEC_USER_FIRST) ? "Caller" : "Host";
 
        ast_cli(a->fd, FORMAT2, user->name, auth, user->authmethods,
            user->contexts ? user->contexts->context : DEFAULT_CONTEXT,
            ast_acl_list_is_empty(user->acl) ? "No" : "Yes", pstr);
    }
    ao2_iterator_destroy(&i);
 
    if (havepattern)
        regfree(&regexbuf);
 
    return CLI_SUCCESS;
#undef FORMAT
#undef FORMAT2
}

References a, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_acl_list_is_empty(), ast_cli(), ast_copy_string(), ast_strlen_zero(), ast_test_flag64, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, DEFAULT_CONTEXT, FORMAT, FORMAT2, IAX_CODEC_NOCAP, IAX_CODEC_NOPREFS, IAX_CODEC_USER_FIRST, NULL, ast_cli_entry::usage, and user_unref().

handle_cli_iax2_test_losspct()

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

static

Definition at line 3774 of file chan_iax2.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 test losspct";
        e->usage =
            "Usage: iax2 test losspct <percentage>\n"
            "       For testing, throws away <percentage> percent of incoming packets\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
 
    test_losspct = atoi(a->argv[3]);
 
    return CLI_SUCCESS;
}

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

handle_cli_iax2_unregister()

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

static

Definition at line 7247 of file chan_iax2.c.

{
    struct iax2_peer *p;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "iax2 unregister";
        e->usage =
            "Usage: iax2 unregister <peername>\n"
            "       Unregister (force expiration) an IAX2 peer from the registry.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_iax2_unregister(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
 
    p = find_peer(a->argv[2], 1);
    if (p) {
        if (p->expire > -1) {
            struct iax2_peer *peer;
 
            peer = ao2_find(peers, a->argv[2], OBJ_KEY);
            if (peer) {
                expire_registry(peer_ref(peer)); /* will release its own reference when done */
                peer_unref(peer); /* ref from ao2_find() */
                ast_cli(a->fd, "Peer %s unregistered\n", a->argv[2]);
            } else {
                ast_cli(a->fd, "Peer %s not found\n", a->argv[2]);
            }
        } else {
            ast_cli(a->fd, "Peer %s not registered\n", a->argv[2]);
        }
        peer_unref(p);
    } else {
        ast_cli(a->fd, "Peer unknown: %s. Not unregistered\n", a->argv[2]);
    }
    return CLI_SUCCESS;
}

References a, ao2_find, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_iax2_unregister(), iax2_peer::expire, expire_registry(), find_peer(), NULL, OBJ_KEY, peer_ref(), peer_unref(), and ast_cli_entry::usage.

handle_deferred_full_frames()

static void handle_deferred_full_frames ( struct iax2_thread *  thread )

static

Handle any deferred full frames for this thread.

Definition at line 9894 of file chan_iax2.c.

{
    struct iax2_pkt_buf *pkt_buf;
 
    ast_mutex_lock(&thread->lock);
 
    while ((pkt_buf = AST_LIST_REMOVE_HEAD(&thread->full_frames, entry))) {
        ast_mutex_unlock(&thread->lock);
 
        thread->buf = pkt_buf->buf;
        thread->buf_len = pkt_buf->len;
        thread->buf_size = pkt_buf->len + 1;
 
        socket_process(thread);
 
        thread->buf = NULL;
        ast_free(pkt_buf);
 
        ast_mutex_lock(&thread->lock);
    }
 
    ast_mutex_unlock(&thread->lock);
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, iax2_pkt_buf::buf, iax2_pkt_buf::entry, iax2_pkt_buf::len, NULL, socket_process(), and thread.

Referenced by iax2_process_thread().

handle_error()

static int handle_error ( void  )

static

Definition at line 3428 of file chan_iax2.c.

{
    /* XXX Ideally we should figure out why an error occurred and then abort those
       rather than continuing to try.  Unfortunately, the published interface does
       not seem to work XXX */
#if 0
    struct sockaddr_in *sin;
    int res;
    struct msghdr m;
    struct sock_extended_err e;
    m.msg_name = NULL;
    m.msg_namelen = 0;
    m.msg_iov = NULL;
    m.msg_control = &e;
    m.msg_controllen = sizeof(e);
    m.msg_flags = 0;
    res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
    if (res < 0)
        ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
    else {
        if (m.msg_controllen) {
            sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
            if (sin)
                ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
            else
                ast_log(LOG_WARNING, "No address detected??\n");
        } else {
            ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
        }
    }
#endif
    return 0;
}

References ast_inet_ntoa(), ast_log, errno, LOG_WARNING, netsocket, and NULL.

Referenced by send_packet(), socket_read(), and transmit_trunk().

iax2_ack_registry()

static int iax2_ack_registry ( struct iax_ies *  ies, struct ast_sockaddr *  addr, int  callno  )

static

Acknowledgment received for OUR registration.

Definition at line 8898 of file chan_iax2.c.

{
    struct iax2_registry *reg;
    /* Start pessimistic */
    char peer[256] = "";
    char msgstatus[60];
    int refresh = 60;
    char ourip[256] = "<Unspecified>";
    struct ast_sockaddr oldus;
    struct ast_sockaddr us;
    int oldmsgs;
 
    if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
        ast_sockaddr_copy(&us, &ies->apparent_addr);
    }
    if (ies->username) {
        ast_copy_string(peer, ies->username, sizeof(peer));
    }
    if (ies->refresh) {
        refresh = ies->refresh;
    }
    if (ies->calling_number) {
        /* We don't do anything with it really, but maybe we should */
    }
    reg = iaxs[callno]->reg;
    if (!reg) {
        ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
        return -1;
    }
    ast_sockaddr_copy(&oldus, &reg->us);
    oldmsgs = reg->messages;
    if (ast_sockaddr_cmp(&reg->addr, addr)) {
        ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", ast_sockaddr_stringify(addr));
        return -1;
    }
    ast_sockaddr_copy(&reg->us, &us);
    if (ies->msgcount >= 0) {
        reg->messages = ies->msgcount & 0xffff;     /* only low 16 bits are used in the transmission of the IE */
    }
    /* always refresh the registration at the interval requested by the server
       we are registering to
    */
    reg->refresh = refresh;
    reg->expire = iax2_sched_replace(reg->expire, sched,
        (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
    if (ast_sockaddr_cmp(&oldus, &reg->us) || (reg->messages != oldmsgs)) {
 
        if (reg->messages > 255) {
            snprintf(msgstatus, sizeof(msgstatus), " with %d new and %d old messages waiting", reg->messages & 0xff, reg->messages >> 8);
        } else if (reg->messages > 1) {
            snprintf(msgstatus, sizeof(msgstatus), " with %d new messages waiting", reg->messages);
        } else if (reg->messages > 0) {
            ast_copy_string(msgstatus, " with 1 new message waiting", sizeof(msgstatus));
        } else {
            ast_copy_string(msgstatus, " with no messages waiting", sizeof(msgstatus));
        }
 
        snprintf(ourip, sizeof(ourip), "%s", ast_sockaddr_stringify(&reg->us));
 
        ast_verb(3, "Registered IAX2 to '%s', who sees us as %s%s\n", ast_sockaddr_stringify(addr), ourip, msgstatus);
        iax2_publish_registry(reg->username, ast_sockaddr_stringify(addr), "Registered", NULL);
    }
    reg->regstate = REG_STATE_REGISTERED;
    return 0;
}

References iax2_registry::addr, iax_ies::apparent_addr, ast_copy_string(), ast_log, ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_stringify(), ast_verb, iax_ies::calling_number, iax2_registry::expire, iax2_do_register_s(), iax2_publish_registry(), iax2_sched_replace(), iaxs, LOG_WARNING, iax2_registry::messages, iax_ies::msgcount, NULL, iax2_registry::refresh, iax_ies::refresh, refresh, chan_iax2_pvt::reg, REG_STATE_REGISTERED, iax2_registry::regstate, iax2_registry::us, iax2_registry::username, and iax_ies::username.

Referenced by socket_process_helper().

iax2_allow_new()

static int attribute_pure iax2_allow_new ( int  frametype, int  subclass, int  inbound  )

inlinestatic

Definition at line 3158 of file chan_iax2.c.

{
    if (frametype != AST_FRAME_IAX) {
        return 0;
    }
    switch (subclass) {
    case IAX_COMMAND_NEW:
    case IAX_COMMAND_REGREQ:
    case IAX_COMMAND_FWDOWNL:
    case IAX_COMMAND_REGREL:
        return 1;
    case IAX_COMMAND_POKE:
        if (!inbound) {
            return 1;
        }
        break;
    }
    return 0;
}

References AST_FRAME_IAX, IAX_COMMAND_FWDOWNL, IAX_COMMAND_NEW, IAX_COMMAND_POKE, IAX_COMMAND_REGREL, and IAX_COMMAND_REGREQ.

Referenced by resend_with_token(), and socket_process_helper().

iax2_answer()

static int iax2_answer ( struct ast_channel *  c )

static

Definition at line 5844 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    ast_debug(1, "Answering IAX2 call\n");
    return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
}

References ast_channel_tech_pvt(), AST_CONTROL_ANSWER, ast_debug, AST_FRAME_CONTROL, c, NULL, PTR_TO_CALLNO, and send_command_locked().

iax2_append_register()

static int iax2_append_register ( const char *  hostname, const char *  username, const char *  secret, const char *  porta  )

static

Definition at line 8964 of file chan_iax2.c.

{
    struct iax2_registry *reg;
 
    if (!(reg = ast_calloc(1, sizeof(*reg) + strlen(hostname) + 1))) {
        return -1;
    }
 
    reg->addr.ss.ss_family = AST_AF_UNSPEC;
    if (ast_dnsmgr_lookup(hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL) < 0) {
        ast_free(reg);
        return -1;
    }
 
    ast_copy_string(reg->username, username, sizeof(reg->username));
    strcpy(reg->hostname, hostname); /* Note: This is safe */
 
    if (secret) {
        ast_copy_string(reg->secret, secret, sizeof(reg->secret));
    }
 
    reg->expire = -1;
    reg->refresh = IAX_DEFAULT_REG_EXPIRE;
 
    reg->port = ast_sockaddr_port(&reg->addr);
 
    if (!porta && !reg->port) {
        reg->port = IAX_DEFAULT_PORTNO;
    } else if (porta) {
        sscanf(porta, "%5d", &reg->port);
    }
 
    ast_sockaddr_set_port(&reg->addr, reg->port);
 
    AST_LIST_LOCK(&registrations);
    AST_LIST_INSERT_HEAD(&registrations, reg, entry);
    AST_LIST_UNLOCK(&registrations);
 
    return 0;
}

References iax2_registry::addr, AST_AF_UNSPEC, ast_calloc, ast_copy_string(), ast_dnsmgr_lookup(), ast_free, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_sockaddr_port, ast_sockaddr_set_port, iax2_registry::dnsmgr, iax2_registry::entry, iax2_registry::expire, iax2_registry::hostname, hostname, IAX_DEFAULT_PORTNO, IAX_DEFAULT_REG_EXPIRE, NULL, iax2_registry::port, iax2_registry::refresh, iax2_registry::secret, srvlookup, ast_sockaddr::ss, and iax2_registry::username.

Referenced by iax2_register().

iax2_call()

static int iax2_call ( struct ast_channel *  c, const char *  dest, int  timeout  )

static

Definition at line 5192 of file chan_iax2.c.

{
    struct ast_sockaddr addr;
    char *l=NULL, *n=NULL, *tmpstr;
    struct iax_ie_data ied;
    char *defaultrdest = "s";
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    struct parsed_dial_string pds;
    struct create_addr_info cai;
    struct ast_var_t *var;
    struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
    const char* osp_token_ptr;
    unsigned int osp_token_length;
    unsigned char osp_block_index;
    unsigned int osp_block_length;
    unsigned char osp_buffer[256];
    char encoded_prefs[32];
    iax2_format iax2_tmpfmt;
 
    if ((ast_channel_state(c) != AST_STATE_DOWN) && (ast_channel_state(c) != AST_STATE_RESERVED)) {
        ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", ast_channel_name(c));
        return -1;
    }
 
    memset(&cai, 0, sizeof(cai));
    cai.encmethods = iax2_encryption;
    cai.authmethods = iax2_authmethods;
 
    memset(&pds, 0, sizeof(pds));
    tmpstr = ast_strdupa(dest);
    parse_dial_string(tmpstr, &pds);
 
    if (ast_strlen_zero(pds.peer)) {
        ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", dest);
        return -1;
    }
    if (!pds.exten) {
        pds.exten = defaultrdest;
    }
    if (create_addr(pds.peer, c, &addr, &cai)) {
        ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
        return -1;
    }
 
    if (ast_test_flag64(&cai, IAX_FORCE_ENCRYPT) ||
        ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
        if (!cai.encmethods) {
            ast_log(LOG_WARNING, "Encryption forced for call, but not enabled\n");
            ast_channel_hangupcause_set(c, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
            return -1;
        }
        if (((cai.authmethods & IAX_AUTH_RSA) || (cai.authmethods & IAX_AUTH_MD5) || (cai.authmethods & IAX_AUTH_PLAINTEXT)) &&
            ast_strlen_zero(cai.secret) && ast_strlen_zero(pds.password)) {
                ast_log(LOG_WARNING, "Call terminated. Encryption forced but no secret provided\n");
                return -1;
        }
    }
 
    if (!pds.username && !ast_strlen_zero(cai.username))
        pds.username = cai.username;
    if (!pds.password && !ast_strlen_zero(cai.secret))
        pds.password = cai.secret;
    if (!pds.key && !ast_strlen_zero(cai.outkey))
        pds.key = cai.outkey;
    if (!pds.context && !ast_strlen_zero(cai.peercontext))
        pds.context = cai.peercontext;
 
    /* Keep track of the context for outgoing calls too */
    ast_channel_context_set(c, cai.context);
 
    if (pds.port) {
        int bindport;
        if (ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
            ast_sockaddr_set_port(&addr, bindport);
        }
    }
 
    l = ast_channel_connected(c)->id.number.valid ? ast_channel_connected(c)->id.number.str : NULL;
    n = ast_channel_connected(c)->id.name.valid ? ast_channel_connected(c)->id.name.str : NULL;
 
    /* Now build request */
    memset(&ied, 0, sizeof(ied));
 
    /* On new call, first IE MUST be IAX version of caller */
    iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
    iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
    if (pds.options && strchr(pds.options, 'a')) {
        /* Request auto answer */
        iax_ie_append(&ied, IAX_IE_AUTOANSWER);
    }
 
    /* WARNING: this breaks down at 190 bits! */
    iax2_codec_pref_convert(&cai.prefs, encoded_prefs, sizeof(encoded_prefs), 1);
    iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, encoded_prefs);
 
    if (l) {
        iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
        iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
            ast_party_id_presentation(&ast_channel_connected(c)->id));
    } else if (n) {
        iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
            ast_party_id_presentation(&ast_channel_connected(c)->id));
    } else {
        iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
    }
 
    iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, ast_channel_connected(c)->id.number.plan);
    iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, ast_channel_dialed(c)->transit_network_select);
    iax_ie_append_int(&ied, IAX_IE_CALLINGANI2, ast_channel_connected(c)->ani2);
 
    if (n)
        iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
    if (ast_test_flag64(iaxs[callno], IAX_SENDANI)
        && ast_channel_connected(c)->ani.number.valid
        && ast_channel_connected(c)->ani.number.str) {
        iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, ast_channel_connected(c)->ani.number.str);
    }
 
    if (!ast_strlen_zero(ast_channel_language(c)))
        iax_ie_append_str(&ied, IAX_IE_LANGUAGE, ast_channel_language(c));
    if (!ast_strlen_zero(ast_channel_dialed(c)->number.str)) {
        iax_ie_append_str(&ied, IAX_IE_DNID, ast_channel_dialed(c)->number.str);
    }
    if (ast_channel_redirecting(c)->from.number.valid
        && !ast_strlen_zero(ast_channel_redirecting(c)->from.number.str)) {
        iax_ie_append_str(&ied, IAX_IE_RDNIS, ast_channel_redirecting(c)->from.number.str);
    }
 
    if (pds.context)
        iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
 
    if (pds.username)
        iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
 
    if (cai.encmethods)
        iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
 
    ast_mutex_lock(&iaxsl[callno]);
 
    if (!ast_strlen_zero(ast_channel_context(c)))
        ast_string_field_set(iaxs[callno], context, ast_channel_context(c));
 
    if (pds.username)
        ast_string_field_set(iaxs[callno], username, pds.username);
 
    iaxs[callno]->encmethods = cai.encmethods;
 
    iaxs[callno]->adsi = cai.adsi;
 
    ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
    ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
 
    if (pds.key)
        ast_string_field_set(iaxs[callno], outkey, pds.key);
    if (pds.password)
        ast_string_field_set(iaxs[callno], secret, pds.password);
 
    iax2_tmpfmt = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(c));
    iax_ie_append_int(&ied, IAX_IE_FORMAT, (int) iax2_tmpfmt);
    iax_ie_append_versioned_uint64(&ied, IAX_IE_FORMAT2, 0, iax2_tmpfmt);
 
    iax_ie_append_int(&ied, IAX_IE_CAPABILITY, (int) iaxs[callno]->capability);
    iax_ie_append_versioned_uint64(&ied, IAX_IE_CAPABILITY2, 0, iaxs[callno]->capability);
    iax_ie_append_short(&ied, IAX_IE_ADSICPE, ast_channel_adsicpe(c));
    iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
 
    if (iaxs[callno]->maxtime) {
        /* Initialize pingtime and auto-congest time */
        iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
        iaxs[callno]->initid = iax2_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
    } else if (autokill) {
        iaxs[callno]->pingtime = autokill / 2;
        iaxs[callno]->initid = iax2_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
    }
 
    /* Check if there is an OSP token */
    osp_token_ptr = pbx_builtin_getvar_helper(c, "IAX2OSPTOKEN");
    if (!ast_strlen_zero(osp_token_ptr)) {
        if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
            osp_block_index = 0;
            while (osp_token_length > 0) {
                osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
                osp_buffer[0] = osp_block_index;
                memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
                iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
                osp_block_index++;
                osp_token_ptr += osp_block_length;
                osp_token_length -= osp_block_length;
            }
        } else
            ast_log(LOG_WARNING, "OSP token is too long\n");
    } else if (iaxdebug)
        ast_debug(1, "OSP token is undefined\n");
 
    /* send the command using the appropriate socket for this peer */
    iaxs[callno]->sockfd = cai.sockfd;
 
    /* Add remote vars */
    if (variablestore) {
        AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
        ast_debug(1, "Found an IAX variable store on this channel\n");
        AST_LIST_LOCK(variablelist);
        AST_LIST_TRAVERSE(variablelist, var, entries) {
            char tmp[256];
            int i;
            ast_debug(1, "Found IAXVAR '%s' with value '%s' (to transmit)\n", ast_var_name(var), ast_var_value(var));
            /* Automatically divide the value up into sized chunks */
            for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) + 1)) {
                snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var), ast_var_value(var) + i);
                iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
            }
        }
        AST_LIST_UNLOCK(variablelist);
    }
 
    /* Transmit the string in a "NEW" request */
    add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
    send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
 
    ast_mutex_unlock(&iaxsl[callno]);
    ast_setstate(c, AST_STATE_RINGING);
 
    return 0;
}

References add_empty_calltoken_ie(), chan_iax2_pvt::adsi, create_addr_info::adsi, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, ast_channel_connected(), ast_channel_context(), ast_channel_context_set(), ast_channel_datastore_find(), ast_channel_dialed(), ast_channel_hangupcause_set(), ast_channel_language(), ast_channel_name(), ast_channel_nativeformats(), ast_channel_redirecting(), ast_channel_tech_pvt(), ast_debug, AST_FRAME_IAX, AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_parse_arg(), ast_party_id_presentation(), AST_PRES_NUMBER_NOT_AVAILABLE, ast_setstate(), ast_sockaddr_set_port, AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RINGING, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_var_name(), ast_var_value(), create_addr_info::authmethods, auto_congest(), autokill, iax_ie_data::buf, c, CALLNO_TO_PTR, create_addr_info::context, parsed_dial_string::context, voicemailpwcheck::context, create_addr(), ast_datastore::data, chan_iax2_pvt::encmethods, create_addr_info::encmethods, parsed_dial_string::exten, iax2_authmethods, iax2_codec_pref_convert(), iax2_datetime(), iax2_encryption, iax2_format_compatibility_cap2bitfield(), iax2_sched_add(), iax2_variable_datastore_info, IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, IAX_COMMAND_NEW, IAX_FORCE_ENCRYPT, IAX_IE_ADSICPE, iax_ie_append(), iax_ie_append_byte(), iax_ie_append_int(), iax_ie_append_raw(), iax_ie_append_short(), iax_ie_append_str(), iax_ie_append_versioned_uint64(), IAX_IE_AUTOANSWER, IAX_IE_CALLED_CONTEXT, IAX_IE_CALLED_NUMBER, IAX_IE_CALLING_ANI, IAX_IE_CALLING_NAME, IAX_IE_CALLING_NUMBER, IAX_IE_CALLINGANI2, IAX_IE_CALLINGPRES, IAX_IE_CALLINGTNS, IAX_IE_CALLINGTON, IAX_IE_CAPABILITY, IAX_IE_CAPABILITY2, IAX_IE_CODEC_PREFS, IAX_IE_DATETIME, IAX_IE_DNID, IAX_IE_ENCRYPTION, IAX_IE_FORMAT, IAX_IE_FORMAT2, IAX_IE_LANGUAGE, IAX_IE_OSPTOKEN, IAX_IE_RDNIS, IAX_IE_USERNAME, IAX_IE_VARIABLE, IAX_IE_VERSION, IAX_MAX_OSPBLOCK_SIZE, IAX_MAX_OSPTOKEN_SIZE, IAX_PROTO_VERSION, IAX_SENDANI, iaxdebug, iaxs, iaxsl, ast_party_connected_line::id, chan_iax2_pvt::initid, parsed_dial_string::key, LOG_WARNING, chan_iax2_pvt::maxtime, mohinterpret, create_addr_info::mohinterpret, mohsuggest, create_addr_info::mohsuggest, ast_party_id::name, NULL, ast_party_id::number, parsed_dial_string::options, create_addr_info::outkey, parse_dial_string(), PARSE_IN_RANGE, PARSE_UINT32, parsed_dial_string::password, pbx_builtin_getvar_helper(), parsed_dial_string::peer, create_addr_info::peercontext, chan_iax2_pvt::pingtime, parsed_dial_string::port, iax_ie_data::pos, create_addr_info::prefs, PTR_TO_CALLNO, create_addr_info::secret, send_command(), chan_iax2_pvt::sockfd, create_addr_info::sockfd, ast_party_name::str, ast_party_number::str, create_addr_info::timezone, create_addr_info::username, parsed_dial_string::username, ast_party_name::valid, ast_party_number::valid, and var.

iax2_canmatch()

static int iax2_canmatch ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

part of the IAX2 dial plan switch interface

Definition at line 14505 of file chan_iax2.c.

{
    int res = 0;
    struct iax2_dpcache *dp = NULL;
#if 0
    ast_log(LOG_NOTICE, "iax2_canmatch: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
#endif
    if ((priority != 1) && (priority != 2))
        return 0;
 
    AST_LIST_LOCK(&dpcache);
    if ((dp = find_cache(chan, data, context, exten, priority))) {
        if (dp->flags & CACHE_FLAG_CANEXIST)
            res = 1;
    } else {
        ast_log(LOG_WARNING, "Unable to make DP cache\n");
    }
    AST_LIST_UNLOCK(&dpcache);
 
    return res;
}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_CANEXIST, voicemailpwcheck::context, iax2_dpcache::exten, find_cache(), iax2_dpcache::flags, LOG_NOTICE, LOG_WARNING, NULL, and priority.

iax2_codec_choose()

static iax2_format iax2_codec_choose ( struct iax2_codec_pref *  pref, iax2_format  formats  )

static

Definition at line 1954 of file chan_iax2.c.

{
    struct ast_format_cap *cap;
    struct ast_format *tmpfmt;
    iax2_format format = 0;
 
    if ((cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        iax2_format_compatibility_bitfield2cap(formats, cap);
        tmpfmt = codec_choose_from_prefs(pref, cap);
        if (!tmpfmt) {
            ao2_ref(cap, -1);
            return 0;
        }
 
        format = ast_format_compatibility_format2bitfield(tmpfmt);
        ao2_ref(tmpfmt, -1);
        ao2_ref(cap, -1);
    }
 
    return format;
}

References ao2_ref, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_compatibility_format2bitfield(), codec_choose_from_prefs(), and iax2_format_compatibility_bitfield2cap().

Referenced by socket_process_helper().

iax2_datetime()

static unsigned int iax2_datetime ( const char *  tz )

static

Definition at line 4844 of file chan_iax2.c.

{
    struct timeval t = ast_tvnow();
    struct ast_tm tm;
    unsigned int tmp;
    ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
    tmp  = (tm.tm_sec >> 1) & 0x1f;         /* 5 bits of seconds */
    tmp |= (tm.tm_min & 0x3f) << 5;         /* 6 bits of minutes */
    tmp |= (tm.tm_hour & 0x1f) << 11;       /* 5 bits of hours */
    tmp |= (tm.tm_mday & 0x1f) << 16;       /* 5 bits of day of month */
    tmp |= ((tm.tm_mon + 1) & 0xf) << 21;       /* 4 bits of month */
    tmp |= ((tm.tm_year - 100) & 0x7f) << 25;   /* 7 bits of year */
    return tmp;
}

References ast_localtime(), ast_strlen_zero(), ast_tvnow(), NULL, ast_tm::tm_hour, ast_tm::tm_mday, ast_tm::tm_min, ast_tm::tm_mon, ast_tm::tm_sec, ast_tm::tm_year, and tz.

Referenced by iax2_call(), and update_registry().

iax2_delete_from_sched()

static int iax2_delete_from_sched ( const void *  data )

static

Definition at line 2150 of file chan_iax2.c.

{
    int sched_id = (int)(long)data;
 
    AST_SCHED_DEL(sched, sched_id);
 
    return 0;
}

References AST_SCHED_DEL.

Referenced by iax2_destroy_helper().

iax2_destroy()

static void iax2_destroy ( int  callno )

static

Definition at line 3532 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt = NULL;
    struct ast_channel *owner = NULL;
 
retry:
    if ((pvt = iaxs[callno])) {
#if 0
        /* iax2_destroy_helper gets called from this function later on.  When
         * called twice, we get the (previously) familiar FRACK! errors in
         * devmode, from the scheduler.  An alternative to this approach is to
         * reset the scheduler entries to -1 when they're deleted in
         * iax2_destroy_helper().  That approach was previously decided to be
         * "wrong" because "the memory is going to be deallocated anyway.  Why
         * should we be resetting those values?" */
        iax2_destroy_helper(pvt);
#endif
    }
 
    owner = pvt ? pvt->owner : NULL;
 
    if (owner) {
        if (ast_channel_trylock(owner)) {
            ast_debug(3, "Avoiding IAX destroy deadlock\n");
            DEADLOCK_AVOIDANCE(&iaxsl[callno]);
            goto retry;
        }
    }
 
    if (!owner) {
        iaxs[callno] = NULL;
    }
 
    if (pvt) {
        if (!owner) {
            pvt->owner = NULL;
        } else {
            /* If there's an owner, prod it to give up */
            /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
             * because we already hold the owner channel lock. */
            ast_queue_hangup(owner);
        }
 
        if (pvt->peercallno) {
            remove_by_peercallno(pvt);
        }
 
        if (pvt->transfercallno) {
            remove_by_transfercallno(pvt);
        }
 
        if (!owner) {
            ao2_ref(pvt, -1);
            pvt = NULL;
        }
    }
 
    if (owner) {
        ast_channel_unlock(owner);
    }
}

References ao2_ref, ast_channel_trylock, ast_channel_unlock, ast_debug, ast_queue_hangup(), DEADLOCK_AVOIDANCE, iax2_destroy_helper(), iaxs, iaxsl, NULL, chan_iax2_pvt::owner, chan_iax2_pvt::peercallno, remove_by_peercallno(), remove_by_transfercallno(), and chan_iax2_pvt::transfercallno.

Referenced by __attempt_transmit(), __iax2_poke_noanswer(), __unload_module(), delete_users(), iax2_do_register(), iax2_hangup(), iax2_poke_peer(), peer_destructor(), scheduled_destroy(), and socket_process_helper().

iax2_destroy_helper()

static void iax2_destroy_helper ( struct chan_iax2_pvt *  pvt )

static

Note

Assumes the lock on the pvt is already held, when iax2_destroy_helper() is called.

Definition at line 2161 of file chan_iax2.c.

{
    /* Decrement AUTHREQ count if needed */
    if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
        struct iax2_user *user;
 
        user = ao2_find(users, pvt->username, OBJ_KEY);
        if (user) {
            ast_atomic_fetchadd_int(&user->curauthreq, -1);
            user_unref(user);
        }
 
        ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
    }
 
 
    /* Mark call destroy initiated flag. */
    pvt->destroy_initiated = 1;
 
    /*
     * Schedule deleting the scheduled (but didn't run yet) PINGs or LAGRQs.
     * Already running tasks will be terminated because of destroy_initiated.
     *
     * Don't call AST_SCHED_DEL from this thread for pingid and lagid because
     * it leads to a deadlock between the scheduler thread callback locking
     * the callno mutex and this thread which holds the callno mutex one or
     * more times.  It is better to have another thread delete the scheduled
     * callbacks which doesn't lock the callno mutex.
     */
    iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->pingid);
    iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->lagid);
 
    pvt->pingid = -1;
    pvt->lagid = -1;
 
    AST_SCHED_DEL(sched, pvt->autoid);
    AST_SCHED_DEL(sched, pvt->authid);
    AST_SCHED_DEL(sched, pvt->initid);
    AST_SCHED_DEL(sched, pvt->jbid);
    AST_SCHED_DEL(sched, pvt->keyrotateid);
}

References ao2_find, ast_atomic_fetchadd_int(), ast_clear_flag64, AST_SCHED_DEL, ast_test_flag64, chan_iax2_pvt::authid, chan_iax2_pvt::autoid, chan_iax2_pvt::destroy_initiated, iax2_delete_from_sched(), iax2_sched_add(), IAX_MAXAUTHREQ, chan_iax2_pvt::initid, chan_iax2_pvt::jbid, chan_iax2_pvt::keyrotateid, chan_iax2_pvt::lagid, OBJ_KEY, chan_iax2_pvt::pingid, user, user_unref(), and chan_iax2_pvt::username.

Referenced by iax2_destroy(), iax2_predestroy(), pvt_destructor(), and stop_stuff().

iax2_devicestate()

static int iax2_devicestate ( const char *  data )

static

Part of the device state notification system —.

Definition at line 14715 of file chan_iax2.c.

{
    struct parsed_dial_string pds;
    char *tmp = ast_strdupa(data);
    struct iax2_peer *p;
    int res = AST_DEVICE_INVALID;
 
    memset(&pds, 0, sizeof(pds));
    parse_dial_string(tmp, &pds);
 
    if (ast_strlen_zero(pds.peer)) {
        ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
        return res;
    }
 
    ast_debug(3, "Checking device state for device %s\n", pds.peer);
 
    /* SLD: FIXME: second call to find_peer during registration */
    if (!(p = find_peer(pds.peer, 1)))
        return res;
 
    res = AST_DEVICE_UNAVAILABLE;
 
    ast_debug(3, "Found peer. What's device state of %s? addr=%s, defaddr=%s maxms=%d, lastms=%d\n",
        pds.peer, ast_sockaddr_stringify(&p->addr), ast_sockaddr_stringify(&p->defaddr), p->maxms, p->lastms);
 
    if (((!ast_sockaddr_isnull(&p->addr)) || (!ast_sockaddr_isnull(&p->defaddr))) &&
        (!p->maxms || ((p->lastms > -1) && (p->historicms <= p->maxms)))) {
        /* Peer is registered, or have default IP address
           and a valid registration */
        if (p->historicms == 0 || p->historicms <= p->maxms)
            /* let the core figure out whether it is in use or not */
            res = AST_DEVICE_UNKNOWN;
    }
 
    peer_unref(p);
 
    return res;
}

References iax2_peer::addr, ast_debug, AST_DEVICE_INVALID, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, ast_log, ast_sockaddr_isnull(), ast_sockaddr_stringify(), ast_strdupa, ast_strlen_zero(), iax2_peer::defaddr, find_peer(), iax2_peer::historicms, iax2_peer::lastms, LOG_WARNING, iax2_peer::maxms, parse_dial_string(), parsed_dial_string::peer, and peer_unref().

iax2_digit_begin()

static int iax2_digit_begin ( struct ast_channel *  c, char  digit  )

static

Definition at line 4414 of file chan_iax2.c.

{
    return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
}

References ast_channel_tech_pvt(), AST_FRAME_DTMF_BEGIN, c, digit, NULL, PTR_TO_CALLNO, and send_command_locked().

iax2_digit_end()

static int iax2_digit_end ( struct ast_channel *  c, char  digit, unsigned int  duration  )

static

Definition at line 4419 of file chan_iax2.c.

{
    return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
}

References ast_channel_tech_pvt(), AST_FRAME_DTMF_END, c, digit, NULL, PTR_TO_CALLNO, and send_command_locked().

iax2_do_register()

static int iax2_do_register ( struct iax2_registry *  reg )

static

Definition at line 12354 of file chan_iax2.c.

{
    struct iax_ie_data ied;
    if (iaxdebug)
        ast_debug(1, "Sending registration request for '%s'\n", reg->username);
 
    if (reg->dnsmgr &&
        ((reg->regstate == REG_STATE_TIMEOUT) || ast_sockaddr_isnull(&reg->addr))) {
        /* Maybe the IP has changed, force DNS refresh */
        ast_dnsmgr_refresh(reg->dnsmgr);
    }
 
    /*
     * if IP has Changed, free allocated call to create a new one with new IP
     * call has the pointer to IP and must be updated to the new one
     */
    if (reg->dnsmgr && ast_dnsmgr_changed(reg->dnsmgr) && (reg->callno > 0)) {
        int callno = reg->callno;
        ast_mutex_lock(&iaxsl[callno]);
        iax2_destroy(callno);
        ast_mutex_unlock(&iaxsl[callno]);
        reg->callno = 0;
    }
    if (ast_sockaddr_isnull(&reg->addr)) {
        if (iaxdebug)
            ast_debug(1, "Unable to send registration request for '%s' without IP address\n", reg->username);
        /* Setup the next registration attempt */
        reg->expire = iax2_sched_replace(reg->expire, sched,
            (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
        return -1;
    }
    if (!ast_sockaddr_port(&reg->addr) && reg->port) {
        ast_sockaddr_set_port(&reg->addr, reg->port);
    }
 
    if (!reg->callno) {
 
        ast_debug(3, "Allocate call number\n");
 
        reg->callno = find_callno_locked(0, 0, &reg->addr, NEW_FORCE, defaultsockfd, 0);
        if (reg->callno < 1) {
            ast_log(LOG_WARNING, "Unable to create call for registration\n");
            return -1;
        } else
            ast_debug(3, "Registration created on call %d\n", reg->callno);
        iaxs[reg->callno]->reg = reg;
        ast_mutex_unlock(&iaxsl[reg->callno]);
    }
    /* Setup the next registration a little early */
    reg->expire = iax2_sched_replace(reg->expire, sched,
        (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
    /* Send the request */
    memset(&ied, 0, sizeof(ied));
    iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
    iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
    add_empty_calltoken_ie(iaxs[reg->callno], &ied); /* this _MUST_ be the last ie added */
    send_command(iaxs[reg->callno],AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
    reg->regstate = REG_STATE_REGSENT;
    return 0;
}

References add_empty_calltoken_ie(), iax2_registry::addr, ast_debug, ast_dnsmgr_changed(), ast_dnsmgr_refresh(), AST_FRAME_IAX, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_isnull(), ast_sockaddr_port, ast_sockaddr_set_port, iax_ie_data::buf, iax2_registry::callno, defaultsockfd, iax2_registry::dnsmgr, iax2_registry::expire, find_callno_locked(), iax2_destroy(), iax2_do_register_s(), iax2_sched_replace(), IAX_COMMAND_REGREQ, iax_ie_append_short(), iax_ie_append_str(), IAX_IE_REFRESH, IAX_IE_USERNAME, iaxdebug, iaxs, iaxsl, LOG_WARNING, NEW_FORCE, iax2_registry::port, iax_ie_data::pos, iax2_registry::refresh, chan_iax2_pvt::reg, REG_STATE_REGSENT, REG_STATE_TIMEOUT, iax2_registry::regstate, send_command(), and iax2_registry::username.

Referenced by __iax2_do_register_s(), load_module(), network_change_sched_cb(), and reload_config().

iax2_do_register_s()

static int iax2_do_register_s ( const void *  data )

static

Definition at line 8741 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__iax2_do_register_s, data))
#endif
        __iax2_do_register_s(data);
    return 0;
}

References __iax2_do_register_s(), and schedule_action.

Referenced by iax2_ack_registry(), and iax2_do_register().

iax2_dprequest()

static void iax2_dprequest ( struct iax2_dpcache *  dp, int  callno  )

static

Definition at line 9543 of file chan_iax2.c.

{
    struct iax_ie_data ied;
    /* Auto-hangup with 30 seconds of inactivity */
    iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
        sched, 30000, auto_hangup, (void *)(long)callno);
    memset(&ied, 0, sizeof(ied));
    iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, dp->exten);
    send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREQ, 0, ied.buf, ied.pos, -1);
    dp->flags |= CACHE_FLAG_TRANSMITTED;
}

References AST_FRAME_IAX, auto_hangup(), chan_iax2_pvt::autoid, iax_ie_data::buf, CACHE_FLAG_TRANSMITTED, iax2_dpcache::exten, iax2_dpcache::flags, iax2_sched_replace(), IAX_COMMAND_DPREQ, iax_ie_append_str(), IAX_IE_CALLED_NUMBER, iaxs, iax_ie_data::pos, and send_command().

Referenced by find_cache(), and socket_process_helper().

iax2_dup_variable_datastore()

static void * iax2_dup_variable_datastore ( void *  old )

static

Definition at line 1601 of file chan_iax2.c.

{
    AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
    struct ast_var_t *oldvar, *newvar;
 
    newlist = ast_calloc(sizeof(*newlist), 1);
    if (!newlist) {
        ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
        return NULL;
    }
 
    AST_LIST_HEAD_INIT(newlist);
    AST_LIST_LOCK(oldlist);
    AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
        newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
        if (newvar)
            AST_LIST_INSERT_TAIL(newlist, newvar, entries);
        else
            ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
    }
    AST_LIST_UNLOCK(oldlist);
    return newlist;
}

References ast_calloc, AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_var_assign, ast_var_name(), ast_var_value(), ast_var_t::entries, LOG_ERROR, and NULL.

iax2_exec()

static int iax2_exec ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Execute IAX2 dialplan switch.

Definition at line 14551 of file chan_iax2.c.

{
    char odata[256];
    char req[sizeof(odata) + AST_MAX_CONTEXT + AST_MAX_EXTENSION + sizeof("IAX2//@")];
    char *ncontext;
    struct iax2_dpcache *dp = NULL;
    struct ast_app *dial = NULL;
#if 0
    ast_log(LOG_NOTICE, "iax2_exec: con: %s, exten: %s, pri: %d, cid: %s, data: %s, newstack: %d\n", context, exten, priority, callerid ? callerid : "<unknown>", data, newstack);
#endif
    if (priority == 2) {
        /* Indicate status, can be overridden in dialplan */
        const char *dialstatus = pbx_builtin_getvar_helper(chan, "DIALSTATUS");
        if (dialstatus) {
            dial = pbx_findapp(dialstatus);
            if (dial)
                pbx_exec(chan, dial, "");
        }
        return -1;
    } else if (priority != 1)
        return -1;
 
    AST_LIST_LOCK(&dpcache);
    if ((dp = find_cache(chan, data, context, exten, priority))) {
        if (dp->flags & CACHE_FLAG_EXISTS) {
            ast_copy_string(odata, data, sizeof(odata));
            ncontext = strchr(odata, '/');
            if (ncontext) {
                *ncontext = '\0';
                ncontext++;
                snprintf(req, sizeof(req), "IAX2/%s/%s@%s", odata, exten, ncontext);
            } else {
                snprintf(req, sizeof(req), "IAX2/%s/%s", odata, exten);
            }
            ast_verb(3, "Executing Dial('%s')\n", req);
        } else {
            AST_LIST_UNLOCK(&dpcache);
            ast_log(LOG_WARNING, "Can't execute nonexistent extension '%s[@%s]' in data '%s'\n", exten, context, data);
            return -1;
        }
    }
    AST_LIST_UNLOCK(&dpcache);
 
    if ((dial = pbx_findapp("Dial")))
        return pbx_exec(chan, dial, req);
    else
        ast_log(LOG_WARNING, "No dial application registered\n");
 
    return -1;
}

References ast_copy_string(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_verb, CACHE_FLAG_EXISTS, voicemailpwcheck::context, find_cache(), iax2_dpcache::flags, LOG_NOTICE, LOG_WARNING, NULL, pbx_builtin_getvar_helper(), pbx_exec(), pbx_findapp(), and priority.

iax2_exists()

static int iax2_exists ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Part of the IAX2 switch interface.

Definition at line 14482 of file chan_iax2.c.

{
    int res = 0;
    struct iax2_dpcache *dp = NULL;
#if 0
    ast_log(LOG_NOTICE, "iax2_exists: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
#endif
    if ((priority != 1) && (priority != 2))
        return 0;
 
    AST_LIST_LOCK(&dpcache);
    if ((dp = find_cache(chan, data, context, exten, priority))) {
        if (dp->flags & CACHE_FLAG_EXISTS)
            res = 1;
    } else {
        ast_log(LOG_WARNING, "Unable to make DP cache\n");
    }
    AST_LIST_UNLOCK(&dpcache);
 
    return res;
}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_EXISTS, voicemailpwcheck::context, iax2_dpcache::exten, find_cache(), iax2_dpcache::flags, LOG_NOTICE, LOG_WARNING, NULL, and priority.

iax2_fixup()

static int iax2_fixup ( struct ast_channel *  oldchannel, struct ast_channel *  newchan  )

static

Definition at line 4441 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(newchan));
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno])
        iaxs[callno]->owner = newchan;
    else
        ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
    ast_mutex_unlock(&iaxsl[callno]);
    return 0;
}

References ast_channel_tech_pvt(), ast_log, ast_mutex_lock, ast_mutex_unlock, iax_frame::callno, iaxs, iaxsl, LOG_WARNING, chan_iax2_pvt::owner, and PTR_TO_CALLNO.

iax2_frame_free()

static void iax2_frame_free ( struct iax_frame *  fr )

static

Definition at line 2203 of file chan_iax2.c.

{
    AST_SCHED_DEL(sched, fr->retrans);
    iax_frame_free(fr);
}

References AST_SCHED_DEL, iax_frame_free(), and iax_frame::retrans.

Referenced by __attempt_transmit(), __do_deliver(), __get_from_jb(), complete_transfer(), pvt_destructor(), resend_with_token(), and schedule_delivery().

iax2_free_variable_datastore()

static void iax2_free_variable_datastore ( void *  old )

static

Definition at line 1625 of file chan_iax2.c.

{
    AST_LIST_HEAD(, ast_var_t) *oldlist = old;
    struct ast_var_t *oldvar;
 
    AST_LIST_LOCK(oldlist);
    while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
        ast_free(oldvar);
    }
    AST_LIST_UNLOCK(oldlist);
    AST_LIST_HEAD_DESTROY(oldlist);
    ast_free(oldlist);
}

References ast_free, AST_LIST_HEAD, AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and ast_var_t::entries.

iax2_getformatname()

const char * iax2_getformatname

(

iax2_format

format

)

iax2 wrapper function for ast_getformatname

Definition at line 1976 of file chan_iax2.c.

{
    struct ast_format *tmpfmt;
 
    tmpfmt = ast_format_compatibility_bitfield2format(format);
    if (!tmpfmt) {
        return "Unknown";
    }
 
    return ast_format_get_name(tmpfmt);
}

References ast_format_compatibility_bitfield2format(), and ast_format_get_name().

Referenced by dump_versioned_codec(), handle_cli_iax2_show_channels(), iax_show_provisioning(), and socket_process_helper().

iax2_getformatname_multiple()

static const char * iax2_getformatname_multiple ( iax2_format  format, struct ast_str **  codec_buf  )

static

Definition at line 1988 of file chan_iax2.c.

{
    struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
    if (!cap) {
        return "(Nothing)";
    }
    iax2_format_compatibility_bitfield2cap(format, cap);
    ast_format_cap_get_names(cap, codec_buf);
    ao2_ref(cap, -1);
 
    return ast_str_buffer(*codec_buf);
}

References ao2_ref, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), ast_str_buffer(), and iax2_format_compatibility_bitfield2cap().

Referenced by function_iaxpeer(), handle_cli_iax2_show_peer(), and socket_process_helper().

iax2_getpeername()

static int iax2_getpeername ( struct ast_sockaddr  addr, char *  host, int  len  )

static

Definition at line 2118 of file chan_iax2.c.

{
    struct iax2_peer *peer = NULL;
    int res = 0;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(peers, 0);
    while ((peer = ao2_iterator_next(&i))) {
 
        if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
            ast_copy_string(host, peer->name, len);
            peer_unref(peer);
            res = 1;
            break;
        }
        peer_unref(peer);
    }
    ao2_iterator_destroy(&i);
 
    if (!peer) {
        peer = realtime_peer(NULL, &addr);
        if (peer) {
            ast_copy_string(host, peer->name, len);
            peer_unref(peer);
            res = 1;
        }
    }
 
    return res;
}

References iax2_peer::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_copy_string(), ast_sockaddr_cmp(), len(), iax2_peer::name, NULL, peer_unref(), and realtime_peer().

Referenced by __find_callno().

iax2_getpeertrunk()

static int iax2_getpeertrunk ( struct ast_sockaddr  addr )

static

Definition at line 5924 of file chan_iax2.c.

{
    struct iax2_peer *peer;
    int res = 0;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(peers, 0);
    while ((peer = ao2_iterator_next(&i))) {
 
        if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
            res = ast_test_flag64(peer, IAX_TRUNK);
            peer_unref(peer);
            break;
        }
        peer_unref(peer);
    }
    ao2_iterator_destroy(&i);
 
    return res;
}

References iax2_peer::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_sockaddr_cmp(), ast_test_flag64, IAX_TRUNK, and peer_unref().

Referenced by check_access().

iax2_hangup()

static int iax2_hangup ( struct ast_channel *  c )

static

Definition at line 5417 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    struct iax_ie_data ied;
    int alreadygone;
    memset(&ied, 0, sizeof(ied));
    ast_mutex_lock(&iaxsl[callno]);
    if (callno && iaxs[callno]) {
        ast_debug(1, "We're hanging up %s now...\n", ast_channel_name(c));
        alreadygone = ast_test_flag64(iaxs[callno], IAX_ALREADYGONE);
        /* Send the hangup unless we have had a transmission error or are already gone */
        iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)ast_channel_hangupcause(c));
        if (!iaxs[callno]->error && !alreadygone) {
            if (send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1)) {
                ast_log(LOG_WARNING, "No final packet could be sent for callno %d\n", callno);
            }
            if (!iaxs[callno]) {
                ast_mutex_unlock(&iaxsl[callno]);
                return 0;
            }
        }
        /* Explicitly predestroy it */
        iax2_predestroy(callno);
        /* If we were already gone to begin with, destroy us now */
        if (iaxs[callno] && alreadygone) {
            ast_debug(1, "Really destroying %s now...\n", ast_channel_name(c));
            iax2_destroy(callno);
        } else if (iaxs[callno]) {
            if (ast_sched_add(sched, 10000, scheduled_destroy, CALLNO_TO_PTR(callno)) < 0) {
                ast_log(LOG_ERROR, "Unable to schedule iax2 callno %d destruction?!!  Destroying immediately.\n", callno);
                iax2_destroy(callno);
            }
        }
    } else if (ast_channel_tech_pvt(c)) {
        /* If this call no longer exists, but the channel still
         * references it we need to set the channel's tech_pvt to null
         * to avoid ast_channel_free() trying to free it.
         */
        ast_channel_tech_pvt_set(c, NULL);
    }
    ast_mutex_unlock(&iaxsl[callno]);
    ast_verb(3, "Hungup '%s'\n", ast_channel_name(c));
    return 0;
}

References ast_channel_hangupcause(), ast_channel_name(), ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), ast_debug, AST_FRAME_IAX, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sched_add(), ast_test_flag64, ast_verb, iax_ie_data::buf, c, CALLNO_TO_PTR, error(), iax2_destroy(), iax2_predestroy(), IAX_ALREADYGONE, IAX_COMMAND_HANGUP, iax_ie_append_byte(), IAX_IE_CAUSECODE, iaxs, iaxsl, LOG_ERROR, LOG_WARNING, NULL, iax_ie_data::pos, PTR_TO_CALLNO, scheduled_destroy(), and send_command_final().

iax2_indicate()

static int iax2_indicate ( struct ast_channel *  c, int  condition, const void *  data, size_t  datalen  )

static

Definition at line 5851 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    struct chan_iax2_pvt *pvt;
    int res = 0;
 
    if (iaxdebug)
        ast_debug(1, "Indicating condition %d\n", condition);
 
    ast_mutex_lock(&iaxsl[callno]);
    pvt = iaxs[callno];
 
    if (wait_for_peercallno(pvt)) {
        res = -1;
        goto done;
    }
 
    switch (condition) {
    case AST_CONTROL_HOLD:
        if (strcasecmp(pvt->mohinterpret, "passthrough")) {
            ast_moh_start(c, data, pvt->mohinterpret);
            goto done;
        }
        break;
    case AST_CONTROL_UNHOLD:
        if (strcasecmp(pvt->mohinterpret, "passthrough")) {
            ast_moh_stop(c);
            goto done;
        }
        break;
    case AST_CONTROL_CONNECTED_LINE:
    case AST_CONTROL_REDIRECTING:
        if (!ast_test_flag64(pvt, IAX_SENDCONNECTEDLINE)) {
            /* We are not configured to allow sending these updates. */
            ast_debug(2, "Callno %d: Config blocked sending control frame %d.\n",
                callno, condition);
            goto done;
        }
        break;
    case AST_CONTROL_PVT_CAUSE_CODE:
    case AST_CONTROL_MASQUERADE_NOTIFY:
        res = -1;
        goto done;
    }
 
    res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
 
done:
    ast_mutex_unlock(&iaxsl[callno]);
 
    return res;
}

References ast_channel_tech_pvt(), AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HOLD, AST_CONTROL_MASQUERADE_NOTIFY, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, AST_CONTROL_UNHOLD, ast_debug, AST_FRAME_CONTROL, ast_moh_start(), ast_moh_stop(), ast_mutex_lock, ast_mutex_unlock, ast_test_flag64, c, chan_iax2_pvt::callno, done, IAX_SENDCONNECTEDLINE, iaxdebug, iaxs, iaxsl, chan_iax2_pvt::mohinterpret, PTR_TO_CALLNO, send_command(), and wait_for_peercallno().

iax2_is_control_frame_allowed()

static int iax2_is_control_frame_allowed ( int  subtype )

static

Definition at line 1430 of file chan_iax2.c.

{
    enum ast_control_frame_type control = subtype;
    int is_allowed;
 
    /*
     * Note: If we compare the enumeration type, which does not have any
     * negative constants, the compiler may optimize this code away.
     * Therefore, we must perform an integer comparison here.
     */
    if (subtype == -1) {
        return -1;
    }
 
    /* Default to not allowing control frames to pass. */
    is_allowed = 0;
 
    /*
     * The switch default is not present in order to take advantage
     * of the compiler complaining of a missing enum case.
     */
    switch (control) {
    /*
     * These control frames make sense to send/receive across the link.
     */
    case AST_CONTROL_HANGUP:
    case AST_CONTROL_RING:
    case AST_CONTROL_RINGING:
    case AST_CONTROL_ANSWER:
    case AST_CONTROL_BUSY:
    case AST_CONTROL_TAKEOFFHOOK:
    case AST_CONTROL_OFFHOOK:
    case AST_CONTROL_CONGESTION:
    case AST_CONTROL_FLASH:
    case AST_CONTROL_WINK:
    case AST_CONTROL_OPTION:
    case AST_CONTROL_RADIO_KEY:
    case AST_CONTROL_RADIO_UNKEY:
    case AST_CONTROL_PROGRESS:
    case AST_CONTROL_PROCEEDING:
    case AST_CONTROL_HOLD:
    case AST_CONTROL_UNHOLD:
    case AST_CONTROL_VIDUPDATE:
    case AST_CONTROL_CONNECTED_LINE:
    case AST_CONTROL_REDIRECTING:
    case AST_CONTROL_T38_PARAMETERS:
    case AST_CONTROL_AOC:
    case AST_CONTROL_INCOMPLETE:
    case AST_CONTROL_MCID:
        is_allowed = -1;
        break;
 
    /*
     * These control frames do not make sense to send/receive across the link.
     */
    case _XXX_AST_CONTROL_T38:
        /* The control value is deprecated in favor of AST_CONTROL_T38_PARAMETERS. */
    case AST_CONTROL_SRCUPDATE:
        /* Across an IAX link the source is still the same. */
    case AST_CONTROL_TRANSFER:
        /* A success/fail status report from calling ast_transfer() on this machine. */
    case AST_CONTROL_CC:
        /* The payload contains pointers that are valid for the sending machine only. */
    case AST_CONTROL_SRCCHANGE:
        /* Across an IAX link the source is still the same. */
    case AST_CONTROL_READ_ACTION:
        /* The action can only be done by the sending machine. */
    case AST_CONTROL_END_OF_Q:
        /* This frame would cause the call to unexpectedly hangup. */
    case AST_CONTROL_UPDATE_RTP_PEER:
        /* Only meaningful across a bridge on this machine for direct-media exchange. */
    case AST_CONTROL_PVT_CAUSE_CODE:
        /* Intended only for the sending machine's local channel structure. */
    case AST_CONTROL_MASQUERADE_NOTIFY:
        /* Intended only for masquerades when calling ast_indicate_data(). */
    case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
        /* Intended only for internal stream topology manipulation. */
    case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
        /* Intended only for internal stream topology change notification. */
    case AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED:
    case AST_CONTROL_STREAM_STOP:
    case AST_CONTROL_STREAM_SUSPEND:
    case AST_CONTROL_STREAM_RESTART:
    case AST_CONTROL_STREAM_REVERSE:
    case AST_CONTROL_STREAM_FORWARD:
    case AST_CONTROL_PLAYBACK_BEGIN: /* Only supported by app_dial currently */
        /* None of these playback stream control frames should go across the link. */
    case AST_CONTROL_RECORD_CANCEL:
    case AST_CONTROL_RECORD_STOP:
    case AST_CONTROL_RECORD_SUSPEND:
    case AST_CONTROL_RECORD_MUTE:
        /* None of these media recording control frames should go across the link. */
        break;
    }
    return is_allowed;
}

References _XXX_AST_CONTROL_T38, AST_CONTROL_ANSWER, AST_CONTROL_AOC, AST_CONTROL_BUSY, AST_CONTROL_CC, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_END_OF_Q, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_INCOMPLETE, AST_CONTROL_MASQUERADE_NOTIFY, AST_CONTROL_MCID, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_PLAYBACK_BEGIN, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_READ_ACTION, AST_CONTROL_RECORD_CANCEL, AST_CONTROL_RECORD_MUTE, AST_CONTROL_RECORD_STOP, AST_CONTROL_RECORD_SUSPEND, AST_CONTROL_REDIRECTING, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_STREAM_FORWARD, AST_CONTROL_STREAM_RESTART, AST_CONTROL_STREAM_REVERSE, AST_CONTROL_STREAM_STOP, AST_CONTROL_STREAM_SUSPEND, AST_CONTROL_STREAM_TOPOLOGY_CHANGED, AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_TRANSFER, AST_CONTROL_UNHOLD, AST_CONTROL_UPDATE_RTP_PEER, AST_CONTROL_VIDUPDATE, and AST_CONTROL_WINK.

Referenced by send_command(), and socket_process_helper().

iax2_key_rotate()

static int iax2_key_rotate ( const void *  vpvt )

static

Definition at line 5579 of file chan_iax2.c.

{
    int res = 0;
    struct chan_iax2_pvt *pvt = (void *) vpvt;
    struct MD5Context md5;
    char key[17] = "";
    struct iax_ie_data ied = {
        .pos = 0,
    };
 
    ast_mutex_lock(&iaxsl[pvt->callno]);
    pvt->keyrotateid = ast_sched_add(sched, 120000 + (ast_random() % 180001), iax2_key_rotate, vpvt);
 
    snprintf(key, sizeof(key), "%lX", (unsigned long)ast_random());
 
    MD5Init(&md5);
    MD5Update(&md5, (unsigned char *) key, strlen(key));
    MD5Final((unsigned char *) key, &md5);
 
    IAX_DEBUGDIGEST("Sending", key);
 
    iax_ie_append_raw(&ied, IAX_IE_CHALLENGE, key, 16);
 
    res = send_command(pvt, AST_FRAME_IAX, IAX_COMMAND_RTKEY, 0, ied.buf, ied.pos, -1);
 
    build_ecx_key((unsigned char *) key, pvt);
 
    ast_mutex_unlock(&iaxsl[pvt->callno]);
 
    return res;
}

References AST_FRAME_IAX, ast_mutex_lock, ast_mutex_unlock, ast_random(), ast_sched_add(), iax_ie_data::buf, build_ecx_key(), chan_iax2_pvt::callno, iax2_key_rotate(), IAX_COMMAND_RTKEY, IAX_DEBUGDIGEST, iax_ie_append_raw(), IAX_IE_CHALLENGE, iaxsl, chan_iax2_pvt::keyrotateid, md5(), MD5Final(), MD5Init(), MD5Update(), iax_ie_data::pos, and send_command().

Referenced by iax2_key_rotate(), and iax2_send().

iax2_lock_callno_unless_destroyed()

static int iax2_lock_callno_unless_destroyed ( int  callno )

static

Acquire the iaxsl[callno] if call exists and not having ongoing hangup.

Parameters

callno

Call number to lock.

Return values

0	If call disappeared or has ongoing hangup procedure.
1	If call found and mutex is locked.

Definition at line 1771 of file chan_iax2.c.

{
    ast_mutex_lock(&iaxsl[callno]);
 
    /* We acquired the lock; but the call was already destroyed (we came after full hang up procedures)
     * or destroy initiated (in middle of hang up procedure. */
    if (!iaxs[callno] || iaxs[callno]->destroy_initiated) {
        ast_debug(3, "I wanted to lock callno %d, but it is dead or going to die.\n", callno);
        ast_mutex_unlock(&iaxsl[callno]);
        return 0;
    }
 
    /* Lock acquired, and callno is alive and kicking. */
    return 1;
}

References ast_debug, ast_mutex_lock, ast_mutex_unlock, iax2_thread::callno, iaxs, and iaxsl.

Referenced by __send_lagrq(), and __send_ping().

iax2_lock_owner()

static void iax2_lock_owner ( int  callno )

static

Definition at line 1406 of file chan_iax2.c.

{
    for (;;) {
        if (!iaxs[callno] || !iaxs[callno]->owner) {
            /* There is no owner lock to get. */
            break;
        }
        if (!ast_channel_trylock(iaxs[callno]->owner)) {
            /* We got the lock */
            break;
        }
        /* Avoid deadlock by pausing and trying again */
        DEADLOCK_AVOIDANCE(&iaxsl[callno]);
    }
}

References ast_channel_trylock, DEADLOCK_AVOIDANCE, iaxs, and iaxsl.

Referenced by iax2_queue_frame(), iax2_queue_hangup(), iax2_queue_hold(), iax2_queue_unhold(), set_hangup_source_and_cause(), and socket_process_helper().

iax2_matchmore()

static int iax2_matchmore ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Part of the IAX2 Switch interface.

Definition at line 14528 of file chan_iax2.c.

{
    int res = 0;
    struct iax2_dpcache *dp = NULL;
#if 0
    ast_log(LOG_NOTICE, "iax2_matchmore: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
#endif
    if ((priority != 1) && (priority != 2))
        return 0;
 
    AST_LIST_LOCK(&dpcache);
    if ((dp = find_cache(chan, data, context, exten, priority))) {
        if (dp->flags & CACHE_FLAG_MATCHMORE)
            res = 1;
    } else {
        ast_log(LOG_WARNING, "Unable to make DP cache\n");
    }
    AST_LIST_UNLOCK(&dpcache);
 
    return res;
}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_MATCHMORE, voicemailpwcheck::context, iax2_dpcache::exten, find_cache(), iax2_dpcache::flags, LOG_NOTICE, LOG_WARNING, NULL, and priority.

iax2_parse_allow_disallow()

static int iax2_parse_allow_disallow ( struct iax2_codec_pref *  pref, iax2_format *  formats, const char *  list, int  allowing  )

static

Definition at line 2002 of file chan_iax2.c.

{
    int res, i;
    struct ast_format_cap *cap;
 
    /* We want to add the formats to the cap in the preferred order */
    cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
        ao2_cleanup(cap);
        return 1;
    }
 
    res = ast_format_cap_update_by_allow_disallow(cap, list, allowing);
 
    /* Adjust formats bitfield and pref list to match. */
    *formats = iax2_format_compatibility_cap2bitfield(cap);
    iax2_codec_pref_remove_missing(pref, *formats);
 
    for (i = 0; i < ast_format_cap_count(cap); i++) {
        struct ast_format *fmt = ast_format_cap_get_format(cap, i);
 
        iax2_codec_pref_append(pref, fmt, ast_format_cap_get_format_framing(cap, fmt));
        ao2_ref(fmt, -1);
    }
 
    ao2_ref(cap, -1);
 
    return res;
}

References ao2_cleanup, ao2_ref, ast_format_cap_alloc, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format(), ast_format_cap_get_format_framing(), ast_format_cap_update_by_allow_disallow(), iax2_codec_pref_append(), iax2_codec_pref_remove_missing(), iax2_codec_pref_to_cap(), and iax2_format_compatibility_cap2bitfield().

Referenced by build_peer(), build_user(), and set_config().

iax2_poke_noanswer()

static int iax2_poke_noanswer ( const void *  data )

static

Definition at line 12564 of file chan_iax2.c.

{
    struct iax2_peer *peer = (struct iax2_peer *)data;
    peer->pokeexpire = -1;
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__iax2_poke_noanswer, data))
#endif
        __iax2_poke_noanswer(data);
    peer_unref(peer);
    return 0;
}

References __iax2_poke_noanswer(), peer_unref(), iax2_peer::pokeexpire, and schedule_action.

Referenced by iax2_poke_peer().

iax2_poke_peer()

static int iax2_poke_peer ( struct iax2_peer *  peer, int  heldcall  )

static

Definition at line 12585 of file chan_iax2.c.

{
    int callno;
    int poke_timeout;
 
    if (!peer->maxms || (ast_sockaddr_isnull(&peer->addr) && !peer->dnsmgr)) {
        /* IF we have no IP without dnsmgr, or this isn't to be monitored, return
          immediately after clearing things out */
        peer->lastms = 0;
        peer->historicms = 0;
        peer->pokeexpire = -1;
        peer->callno = 0;
        return 0;
    }
 
    /* The peer could change the callno inside iax2_destroy, since we do deadlock avoidance */
    if ((callno = peer->callno) > 0) {
        ast_log(LOG_NOTICE, "Still have a callno...\n");
        ast_mutex_lock(&iaxsl[callno]);
        iax2_destroy(callno);
        ast_mutex_unlock(&iaxsl[callno]);
    }
    if (heldcall)
        ast_mutex_unlock(&iaxsl[heldcall]);
    callno = peer->callno = find_callno(0, 0, &peer->addr, NEW_FORCE, peer->sockfd, 0);
    if (heldcall)
        ast_mutex_lock(&iaxsl[heldcall]);
    if (callno < 1) {
        ast_log(LOG_WARNING, "Unable to allocate call for poking peer '%s'\n", peer->name);
        return -1;
    }
 
    if (peer->pokeexpire > -1) {
        if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
            peer->pokeexpire = -1;
            peer_unref(peer);
        }
    }
 
    if (peer->lastms < 0){
        /* If the host is already unreachable then use time less than the unreachable
         * interval. 5/6 is arbitrary multiplier to get value less than
         * peer->pokefreqnotok. Value less than peer->pokefreqnotok is used to expire
         * current POKE before starting new POKE (which is scheduled after
         * peer->pokefreqnotok). */
        poke_timeout = peer->pokefreqnotok * 5  / 6;
    } else {
        /* If the host is reachable, use timeout large enough to allow for multiple
         * POKE retries. Limit this value to less than peer->pokefreqok. 5/6 is arbitrary
         * multiplier to get value less than peer->pokefreqok. Value less than
         * peer->pokefreqok is used to expire current POKE before starting new POKE
         * (which is scheduled after peer->pokefreqok). */
        poke_timeout = MIN(MAX_RETRY_TIME * 2 + peer->maxms, peer->pokefreqok * 5  / 6);
    }
 
    /* Queue up a new task to handle no reply */
    peer->pokeexpire = iax2_sched_add(sched, poke_timeout, iax2_poke_noanswer, peer_ref(peer));
 
    if (peer->pokeexpire == -1)
        peer_unref(peer);
 
    /* And send the poke */
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        struct iax_ie_data ied = {
            .buf = { 0 },
            .pos = 0,
        };
 
        /* Speed up retransmission times for this qualify call */
        iaxs[callno]->pingtime = peer->maxms / 8;
        iaxs[callno]->peerpoke = peer;
 
        add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
        send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_POKE, 0, ied.buf, ied.pos, -1);
    }
    ast_mutex_unlock(&iaxsl[callno]);
 
    return 0;
}

References add_empty_calltoken_ie(), iax2_peer::addr, AST_FRAME_IAX, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_SCHED_DEL, ast_sockaddr_isnull(), iax_ie_data::buf, iax2_peer::callno, iax2_peer::dnsmgr, find_callno(), iax2_peer::historicms, iax2_destroy(), iax2_poke_noanswer(), iax2_sched_add(), IAX_COMMAND_POKE, iaxs, iaxsl, iax2_peer::lastms, LOG_NOTICE, LOG_WARNING, MAX_RETRY_TIME, iax2_peer::maxms, MIN, iax2_peer::name, NEW_FORCE, peer_ref(), peer_unref(), chan_iax2_pvt::peerpoke, chan_iax2_pvt::pingtime, iax2_peer::pokeexpire, iax2_peer::pokefreqnotok, iax2_peer::pokefreqok, iax_ie_data::pos, send_command(), and iax2_peer::sockfd.

Referenced by __iax2_poke_peer_s(), iax2_poke_peer_cb(), poke_all_peers(), reg_source_db(), and update_registry().

iax2_poke_peer_cb()

static int iax2_poke_peer_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 12576 of file chan_iax2.c.

{
    struct iax2_peer *peer = obj;
 
    iax2_poke_peer(peer, 0);
 
    return 0;
}

References iax2_poke_peer().

Referenced by load_module().

iax2_poke_peer_s()

static int iax2_poke_peer_s ( const void *  data )

static

Definition at line 9580 of file chan_iax2.c.

{
    struct iax2_peer *peer = (struct iax2_peer *)data;
    peer->pokeexpire = -1;
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__iax2_poke_peer_s, data))
#endif
        __iax2_poke_peer_s(data);
    return 0;
}

References __iax2_poke_peer_s(), iax2_peer::pokeexpire, and schedule_action.

Referenced by __iax2_poke_noanswer(), and socket_process_helper().

iax2_predestroy()

static int iax2_predestroy ( int  callno )

static

Note

Since this function calls iax2_queue_hangup(), the pvt struct for the given call number may disappear during its execution.

Definition at line 3509 of file chan_iax2.c.

{
    struct ast_channel *c = NULL;
    struct chan_iax2_pvt *pvt = iaxs[callno];
 
    if (!pvt)
        return -1;
 
    if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
        iax2_destroy_helper(pvt);
        ast_set_flag64(pvt, IAX_ALREADYGONE);
    }
 
    if ((c = pvt->owner)) {
        ast_channel_tech_pvt_set(c, NULL);
        iax2_queue_hangup(callno);
        pvt->owner = NULL;
        ast_module_unref(ast_module_info->self);
    }
 
    return 0;
}

References ast_channel_tech_pvt_set(), ast_module_unref, ast_set_flag64, ast_test_flag64, c, chan_iax2_pvt::callno, iax2_destroy_helper(), iax2_queue_hangup(), IAX_ALREADYGONE, iaxs, NULL, chan_iax2_pvt::owner, and ast_module_info::self.

Referenced by iax2_hangup(), and send_command_final().

iax2_process_thread()

static void * iax2_process_thread ( void *  data )

static

Note

For some reason, idle threads are exiting without being removed from an idle list, which is causing memory corruption. Forcibly remove it from the list, if it's there.

Definition at line 12208 of file chan_iax2.c.

{
    struct iax2_thread *thread = data;
    struct timeval wait;
    struct timespec ts;
    int put_into_idle = 0;
    int first_time = 1;
    int old_state;
 
    ast_atomic_fetchadd_int(&iaxactivethreadcount, 1);
 
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
    pthread_cleanup_push(iax2_process_thread_cleanup, data);
 
    for (;;) {
        /* Wait for something to signal us to be awake */
        ast_mutex_lock(&thread->lock);
 
        if (thread->stop) {
            ast_mutex_unlock(&thread->lock);
            break;
        }
 
        /* Flag that we're ready to accept signals */
        if (first_time) {
            signal_condition(&thread->init_lock, &thread->init_cond);
            first_time = 0;
        }
 
        /* Put into idle list if applicable */
        if (put_into_idle) {
            insert_idle_thread(thread);
        }
 
        if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
            struct iax2_thread *t = NULL;
            /* Wait to be signalled or time out */
            wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
            ts.tv_sec = wait.tv_sec;
            ts.tv_nsec = wait.tv_usec * 1000;
            if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
                /* This thread was never put back into the available dynamic
                 * thread list, so just go away. */
                if (!put_into_idle || thread->stop) {
                    ast_mutex_unlock(&thread->lock);
                    break;
                }
                AST_LIST_LOCK(&dynamic_list);
                /* Account for the case where this thread is acquired *right* after a timeout */
                if ((t = AST_LIST_REMOVE(&dynamic_list, thread, list)))
                    ast_atomic_fetchadd_int(&iaxdynamicthreadcount, -1);
                AST_LIST_UNLOCK(&dynamic_list);
                if (t) {
                    /* This dynamic thread timed out waiting for a task and was
                     * not acquired immediately after the timeout,
                     * so it's time to go away. */
                    ast_mutex_unlock(&thread->lock);
                    break;
                }
                /* Someone grabbed our thread *right* after we timed out.
                 * Wait for them to set us up with something to do and signal
                 * us to continue. */
                wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
                ts.tv_sec = wait.tv_sec;
                ts.tv_nsec = wait.tv_usec * 1000;
                if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
                    ast_mutex_unlock(&thread->lock);
                    break;
                }
            }
        } else {
            ast_cond_wait(&thread->cond, &thread->lock);
        }
 
        /* Go back into our respective list */
        put_into_idle = 1;
 
        ast_mutex_unlock(&thread->lock);
 
        if (thread->stop) {
            break;
        }
 
        /* See what we need to do */
        switch (thread->iostate) {
        case IAX_IOSTATE_IDLE:
            continue;
        case IAX_IOSTATE_READY:
            thread->actions++;
            thread->iostate = IAX_IOSTATE_PROCESSING;
            socket_process(thread);
            handle_deferred_full_frames(thread);
            break;
        case IAX_IOSTATE_SCHEDREADY:
            thread->actions++;
            thread->iostate = IAX_IOSTATE_PROCESSING;
#ifdef SCHED_MULTITHREADED
            thread->schedfunc(thread->scheddata);
#endif
            break;
        default:
            break;
        }
 
        /* The network thread added us to the active_thread list when we were given
         * frames to process, Now that we are done, we must remove ourselves from
         * the active list, and return to the idle list */
        AST_LIST_LOCK(&active_list);
        AST_LIST_REMOVE(&active_list, thread, list);
        AST_LIST_UNLOCK(&active_list);
 
        /* Make sure another frame didn't sneak in there after we thought we were done. */
        handle_deferred_full_frames(thread);
 
        time(&thread->checktime);
        thread->iostate = IAX_IOSTATE_IDLE;
#ifdef DEBUG_SCHED_MULTITHREAD
        thread->curfunc[0]='\0';
#endif
    }
 
    /*!
     * \note For some reason, idle threads are exiting without being
     * removed from an idle list, which is causing memory
     * corruption.  Forcibly remove it from the list, if it's there.
     */
    AST_LIST_LOCK(&idle_list);
    AST_LIST_REMOVE(&idle_list, thread, list);
    AST_LIST_UNLOCK(&idle_list);
 
    AST_LIST_LOCK(&dynamic_list);
    AST_LIST_REMOVE(&dynamic_list, thread, list);
    AST_LIST_UNLOCK(&dynamic_list);
 
    if (!thread->stop) {
        /* Nobody asked me to stop so nobody is waiting to join me. */
        pthread_detach(pthread_self());
    }
 
    /* I am exiting here on my own volition, I need to clean up my own data structures
    * Assume that I am no longer in any of the lists (idle, active, or dynamic)
    */
    pthread_cleanup_pop(1);
    return NULL;
}

References ast_atomic_fetchadd_int(), ast_cond_timedwait, ast_cond_wait, AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_tvadd(), ast_tvnow(), handle_deferred_full_frames(), iax2_process_thread_cleanup(), IAX_IOSTATE_IDLE, IAX_IOSTATE_PROCESSING, IAX_IOSTATE_READY, IAX_IOSTATE_SCHEDREADY, IAX_THREAD_TYPE_DYNAMIC, iaxactivethreadcount, iaxdynamicthreadcount, insert_idle_thread(), iax2_thread::list, NULL, signal_condition(), socket_process(), and thread.

Referenced by find_idle_thread(), and start_network_thread().

iax2_process_thread_cleanup()

static void iax2_process_thread_cleanup ( void *  data )

static

Definition at line 12196 of file chan_iax2.c.

{
    struct iax2_thread *thread = data;
    ast_mutex_destroy(&thread->lock);
    ast_cond_destroy(&thread->cond);
    ast_mutex_destroy(&thread->init_lock);
    ast_cond_destroy(&thread->init_cond);
    ast_free(thread);
    /* Ignore check_return warning from Coverity for ast_atomic_dec_and_test below */
    ast_atomic_dec_and_test(&iaxactivethreadcount);
}

References ast_atomic_dec_and_test(), ast_cond_destroy, ast_free, ast_mutex_destroy, iaxactivethreadcount, and thread.

Referenced by iax2_process_thread().

iax2_provision()

static int iax2_provision ( struct ast_sockaddr *  end, int  sockfd, const char *  dest, const char *  template, int  force  )

static

Definition at line 12415 of file chan_iax2.c.

{
    /* Returns 1 if provisioned, -1 if not able to find destination, or 0 if no provisioning
       is found for template */
    struct iax_ie_data provdata;
    struct iax_ie_data ied;
    unsigned int sig;
    struct ast_sockaddr addr;
    int callno;
    struct create_addr_info cai;
 
    memset(&cai, 0, sizeof(cai));
 
    ast_debug(1, "Provisioning '%s' from template '%s'\n", dest, template);
 
    if (iax_provision_build(&provdata, &sig, template, force)) {
        ast_debug(1, "No provisioning found for template '%s'\n", template);
        return 0;
    }
 
    if (end) {
        ast_sockaddr_copy(&addr, end);
        cai.sockfd = sockfd;
    } else if (create_addr(dest, NULL, &addr, &cai))
        return -1;
 
    /* Build the rest of the message */
    memset(&ied, 0, sizeof(ied));
    iax_ie_append_raw(&ied, IAX_IE_PROVISIONING, provdata.buf, provdata.pos);
 
    callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
    if (!callno)
        return -1;
 
    if (iaxs[callno]) {
        /* Schedule autodestruct in case they don't ever give us anything back */
        iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
            sched, 15000, auto_hangup, (void *)(long)callno);
        ast_set_flag64(iaxs[callno], IAX_PROVISION);
        /* Got a call number now, so go ahead and send the provisioning information */
        send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PROVISION, 0, ied.buf, ied.pos, -1);
    }
    ast_mutex_unlock(&iaxsl[callno]);
 
    return 1;
}

References ast_debug, AST_FRAME_IAX, ast_mutex_unlock, ast_set_flag64, ast_sockaddr_copy(), auto_hangup(), chan_iax2_pvt::autoid, iax_ie_data::buf, create_addr(), end, find_callno_locked(), iax2_sched_replace(), IAX_COMMAND_PROVISION, iax_ie_append_raw(), IAX_IE_PROVISIONING, IAX_PROVISION, iax_provision_build(), iaxs, iaxsl, NEW_FORCE, NULL, iax_ie_data::pos, send_command(), and create_addr_info::sockfd.

Referenced by check_provisioning(), handle_cli_iax2_provision(), and iax2_prov_app().

iax2_publish_registry()

static void iax2_publish_registry ( const char *  username, const char *  domain, const char *  status, const char *  cause  )

static

Definition at line 8892 of file chan_iax2.c.

{
    ast_system_publish_registry("IAX2", username, domain, status, cause);
}

References ast_system_publish_registry(), and status.

Referenced by iax2_ack_registry(), and socket_process_helper().

iax2_queryoption()

static int iax2_queryoption ( struct ast_channel *  c, int  option, void *  data, int *  datalen  )

static

Definition at line 5556 of file chan_iax2.c.

{
    switch (option) {
    case AST_OPTION_SECURE_SIGNALING:
    case AST_OPTION_SECURE_MEDIA:
    {
        unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
        ast_mutex_lock(&iaxsl[callno]);
        *((int *) data) = ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT) ? 1 : 0;
        ast_mutex_unlock(&iaxsl[callno]);
        return 0;
    }
    default:
        return -1;
    }
}

References ast_channel_tech_pvt(), ast_mutex_lock, ast_mutex_unlock, AST_OPTION_SECURE_MEDIA, AST_OPTION_SECURE_SIGNALING, ast_test_flag64, c, chan_iax2_pvt::callno, IAX_FORCE_ENCRYPT, iaxs, iaxsl, and PTR_TO_CALLNO.

iax2_queue_frame()

static int iax2_queue_frame ( int  callno, struct ast_frame *  f  )

static

Queue a frame to a call's owning asterisk channel.

Precondition

This function assumes that iaxsl[callno] is locked when called.

Note

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it. This function may unlock and lock the mutex associated with this callno, meaning that another thread may grab it and destroy the call.

Definition at line 3326 of file chan_iax2.c.

{
    iax2_lock_owner(callno);
    if (iaxs[callno] && iaxs[callno]->owner) {
        ast_queue_frame(iaxs[callno]->owner, f);
        ast_channel_unlock(iaxs[callno]->owner);
    }
    return 0;
}

References ast_channel_unlock, ast_queue_frame(), chan_iax2_pvt::callno, iax2_lock_owner(), iaxs, and chan_iax2_pvt::owner.

Referenced by __attempt_transmit(), __auto_congest(), __do_deliver(), __get_from_jb(), and socket_process_helper().

iax2_queue_hangup()

static int iax2_queue_hangup ( int  callno )

static

Queue a hangup frame on the ast_channel owner.

This function queues a hangup frame on the owner of the IAX2 pvt struct that is active for the given call number.

Precondition

Assumes lock for callno is already held.

Note

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it. This function may unlock and lock the mutex associated with this callno, meaning that another thread may grab it and destroy the call.

Definition at line 3395 of file chan_iax2.c.

{
    iax2_lock_owner(callno);
    if (iaxs[callno] && iaxs[callno]->owner) {
        ast_queue_hangup(iaxs[callno]->owner);
        ast_channel_unlock(iaxs[callno]->owner);
    }
    return 0;
}

References ast_channel_unlock, ast_queue_hangup(), chan_iax2_pvt::callno, iax2_lock_owner(), iaxs, and chan_iax2_pvt::owner.

Referenced by iax2_predestroy().

iax2_queue_hold()

static int iax2_queue_hold ( int  callno, const char *  musicclass  )

static

Queue a hold frame on the ast_channel owner.

This function queues a hold frame on the owner of the IAX2 pvt struct that is active for the given call number.

Precondition

Assumes lock for callno is already held.

Note

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it. This function may unlock and lock the mutex associated with this callno, meaning that another thread may grab it and destroy the call.

Definition at line 3349 of file chan_iax2.c.

{
    iax2_lock_owner(callno);
    if (iaxs[callno] && iaxs[callno]->owner) {
        ast_queue_hold(iaxs[callno]->owner, musicclass);
        ast_channel_unlock(iaxs[callno]->owner);
    }
    return 0;
}

References ast_channel_unlock, ast_queue_hold(), chan_iax2_pvt::callno, iax2_lock_owner(), iaxs, and chan_iax2_pvt::owner.

Referenced by socket_process_helper().

iax2_queue_unhold()

static int iax2_queue_unhold ( int  callno )

static

Queue an unhold frame on the ast_channel owner.

This function queues an unhold frame on the owner of the IAX2 pvt struct that is active for the given call number.

Precondition

Assumes lock for callno is already held.

Note

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it. This function may unlock and lock the mutex associated with this callno, meaning that another thread may grab it and destroy the call.

Definition at line 3372 of file chan_iax2.c.

{
    iax2_lock_owner(callno);
    if (iaxs[callno] && iaxs[callno]->owner) {
        ast_queue_unhold(iaxs[callno]->owner);
        ast_channel_unlock(iaxs[callno]->owner);
    }
    return 0;
}

References ast_channel_unlock, ast_queue_unhold(), chan_iax2_pvt::callno, iax2_lock_owner(), iaxs, and chan_iax2_pvt::owner.

Referenced by socket_process_helper().

iax2_read()

static struct ast_frame * iax2_read ( struct ast_channel *  c )

static

Definition at line 5573 of file chan_iax2.c.

{
    ast_debug(1, "I should never be called!\n");
    return &ast_null_frame;
}

References ast_debug, and ast_null_frame.

iax2_register()

static int iax2_register ( const char *  value, int  lineno  )

static

Definition at line 9006 of file chan_iax2.c.

{
    char copy[256];
    char *username, *hostname, *secret;
    char *porta;
    char *stringp=NULL;
 
    if (!value)
        return -1;
 
    ast_copy_string(copy, value, sizeof(copy));
    stringp = copy;
    username = strsep(&stringp, "@");
    hostname = strsep(&stringp, "@");
 
    if (!hostname) {
        ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d\n", lineno);
        return -1;
    }
 
    stringp = username;
    username = strsep(&stringp, ":");
    secret = strsep(&stringp, ":");
    stringp = hostname;
    hostname = strsep(&stringp, ":");
    porta = strsep(&stringp, ":");
 
    if (porta && !atoi(porta)) {
        ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
        return -1;
    }
 
    return iax2_append_register(hostname, username, secret, porta);
}

References ast_copy_string(), ast_log, copy(), hostname, iax2_append_register(), LOG_WARNING, NULL, iax2_registry::secret, strsep(), iax2_registry::username, and value.

Referenced by set_config().

iax2_request()

static struct ast_channel * iax2_request ( const char *  type, struct ast_format_cap *  cap, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  data, int *  cause  )

static

Definition at line 12676 of file chan_iax2.c.

{
    int callno;
    int res;
    struct ast_sockaddr addr;
    struct ast_channel *c;
    struct parsed_dial_string pds;
    struct create_addr_info cai;
    char *tmpstr;
    ast_callid callid;
 
    memset(&pds, 0, sizeof(pds));
    tmpstr = ast_strdupa(data);
    parse_dial_string(tmpstr, &pds);
 
    callid = ast_read_threadstorage_callid();
 
    if (ast_strlen_zero(pds.peer)) {
        ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
        return NULL;
    }
    memset(&cai, 0, sizeof(cai));
    cai.capability = iax2_capability;
 
    ast_copy_flags64(&cai, &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
 
    /* Populate our address from the given */
    if (create_addr(pds.peer, NULL, &addr, &cai)) {
        *cause = AST_CAUSE_UNREGISTERED;
        return NULL;
    }
 
    if (pds.port) {
        int bindport;
        ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535);
        ast_sockaddr_set_port(&addr, bindport);
    }
 
    callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
    if (callno < 1) {
        ast_log(LOG_WARNING, "Unable to create call\n");
        *cause = AST_CAUSE_CONGESTION;
        return NULL;
    }
 
    /* If this is a trunk, update it now */
    ast_copy_flags64(iaxs[callno], &cai, IAX_TRUNK | IAX_SENDANI | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
    if (ast_test_flag64(&cai, IAX_TRUNK)) {
        int new_callno;
        if ((new_callno = make_trunk(callno, 1)) != -1)
            callno = new_callno;
    }
    iaxs[callno]->maxtime = cai.maxtime;
    if (callid) {
        iax_pvt_callid_set(callno, callid);
    }
 
    if (cai.found) {
        ast_string_field_set(iaxs[callno], host, pds.peer);
    }
 
    c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, &cai.prefs, assignedids,
        requestor, cai.found);
 
    ast_mutex_unlock(&iaxsl[callno]);
 
    if (c) {
        struct ast_format_cap *joint;
        struct ast_format *format;
        if (callid) {
            ast_channel_lock(c);
            ast_channel_callid_set(c, callid);
            ast_channel_unlock(c);
        }
 
        joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        if (!joint) {
            ast_hangup(c);
            return NULL;
        }
 
        ast_format_cap_get_compatible(ast_channel_nativeformats(c), cap, joint);
 
        /* If there is no joint format find one through translation */
        if (!ast_format_cap_count(joint)) {
            struct ast_format *best_fmt_cap = NULL;
            struct ast_format *best_fmt_native = NULL;
 
            res = ast_translator_best_choice(cap, ast_channel_nativeformats(c), &best_fmt_cap, &best_fmt_native);
            if (res < 0) {
                struct ast_str *native_cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                ast_log(LOG_WARNING, "Unable to create translator path for %s to %s on %s\n",
                    ast_format_cap_get_names(ast_channel_nativeformats(c), &native_cap_buf),
                    ast_format_cap_get_names(cap, &cap_buf),
                    ast_channel_name(c));
                ast_hangup(c);
                ao2_ref(joint, -1);
                return NULL;
            }
            ast_format_cap_append(joint, best_fmt_native, 0);
            ao2_ref(best_fmt_cap, -1);
            ao2_ref(best_fmt_native, -1);
        }
        ast_channel_nativeformats_set(c, joint);
        format = ast_format_cap_get_format(ast_channel_nativeformats(c), 0);
        ast_channel_set_readformat(c, format);
        ast_channel_set_writeformat(c, format);
 
        ao2_ref(joint, -1);
        ao2_ref(format, -1);
    }
 
    return c;
}

References ao2_ref, AST_CAUSE_CONGESTION, AST_CAUSE_UNREGISTERED, ast_channel_callid_set(), ast_channel_lock, ast_channel_name(), ast_channel_nativeformats(), ast_channel_nativeformats_set(), ast_channel_set_readformat(), ast_channel_set_writeformat(), ast_channel_unlock, ast_copy_flags64, ast_format_cap_alloc, ast_format_cap_append, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_compatible(), ast_format_cap_get_format(), ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_hangup(), ast_iax2_new(), ast_log, ast_mutex_unlock, ast_parse_arg(), ast_read_threadstorage_callid(), ast_sockaddr_set_port, AST_STATE_DOWN, ast_str_alloca, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, ast_translator_best_choice(), c, create_addr_info::capability, create_addr(), find_callno_locked(), create_addr_info::found, globalflags, iax2_capability, IAX_NOTRANSFER, iax_pvt_callid_set(), IAX_RECVCONNECTEDLINE, IAX_SENDANI, IAX_SENDCONNECTEDLINE, IAX_TRANSFERMEDIA, IAX_TRUNK, IAX_USEJITTERBUF, iaxs, iaxsl, LOG_WARNING, make_trunk(), chan_iax2_pvt::maxtime, create_addr_info::maxtime, NEW_FORCE, NULL, parse_dial_string(), PARSE_IN_RANGE, PARSE_UINT32, parsed_dial_string::peer, parsed_dial_string::port, create_addr_info::prefs, and create_addr_info::sockfd.

iax2_sched_add()

static int iax2_sched_add ( struct ast_sched_context *  sched, int  when, ast_sched_cb  callback, const void *  data  )

static

Definition at line 1759 of file chan_iax2.c.

{
    return ast_sched_add(con, when, callback, data);
}

References ast_sched_add(), and callback().

Referenced by __attempt_transmit(), __find_callno(), __iax2_poke_noanswer(), __send_lagrq(), __send_ping(), iax2_call(), iax2_destroy_helper(), iax2_poke_peer(), make_trunk(), network_change_stasis_cb(), realtime_peer(), reg_source_db(), sched_delay_remove(), socket_process_helper(), transmit_frame(), and update_registry().

iax2_sched_replace()

static int iax2_sched_replace ( int  id, struct ast_sched_context *  con, int  when, ast_sched_cb  callback, const void *  data  )

static

Definition at line 1753 of file chan_iax2.c.

{
    return ast_sched_replace(id, con, when, callback, data);
}

References ast_sched_replace(), and callback().

Referenced by auth_fail(), iax2_ack_registry(), iax2_do_register(), iax2_dprequest(), iax2_provision(), and update_jbsched().

iax2_send()

static int iax2_send ( struct chan_iax2_pvt *  pvt, struct ast_frame *  f, unsigned int  ts, int  seqno, int  now, int  transfer, int  final  )

static

Definition at line 6683 of file chan_iax2.c.

{
    /* Queue a packet for delivery on a given private structure.  Use "ts" for
       timestamp, or calculate if ts is 0.  Send immediately without retransmission
       or delayed, with retransmission */
    struct ast_iax2_full_hdr *fh;
    struct ast_iax2_mini_hdr *mh;
    struct ast_iax2_video_hdr *vh;
    struct {
        struct iax_frame fr2;
        unsigned char buffer[4096];
    } frb;
    struct iax_frame *fr;
    int res;
    int sendmini=0;
    unsigned int lastsent;
    unsigned int fts;
 
    frb.fr2.afdatalen = sizeof(frb.buffer);
 
    if (!pvt) {
        ast_log(LOG_WARNING, "No private structure for packet?\n");
        return -1;
    }
 
    lastsent = pvt->lastsent;
 
    /* Calculate actual timestamp */
    fts = calc_timestamp(pvt, ts, f);
 
    /* Bail here if this is an "interp" frame; we don't want or need to send these placeholders out
     * (the endpoint should detect the lost packet itself).  But, we want to do this here, so that we
     * increment the "predicted timestamps" for voice, if we're predicting */
    if(f->frametype == AST_FRAME_VOICE && f->datalen == 0)
        return 0;
#if 0
    ast_log(LOG_NOTICE,
        "f->frametype %c= AST_FRAME_VOICE, %sencrypted, %srotation scheduled...\n",
        *("=!" + (f->frametype == AST_FRAME_VOICE)),
        IAX_CALLENCRYPTED(pvt) ? "" : "not ",
        pvt->keyrotateid != -1 ? "" : "no "
    );
#endif
    if (pvt->keyrotateid == -1 && f->frametype == AST_FRAME_VOICE && IAX_CALLENCRYPTED(pvt)) {
        iax2_key_rotate(pvt);
    }
 
    if ((ast_test_flag64(pvt, IAX_TRUNK) ||
            (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)) ||
            ((fts & 0xFFFF0000L) == ((lastsent + 0x10000) & 0xFFFF0000L))))
        /* High two bytes are the same on timestamp, or sending on a trunk */ &&
        (f->frametype == AST_FRAME_VOICE)
        /* is a voice frame */ &&
        (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svoiceformat)) ==
            AST_FORMAT_CMP_EQUAL)
        /* is the same type */ ) {
            /* Force immediate rather than delayed transmission */
            now = 1;
            /* Mark that mini-style frame is appropriate */
            sendmini = 1;
    }
    if ( f->frametype == AST_FRAME_VIDEO ) {
        /*
         * If the lower 15 bits of the timestamp roll over, or if
         * the video format changed then send a full frame.
         * Otherwise send a mini video frame
         */
        if (((fts & 0xFFFF8000L) == (pvt->lastvsent & 0xFFFF8000L)) &&
        (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svideoformat)) ==
            AST_FORMAT_CMP_EQUAL)
           ) {
            now = 1;
            sendmini = 1;
        } else {
            now = 0;
            sendmini = 0;
        }
        pvt->lastvsent = fts;
    }
    if (f->frametype == AST_FRAME_IAX) {
        /* 0x8000 marks this message as TX:, this bit will be stripped later */
        pvt->last_iax_message = f->subclass.integer | MARK_IAX_SUBCLASS_TX;
        if (!pvt->first_iax_message) {
            pvt->first_iax_message = pvt->last_iax_message;
        }
    }
    /* Allocate an iax_frame */
    if (now) {
        fr = &frb.fr2;
    } else
        fr = iax_frame_new(DIRECTION_OUTGRESS, ast_test_flag64(pvt, IAX_ENCRYPTED) ? f->datalen + 32 : f->datalen, (f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_VIDEO));
    if (!fr) {
        ast_log(LOG_WARNING, "Out of memory\n");
        return -1;
    }
    /* Copy our prospective frame into our immediate or retransmitted wrapper */
    iax_frame_wrap(fr, f);
 
    fr->ts = fts;
    fr->callno = pvt->callno;
    fr->transfer = transfer;
    fr->final = final;
    fr->encmethods = 0;
    if (!sendmini) {
        /* We need a full frame */
        if (seqno > -1)
            fr->oseqno = seqno;
        else
            fr->oseqno = pvt->oseqno++;
        fr->iseqno = pvt->iseqno;
        fh = (struct ast_iax2_full_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_full_hdr));
        fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
        fh->ts = htonl(fr->ts);
        fh->oseqno = fr->oseqno;
        if (transfer) {
            fh->iseqno = 0;
        } else
            fh->iseqno = fr->iseqno;
        /* Keep track of the last thing we've acknowledged */
        if (!transfer)
            pvt->aseqno = fr->iseqno;
        fh->type = fr->af.frametype & 0xFF;
 
        if (fr->af.frametype == AST_FRAME_VIDEO) {
            iax2_format tmpfmt = ast_format_compatibility_format2bitfield(fr->af.subclass.format);
            tmpfmt |= fr->af.subclass.frame_ending ? 0x1LL : 0;
            fh->csub = compress_subclass(tmpfmt | ((tmpfmt & 0x1LL) << 6));
        } else if (fr->af.frametype == AST_FRAME_VOICE) {
            fh->csub = compress_subclass(ast_format_compatibility_format2bitfield(fr->af.subclass.format));
        } else {
            fh->csub = compress_subclass(fr->af.subclass.integer);
        }
 
        if (transfer) {
            fr->dcallno = pvt->transfercallno;
        } else
            fr->dcallno = pvt->peercallno;
        fh->dcallno = htons(fr->dcallno);
        fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
        fr->data = fh;
        fr->retries = 0;
        /* Retry after 2x the ping time has passed */
        fr->retrytime = pvt->pingtime * 2;
        if (fr->retrytime < MIN_RETRY_TIME)
            fr->retrytime = MIN_RETRY_TIME;
        if (fr->retrytime > MAX_RETRY_TIME)
            fr->retrytime = MAX_RETRY_TIME;
        /* Acks' don't get retried */
        if ((f->frametype == AST_FRAME_IAX) && (f->subclass.integer == IAX_COMMAND_ACK))
            fr->retries = -1;
        else if (f->frametype == AST_FRAME_VOICE)
            pvt->svoiceformat = ast_format_compatibility_format2bitfield(f->subclass.format);
        else if (f->frametype == AST_FRAME_VIDEO)
            pvt->svideoformat = ast_format_compatibility_format2bitfield(f->subclass.format);
        if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
            if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
                if (fr->transfer)
                    iax_outputframe(fr, NULL, 2, &pvt->transfer, fr->datalen - sizeof(struct ast_iax2_full_hdr));
                else
                    iax_outputframe(fr, NULL, 2, &pvt->addr, fr->datalen - sizeof(struct ast_iax2_full_hdr));
                encrypt_frame(&pvt->ecx, fh, pvt->semirand, &fr->datalen);
                fr->encmethods = pvt->encmethods;
                fr->ecx = pvt->ecx;
                fr->mydcx = pvt->mydcx;
                memcpy(fr->semirand, pvt->semirand, sizeof(fr->semirand));
            } else
                ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
        }
 
        if (now) {
            res = send_packet(fr);
        } else
            res = iax2_transmit(fr);
    } else {
        if (ast_test_flag64(pvt, IAX_TRUNK)) {
            iax2_trunk_queue(pvt, fr);
            res = 0;
        } else if (fr->af.frametype == AST_FRAME_VIDEO) {
            /* Video frame have no sequence number */
            fr->oseqno = -1;
            fr->iseqno = -1;
            vh = (struct ast_iax2_video_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_video_hdr));
            vh->zeros = 0;
            vh->callno = htons(0x8000 | fr->callno);
            vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass.frame_ending ? 0x8000 : 0));
            fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
            fr->data = vh;
            fr->retries = -1;
            res = send_packet(fr);
        } else {
            /* Mini-frames have no sequence number */
            fr->oseqno = -1;
            fr->iseqno = -1;
            /* Mini frame will do */
            mh = (struct ast_iax2_mini_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_mini_hdr));
            mh->callno = htons(fr->callno);
            mh->ts = htons(fr->ts & 0xFFFF);
            fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
            fr->data = mh;
            fr->retries = -1;
            if (pvt->transferring == TRANSFER_MEDIAPASS)
                fr->transfer = 1;
            if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
                if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
                    encrypt_frame(&pvt->ecx, (struct ast_iax2_full_hdr *)mh, pvt->semirand, &fr->datalen);
                } else
                    ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
            }
            res = send_packet(fr);
        }
    }
    return res;
}

References chan_iax2_pvt::addr, iax_frame::af, iax_frame::afdatalen, chan_iax2_pvt::aseqno, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_compatibility_bitfield2format(), ast_format_compatibility_format2bitfield(), AST_FRAME_IAX, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_log, ast_test_flag64, calc_timestamp(), chan_iax2_pvt::callno, ast_iax2_mini_hdr::callno, ast_iax2_video_hdr::callno, iax_frame::callno, compress_subclass(), ast_iax2_full_hdr::csub, iax_frame::data, ast_frame::data, iax_frame::datalen, ast_frame::datalen, ast_iax2_full_hdr::dcallno, iax_frame::dcallno, DIRECTION_OUTGRESS, chan_iax2_pvt::ecx, iax_frame::ecx, chan_iax2_pvt::encmethods, iax_frame::encmethods, encrypt_frame(), iax_frame::final, chan_iax2_pvt::first_iax_message, ast_frame_subclass::format, ast_frame_subclass::frame_ending, ast_frame::frametype, iax2_key_rotate(), iax2_transmit(), iax2_trunk_queue(), IAX_CALLENCRYPTED, IAX_COMMAND_ACK, IAX_ENCRYPTED, IAX_FLAG_FULL, iax_frame_new(), iax_frame_wrap(), IAX_KEYPOPULATED, iax_outputframe(), IAX_TRUNK, ast_frame_subclass::integer, chan_iax2_pvt::iseqno, ast_iax2_full_hdr::iseqno, iax_frame::iseqno, chan_iax2_pvt::keyrotateid, chan_iax2_pvt::last_iax_message, chan_iax2_pvt::lastsent, chan_iax2_pvt::lastvsent, LOG_NOTICE, LOG_WARNING, MARK_IAX_SUBCLASS_TX, MAX_RETRY_TIME, MIN_RETRY_TIME, chan_iax2_pvt::mydcx, iax_frame::mydcx, NULL, chan_iax2_pvt::oseqno, ast_iax2_full_hdr::oseqno, iax_frame::oseqno, chan_iax2_pvt::peercallno, chan_iax2_pvt::pingtime, ast_frame::ptr, iax_frame::retries, iax_frame::retrytime, ast_iax2_full_hdr::scallno, chan_iax2_pvt::semirand, iax_frame::semirand, send_packet(), ast_frame::subclass, chan_iax2_pvt::svideoformat, chan_iax2_pvt::svoiceformat, chan_iax2_pvt::transfer, transfer(), iax_frame::transfer, TRANSFER_MEDIAPASS, chan_iax2_pvt::transfercallno, chan_iax2_pvt::transferring, ast_iax2_full_hdr::ts, ast_iax2_mini_hdr::ts, ast_iax2_video_hdr::ts, iax_frame::ts, ast_iax2_full_hdr::type, and ast_iax2_video_hdr::zeros.

Referenced by __send_command(), iax2_write(), send_signaling(), and socket_process_helper().

iax2_sendhtml()

static int iax2_sendhtml ( struct ast_channel *  c, int  subclass, const char *  data, int  datalen  )

static

Definition at line 4436 of file chan_iax2.c.

{
    return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
}

References ast_channel_tech_pvt(), AST_FRAME_HTML, c, iax_frame::data, iax_frame::datalen, PTR_TO_CALLNO, and send_command_locked().

iax2_sendimage()

static int iax2_sendimage ( struct ast_channel *  c, struct ast_frame *  img  )

static

Definition at line 4431 of file chan_iax2.c.

{
    return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_IMAGE, img->subclass.integer, 0, img->data.ptr, img->datalen, -1);
}

References ast_channel_tech_pvt(), AST_FRAME_IMAGE, c, ast_frame::data, ast_frame::datalen, ast_frame_subclass::integer, ast_frame::ptr, PTR_TO_CALLNO, send_command_locked(), and ast_frame::subclass.

iax2_sendtext()

static int iax2_sendtext ( struct ast_channel *  c, const char *  text  )

static

Definition at line 4424 of file chan_iax2.c.

{
 
    return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_TEXT,
        0, 0, (unsigned char *)text, strlen(text) + 1, -1);
}

References ast_channel_tech_pvt(), AST_FRAME_TEXT, c, PTR_TO_CALLNO, send_command_locked(), and text.

iax2_setoption()

static int iax2_setoption ( struct ast_channel *  c, int  option, void *  data, int  datalen  )

static

Definition at line 5484 of file chan_iax2.c.

{
    struct ast_option_header *h;
    int res;
 
    switch (option) {
    case AST_OPTION_TXGAIN:
    case AST_OPTION_RXGAIN:
        /* these two cannot be sent, because they require a result */
        errno = ENOSYS;
        return -1;
    case AST_OPTION_OPRMODE:
        errno = EINVAL;
        return -1;
    case AST_OPTION_SECURE_SIGNALING:
    case AST_OPTION_SECURE_MEDIA:
    {
        unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
        ast_mutex_lock(&iaxsl[callno]);
        if ((*(int *) data)) {
            ast_set_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
        } else {
            ast_clear_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
        }
        ast_mutex_unlock(&iaxsl[callno]);
        return 0;
    }
    /* These options are sent to the other side across the network where
     * they will be passed to whatever channel is bridged there. Don't
     * do anything silly like pass an option that transmits pointers to
     * memory on this machine to a remote machine to use */
    case AST_OPTION_TONE_VERIFY:
    case AST_OPTION_TDD:
    case AST_OPTION_RELAXDTMF:
    case AST_OPTION_AUDIO_MODE:
    case AST_OPTION_DIGIT_DETECT:
    case AST_OPTION_FAX_DETECT:
    {
        unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
        struct chan_iax2_pvt *pvt;
 
        ast_mutex_lock(&iaxsl[callno]);
        pvt = iaxs[callno];
 
        if (wait_for_peercallno(pvt)) {
            ast_mutex_unlock(&iaxsl[callno]);
            return -1;
        }
 
        ast_mutex_unlock(&iaxsl[callno]);
 
        if (!(h = ast_malloc(datalen + sizeof(*h)))) {
            return -1;
        }
 
        h->flag = AST_OPTION_FLAG_REQUEST;
        h->option = htons(option);
        memcpy(h->data, data, datalen);
        res = send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_CONTROL,
                      AST_CONTROL_OPTION, 0, (unsigned char *) h,
                      datalen + sizeof(*h), -1);
        ast_free(h);
        return res;
    }
    default:
        return -1;
    }
 
    /* Just in case someone does a break instead of a return */
    return -1;
}

References ast_channel_tech_pvt(), ast_clear_flag64, AST_CONTROL_OPTION, AST_FRAME_CONTROL, ast_free, ast_malloc, ast_mutex_lock, ast_mutex_unlock, AST_OPTION_AUDIO_MODE, AST_OPTION_DIGIT_DETECT, AST_OPTION_FAX_DETECT, AST_OPTION_FLAG_REQUEST, AST_OPTION_OPRMODE, AST_OPTION_RELAXDTMF, AST_OPTION_RXGAIN, AST_OPTION_SECURE_MEDIA, AST_OPTION_SECURE_SIGNALING, AST_OPTION_TDD, AST_OPTION_TONE_VERIFY, AST_OPTION_TXGAIN, ast_set_flag64, c, chan_iax2_pvt::callno, ast_option_header::data, errno, IAX_FORCE_ENCRYPT, iaxs, iaxsl, PTR_TO_CALLNO, send_command_locked(), and wait_for_peercallno().

iax2_transfer()

static int iax2_transfer ( struct ast_channel *  c, const char *  dest  )

static

Definition at line 5904 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    struct iax_ie_data ied = { "", };
    char tmp[256], *context;
    enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
    ast_copy_string(tmp, dest, sizeof(tmp));
    context = strchr(tmp, '@');
    if (context) {
        *context = '\0';
        context++;
    }
    iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
    if (context)
        iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
    ast_debug(1, "Transferring '%s' to '%s'\n", ast_channel_name(c), dest);
    ast_queue_control_data(c, AST_CONTROL_TRANSFER, &message, sizeof(message));
    return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
}

References ast_channel_name(), ast_channel_tech_pvt(), AST_CONTROL_TRANSFER, ast_copy_string(), ast_debug, AST_FRAME_IAX, ast_queue_control_data(), AST_TRANSFER_SUCCESS, iax_ie_data::buf, c, chan_iax2_pvt::callno, voicemailpwcheck::context, IAX_COMMAND_TRANSFER, iax_ie_append_str(), IAX_IE_CALLED_CONTEXT, IAX_IE_CALLED_NUMBER, iax_ie_data::pos, PTR_TO_CALLNO, and send_command_locked().

iax2_transmit()

static int iax2_transmit ( struct iax_frame *  fr )

static

Definition at line 4407 of file chan_iax2.c.

{
    fr->sentyet = 0;
 
    return ast_taskprocessor_push(transmit_processor, transmit_frame, fr);
}

References ast_taskprocessor_push(), iax_frame::sentyet, transmit_frame(), and transmit_processor.

Referenced by iax2_send().

iax2_trunk_expired()

static int iax2_trunk_expired ( struct iax2_trunk_peer *  tpeer, struct timeval *  now  )

inlinestatic

Definition at line 9634 of file chan_iax2.c.

{
    /* Drop when trunk is about 5 seconds idle */
    if (now->tv_sec > tpeer->trunkact.tv_sec + 5)
        return 1;
    return 0;
}

References iax2_trunk_peer::trunkact.

Referenced by timing_read().

iax2_trunk_queue()

static int iax2_trunk_queue ( struct chan_iax2_pvt *  pvt, struct iax_frame *  fr  )

static

Definition at line 6400 of file chan_iax2.c.

{
    struct ast_frame *f;
    struct iax2_trunk_peer *tpeer;
    void *tmp, *ptr;
    struct timeval now;
    struct ast_iax2_meta_trunk_entry *met;
    struct ast_iax2_meta_trunk_mini *mtm;
 
    f = &fr->af;
    tpeer = find_tpeer(&pvt->addr, pvt->sockfd);
    if (tpeer) {
 
        if (tpeer->trunkdatalen + f->datalen + 4 >= tpeer->trunkdataalloc) {
            /* Need to reallocate space */
            if (tpeer->trunkdataalloc < trunkmaxsize) {
                if (!(tmp = ast_realloc(tpeer->trunkdata, tpeer->trunkdataalloc + DEFAULT_TRUNKDATA + IAX2_TRUNK_PREFACE))) {
                    ast_mutex_unlock(&tpeer->lock);
                    return -1;
                }
 
                tpeer->trunkdataalloc += DEFAULT_TRUNKDATA;
                tpeer->trunkdata = tmp;
                ast_debug(1, "Expanded trunk '%s' to %u bytes\n", ast_sockaddr_stringify(&tpeer->addr), tpeer->trunkdataalloc);
            } else {
                ast_log(LOG_WARNING, "Maximum trunk data space exceeded to %s\n", ast_sockaddr_stringify(&tpeer->addr));
                ast_mutex_unlock(&tpeer->lock);
                return -1;
            }
        }
 
        /* Append to meta frame */
        ptr = tpeer->trunkdata + IAX2_TRUNK_PREFACE + tpeer->trunkdatalen;
        if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS)) {
            mtm = (struct ast_iax2_meta_trunk_mini *)ptr;
            mtm->len = htons(f->datalen);
            mtm->mini.callno = htons(pvt->callno);
            mtm->mini.ts = htons(0xffff & fr->ts);
            ptr += sizeof(struct ast_iax2_meta_trunk_mini);
            tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_mini);
        } else {
            met = (struct ast_iax2_meta_trunk_entry *)ptr;
            /* Store call number and length in meta header */
            met->callno = htons(pvt->callno);
            met->len = htons(f->datalen);
            /* Advance pointers/decrease length past trunk entry header */
            ptr += sizeof(struct ast_iax2_meta_trunk_entry);
            tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
        }
        /* Copy actual trunk data */
        memcpy(ptr, f->data.ptr, f->datalen);
        tpeer->trunkdatalen += f->datalen;
 
        tpeer->calls++;
 
        /* track the largest mtu we actually have sent */
        if (tpeer->trunkdatalen + f->datalen + 4 > trunk_maxmtu)
            trunk_maxmtu = tpeer->trunkdatalen + f->datalen + 4 ;
 
        /* if we have enough for a full MTU, ship it now without waiting */
        if (global_max_trunk_mtu > 0 && tpeer->trunkdatalen + f->datalen + 4 >= global_max_trunk_mtu) {
            now = ast_tvnow();
            send_trunk(tpeer, &now);
            trunk_untimed ++;
        }
 
        ast_mutex_unlock(&tpeer->lock);
    }
    return 0;
}

References iax2_trunk_peer::addr, chan_iax2_pvt::addr, iax_frame::af, ast_debug, ast_log, ast_mutex_unlock, ast_realloc, ast_sockaddr_stringify(), ast_test_flag64, ast_tvnow(), chan_iax2_pvt::callno, ast_iax2_mini_hdr::callno, ast_iax2_meta_trunk_entry::callno, iax2_trunk_peer::calls, ast_frame::data, ast_frame::datalen, DEFAULT_TRUNKDATA, find_tpeer(), global_max_trunk_mtu, globalflags, IAX2_TRUNK_PREFACE, IAX_TRUNKTIMESTAMPS, ast_iax2_meta_trunk_entry::len, ast_iax2_meta_trunk_mini::len, iax2_trunk_peer::lock, LOG_WARNING, ast_iax2_meta_trunk_mini::mini, ast_frame::ptr, send_trunk(), chan_iax2_pvt::sockfd, trunk_maxmtu, trunk_untimed, iax2_trunk_peer::trunkdata, iax2_trunk_peer::trunkdataalloc, iax2_trunk_peer::trunkdatalen, trunkmaxsize, ast_iax2_mini_hdr::ts, and iax_frame::ts.

Referenced by iax2_send().

iax2_vnak()

static int iax2_vnak ( int  callno )

static

Definition at line 9555 of file chan_iax2.c.

{
    return send_command_immediate(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_VNAK, 0, NULL, 0, iaxs[callno]->iseqno);
}

References AST_FRAME_IAX, IAX_COMMAND_VNAK, iaxs, NULL, and send_command_immediate().

Referenced by socket_process_helper(), and socket_process_meta().

iax2_write()

static int iax2_write ( struct ast_channel *  c, struct ast_frame *  f  )

static

Definition at line 7823 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
    int res = -1;
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
    /* If there's an outstanding error, return failure now */
        if (!iaxs[callno]->error) {
            if (ast_test_flag64(iaxs[callno], IAX_ALREADYGONE))
                res = 0;
                /* Don't waste bandwidth sending null frames */
            else if (f->frametype == AST_FRAME_NULL)
                res = 0;
            else if ((f->frametype == AST_FRAME_VOICE) && ast_test_flag64(iaxs[callno], IAX_QUELCH))
                res = 0;
            else if (!ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
                res = 0;
            else
            /* Simple, just queue for transmission */
                res = iax2_send(iaxs[callno], f, 0, -1, 0, 0, 0);
        } else {
            ast_debug(1, "Write error: %s\n", strerror(errno));
        }
    }
    /* If it's already gone, just return */
    ast_mutex_unlock(&iaxsl[callno]);
    return res;
}

References ast_channel_tech_pvt(), ast_debug, AST_FRAME_NULL, AST_FRAME_VOICE, ast_mutex_lock, ast_mutex_unlock, ast_test_flag, ast_test_flag64, c, iax2_peer::callno, errno, error(), ast_frame::frametype, iax2_send(), IAX_ALREADYGONE, IAX_QUELCH, IAX_STATE_STARTED, iaxs, iaxsl, and PTR_TO_CALLNO.

iax_debug_output()

static void iax_debug_output ( const char *  data )

static

Definition at line 1270 of file chan_iax2.c.

{
    if (iaxdebug)
        ast_verbose("%s", data);
}

References ast_verbose(), and iaxdebug.

Referenced by load_module().

iax_error_output()

static void iax_error_output ( const char *  data )

static

Definition at line 1276 of file chan_iax2.c.

{
    ast_log(LOG_WARNING, "%s", data);
}

References ast_log, and LOG_WARNING.

Referenced by load_module().

iax_outputframe()

static void iax_outputframe ( struct iax_frame *  f, struct ast_iax2_full_hdr *  fhi, int  rx, struct ast_sockaddr *  addr, int  datalen  )

static

Definition at line 1252 of file chan_iax2.c.

{
    if (iaxdebug ||
        (addr && !ast_sockaddr_isnull(&debugaddr) &&
        (!ast_sockaddr_port(&debugaddr) ||
          ast_sockaddr_port(&debugaddr) == ast_sockaddr_port(addr)) &&
          !ast_sockaddr_cmp_addr(&debugaddr, addr))) {
 
        if (iaxdebug) {
            iax_showframe(f, fhi, rx, addr, datalen);
        } else {
            iaxdebug = 1;
            iax_showframe(f, fhi, rx, addr, datalen);
            iaxdebug = 0;
        }
    }
}

References ast_sockaddr_cmp_addr(), ast_sockaddr_isnull(), ast_sockaddr_port, debugaddr, iax_showframe(), and iaxdebug.

Referenced by iax2_send(), raw_hangup(), send_apathetic_reply(), send_packet(), and socket_process_helper().

iax_pvt_callid_get()

static ast_callid iax_pvt_callid_get ( int  callno )

static

Definition at line 1200 of file chan_iax2.c.

{
    return iaxs[callno]->callid;
}

References chan_iax2_pvt::callid, chan_iax2_pvt::callno, and iaxs.

Referenced by socket_process_helper().

iax_pvt_callid_new()

static void iax_pvt_callid_new ( int  callno )

static

Definition at line 1210 of file chan_iax2.c.

{
    ast_callid callid = ast_create_callid();
    char buffer[AST_CALLID_BUFFER_LENGTH];
    ast_callid_strnprint(buffer, sizeof(buffer), callid);
    iax_pvt_callid_set(callno, callid);
}

References AST_CALLID_BUFFER_LENGTH, ast_callid_strnprint(), ast_create_callid(), chan_iax2_pvt::callid, chan_iax2_pvt::callno, and iax_pvt_callid_set().

Referenced by socket_process_helper().

iax_pvt_callid_set()

static void iax_pvt_callid_set ( int  callno, ast_callid  callid  )

static

Definition at line 1205 of file chan_iax2.c.

{
    iaxs[callno]->callid = callid;
}

References chan_iax2_pvt::callid, chan_iax2_pvt::callno, and iaxs.

Referenced by iax2_request(), and iax_pvt_callid_new().

iaxfrdup2()

static struct iax_frame * iaxfrdup2 ( struct iax_frame *  fr )

static

Definition at line 2359 of file chan_iax2.c.

{
    struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
    if (new) {
        size_t afdatalen = new->afdatalen;
        memcpy(new, fr, sizeof(*new));
        iax_frame_wrap(new, &fr->af);
        new->afdatalen = afdatalen;
        new->data = NULL;
        new->datalen = 0;
        new->direction = DIRECTION_INGRESS;
        new->retrans = -1;
    }
    return new;
}

References iax_frame::af, iax_frame::afdatalen, iax_frame::cacheable, ast_frame::datalen, DIRECTION_INGRESS, iax_frame_new(), iax_frame_wrap(), and NULL.

Referenced by socket_process_helper(), and socket_process_meta().

insert_idle_thread()

static void insert_idle_thread ( struct iax2_thread *  thread )

static

Definition at line 1643 of file chan_iax2.c.

{
    if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
        AST_LIST_LOCK(&dynamic_list);
        AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
        AST_LIST_UNLOCK(&dynamic_list);
    } else {
        AST_LIST_LOCK(&idle_list);
        AST_LIST_INSERT_TAIL(&idle_list, thread, list);
        AST_LIST_UNLOCK(&idle_list);
    }
 
    return;
}

References AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, IAX_THREAD_TYPE_DYNAMIC, and thread.

Referenced by iax2_process_thread().

invalid_key()

static int invalid_key ( ast_aes_decrypt_key *  ecx )

static

Definition at line 6483 of file chan_iax2.c.

{
#ifdef HAVE_OPENSSL
    int i;
    for (i = 0; i < 60; i++) {
        if (ecx->raw[i]) {
            return 0; /* stop if we encounter anything non-zero */
        }
    }
    /* if ast_aes_encrypt or ast_aes_decrypt is called, then we'll crash when calling AES_encrypt or AES_decrypt */
    return -1;
#else
    return 0; /* Can't verify, but doesn't matter anyways */
#endif
}

References aes_key::raw.

Referenced by authenticate_reply().

jb_debug_output()

static void jb_debug_output ( const char *  fmt,   ...  )

static

Definition at line 1305 of file chan_iax2.c.

{
    va_list args;
    char buf[1024];
 
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);
 
    ast_verbose("%s", buf);
}

References args, ast_verbose(), and buf.

Referenced by handle_cli_iax2_set_debug_jb().

jb_error_output()

static void jb_error_output ( const char *  fmt,   ...  )

static

Definition at line 1281 of file chan_iax2.c.

{
    va_list args;
    char buf[1024];
 
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);
 
    ast_log(LOG_ERROR, "%s", buf);
}

References args, ast_log, buf, and LOG_ERROR.

Referenced by handle_cli_iax2_set_debug_jb(), and load_module().

jb_warning_output()

static void jb_warning_output ( const char *  fmt,   ...  )

static

Definition at line 1293 of file chan_iax2.c.

{
    va_list args;
    char buf[1024];
 
    va_start(args, fmt);
    vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);
 
    ast_log(LOG_WARNING, "%s", buf);
}

References args, ast_log, buf, and LOG_WARNING.

Referenced by handle_cli_iax2_set_debug_jb(), and load_module().

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 15040 of file chan_iax2.c.

{
    static const char config[] = "iax.conf";
    int x = 0;
    struct iax2_registry *reg = NULL;
 
    if (!(iax2_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_format_cap_append_by_type(iax2_tech.capabilities, AST_MEDIA_TYPE_UNKNOWN);
 
    if (load_objects()) {
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    memset(iaxs, 0, sizeof(iaxs));
 
    for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
        ast_mutex_init(&iaxsl[x]);
    }
 
    if (!(sched = ast_sched_context_create())) {
        ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_sched_start_thread(sched)) {
        ast_sched_context_destroy(sched);
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        sched = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!(io = io_context_create())) {
        ast_log(LOG_ERROR, "Failed to create I/O context\n");
        ast_sched_context_destroy(sched);
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        sched = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!(netsock = ast_netsock_list_alloc())) {
        ast_log(LOG_ERROR, "Failed to create netsock list\n");
        io_context_destroy(io);
        ast_sched_context_destroy(sched);
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        sched = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_netsock_init(netsock);
 
    outsock = ast_netsock_list_alloc();
    if (!outsock) {
        ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
        io_context_destroy(io);
        ast_sched_context_destroy(sched);
        ao2_ref(iax2_tech.capabilities, -1);
        iax2_tech.capabilities = NULL;
        sched = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_netsock_init(outsock);
 
    randomcalltokendata = ast_random();
 
    iax_set_output(iax_debug_output);
    iax_set_error(iax_error_output);
    jb_setoutput(jb_error_output, jb_warning_output, NULL);
 
    if ((timer = ast_timer_open())) {
        ast_timer_set_rate(timer, 1000 / trunkfreq);
    }
 
    if (set_config(config, 0, 0) == -1) {
        if (timer) {
            ast_timer_close(timer);
            timer = NULL;
        }
        __unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_cli_register_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
 
    ast_register_application_xml(papp, iax2_prov_app);
 
    ast_custom_function_register(&iaxpeer_function);
    ast_custom_function_register(&iaxvar_function);
 
    ast_manager_register_xml("IAXpeers", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peers);
    ast_manager_register_xml("IAXpeerlist", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peer_list);
    ast_manager_register_xml("IAXnetstats", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_netstats);
    ast_manager_register_xml("IAXregistry", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_registry);
 
    if (ast_channel_register(&iax2_tech)) {
        ast_log(LOG_ERROR, "Unable to register channel class %s\n", "IAX2");
        __unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_register_switch(&iax2_switch)) {
        ast_log(LOG_ERROR, "Unable to register IAX switch\n");
    }
 
    if (start_network_thread()) {
        ast_log(LOG_ERROR, "Unable to start network thread\n");
        __unload_module();
        return AST_MODULE_LOAD_DECLINE;
    } else {
        ast_verb(2, "IAX Ready and Listening\n");
    }
 
    AST_LIST_LOCK(&registrations);
    AST_LIST_TRAVERSE(&registrations, reg, entry)
        iax2_do_register(reg);
    AST_LIST_UNLOCK(&registrations);
 
    ao2_callback(peers, 0, peer_set_sock_cb, NULL);
    ao2_callback(peers, 0, iax2_poke_peer_cb, NULL);
 
 
    iax_firmware_reload();
    iax_provision_reload(0);
 
    ast_realtime_require_field("iaxpeers", "name", RQ_CHAR, 10, "ipaddr", RQ_CHAR, 15, "port", RQ_UINTEGER2, 5, "regseconds", RQ_UINTEGER2, 6, SENTINEL);
 
    network_change_stasis_subscribe();
 
    return AST_MODULE_LOAD_SUCCESS;
}

References __unload_module(), ao2_callback, ao2_ref, ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple, ast_custom_function_register, ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_manager_register_xml, AST_MEDIA_TYPE_UNKNOWN, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_mutex_init, ast_netsock_init(), ast_netsock_list_alloc(), ast_random(), ast_realtime_require_field(), ast_register_application_xml, ast_register_switch(), ast_sched_context_create(), ast_sched_context_destroy(), ast_sched_start_thread(), ast_timer_close(), ast_timer_open(), ast_timer_set_rate(), ast_verb, ast_channel_tech::capabilities, cli_iax2, config, iax2_registry::entry, EVENT_FLAG_REPORTING, EVENT_FLAG_SYSTEM, iax2_do_register(), iax2_poke_peer_cb(), iax2_prov_app(), iax2_switch, iax2_tech, iax_debug_output(), iax_error_output(), iax_firmware_reload(), iax_provision_reload(), iax_set_error(), iax_set_output(), iaxpeer_function, iaxs, iaxsl, iaxvar_function, io, io_context_create(), io_context_destroy(), jb_error_output(), jb_setoutput(), jb_warning_output(), load_objects(), LOG_ERROR, manager_iax2_show_netstats(), manager_iax2_show_peer_list(), manager_iax2_show_peers(), manager_iax2_show_registry(), netsock, network_change_stasis_subscribe(), NULL, outsock, papp, peer_set_sock_cb(), randomcalltokendata, RQ_CHAR, RQ_UINTEGER2, SENTINEL, set_config(), start_network_thread(), timer, and trunkfreq.

load_objects()

static int load_objects ( void  )

static

Definition at line 14947 of file chan_iax2.c.

{
    peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
    peercnts = callno_limits = calltoken_ignores = NULL;
 
    peers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
        peer_hash_cb, NULL, peer_cmp_cb);
    if (!peers) {
        goto container_fail;
    }
 
    users = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_USER_BUCKETS,
        user_hash_cb, NULL, user_cmp_cb);
    if (!users) {
        goto container_fail;
    }
 
    iax_peercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        IAX_MAX_CALLS, pvt_hash_cb, NULL, pvt_cmp_cb);
    if (!iax_peercallno_pvts) {
        goto container_fail;
    }
 
    iax_transfercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        IAX_MAX_CALLS, transfercallno_pvt_hash_cb, NULL, transfercallno_pvt_cmp_cb);
    if (!iax_transfercallno_pvts) {
        goto container_fail;
    }
 
    peercnts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
        peercnt_hash_cb, NULL, peercnt_cmp_cb);
    if (!peercnts) {
        goto container_fail;
    }
 
    callno_limits = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
    if (!callno_limits) {
        goto container_fail;
    }
 
    calltoken_ignores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
    if (!calltoken_ignores) {
        goto container_fail;
    }
 
    if (create_callno_pools()) {
        goto container_fail;
    }
 
    transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT);
    if (!transmit_processor) {
        goto container_fail;
    }
 
    return 0;
 
container_fail:
    if (peers) {
        ao2_ref(peers, -1);
    }
    if (users) {
        ao2_ref(users, -1);
    }
    if (iax_peercallno_pvts) {
        ao2_ref(iax_peercallno_pvts, -1);
    }
    if (iax_transfercallno_pvts) {
        ao2_ref(iax_transfercallno_pvts, -1);
    }
    if (peercnts) {
        ao2_ref(peercnts, -1);
    }
    if (callno_limits) {
        ao2_ref(callno_limits, -1);
    }
    if (calltoken_ignores) {
        ao2_ref(calltoken_ignores, -1);
    }
    return -1;
}

References addr_range_cmp_cb(), addr_range_hash_cb(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ast_taskprocessor_get(), callno_limits, calltoken_ignores, create_callno_pools(), IAX_MAX_CALLS, iax_peercallno_pvts, iax_transfercallno_pvts, MAX_PEER_BUCKETS, MAX_USER_BUCKETS, NULL, peer_cmp_cb(), peer_hash_cb(), peercnt_cmp_cb(), peercnt_hash_cb(), peercnts, pvt_cmp_cb(), pvt_hash_cb(), TPS_REF_DEFAULT, transfercallno_pvt_cmp_cb(), transfercallno_pvt_hash_cb(), transmit_processor, user_cmp_cb(), and user_hash_cb().

Referenced by load_module().

log_jitterstats()

static void log_jitterstats ( unsigned short  callno )

static

Definition at line 9851 of file chan_iax2.c.

{
    int localjitter = -1, localdelay = 0, locallost = -1, locallosspct = -1, localdropped = 0, localooo = -1, localpackets = -1;
    jb_info jbinfo;
 
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno] && iaxs[callno]->owner && ast_channel_name(iaxs[callno]->owner)) {
        if(ast_test_flag64(iaxs[callno], IAX_USEJITTERBUF)) {
            jb_getinfo(iaxs[callno]->jb, &jbinfo);
            localjitter = jbinfo.jitter;
            localdelay = jbinfo.current - jbinfo.min;
            locallost = jbinfo.frames_lost;
            locallosspct = jbinfo.losspct/1000;
            localdropped = jbinfo.frames_dropped;
            localooo = jbinfo.frames_ooo;
            localpackets = jbinfo.frames_in;
        }
        ast_debug(3, "JB STATS:%s ping=%u ljitterms=%d ljbdelayms=%d ltotlost=%d lrecentlosspct=%d ldropped=%d looo=%d lrecvd=%d rjitterms=%d rjbdelayms=%d rtotlost=%d rrecentlosspct=%d rdropped=%d rooo=%d rrecvd=%d\n",
            ast_channel_name(iaxs[callno]->owner),
            iaxs[callno]->pingtime,
            localjitter,
            localdelay,
            locallost,
            locallosspct,
            localdropped,
            localooo,
            localpackets,
            iaxs[callno]->remote_rr.jitter,
            iaxs[callno]->remote_rr.delay,
            iaxs[callno]->remote_rr.losscnt,
            iaxs[callno]->remote_rr.losspct/1000,
            iaxs[callno]->remote_rr.dropped,
            iaxs[callno]->remote_rr.ooo,
            iaxs[callno]->remote_rr.packets);
    }
    ast_mutex_unlock(&iaxsl[callno]);
}

References ast_channel_name(), ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_test_flag64, dpreq_data::callno, jb_info::current, iax_rr::delay, iax_rr::dropped, jb_info::frames_dropped, jb_info::frames_in, jb_info::frames_lost, jb_info::frames_ooo, IAX_USEJITTERBUF, iaxs, iaxsl, jb_getinfo(), jb_info::jitter, iax_rr::losscnt, iax_rr::losspct, jb_info::losspct, jb_info::min, iax_rr::ooo, iax_rr::packets, and chan_iax2_pvt::remote_rr.

Referenced by socket_process_helper().

make_trunk()

static int make_trunk ( unsigned short  callno, int  locked  )

static

Note

We delete these before switching the slot, because if they fire in the meantime, they will generate a warning.

Definition at line 2406 of file chan_iax2.c.

{
    int x;
    int res= 0;
    callno_entry entry;
    if (iaxs[callno]->oseqno) {
        ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
        return -1;
    }
    if (callno >= TRUNK_CALL_START) {
        ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
        return -1;
    }
 
    if (get_unused_callno(
            CALLNO_TYPE_TRUNK,
            CALLNO_ENTRY_IS_VALIDATED(iaxs[callno]->callno_entry),
            &entry)) {
        ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
        return -1;
    }
 
    x = CALLNO_ENTRY_GET_CALLNO(entry);
    ast_mutex_lock(&iaxsl[x]);
 
    /*!
     * \note We delete these before switching the slot, because if
     * they fire in the meantime, they will generate a warning.
     */
    AST_SCHED_DEL(sched, iaxs[callno]->pingid);
    AST_SCHED_DEL(sched, iaxs[callno]->lagid);
    iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
    iaxs[x] = iaxs[callno];
    iaxs[x]->callno = x;
 
    /* since we copied over the pvt from a different callno, make sure the old entry is replaced
     * before assigning the new one */
    if (iaxs[x]->callno_entry) {
        iax2_sched_add(
            sched,
            MIN_REUSE_TIME * 1000,
            replace_callno,
            CALLNO_ENTRY_TO_PTR(iaxs[x]->callno_entry));
 
    }
    iaxs[x]->callno_entry = entry;
 
    iaxs[callno] = NULL;
    /* Update the two timers that should have been started */
    iaxs[x]->pingid = iax2_sched_add(sched,
        ping_time * 1000, send_ping, (void *)(long)x);
    iaxs[x]->lagid = iax2_sched_add(sched,
        lagrq_time * 1000, send_lagrq, (void *)(long)x);
 
    if (locked)
        ast_mutex_unlock(&iaxsl[callno]);
    res = x;
    if (!locked)
        ast_mutex_unlock(&iaxsl[x]);
 
    /* We moved this call from a non-trunked to a trunked call */
    ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
 
    return res;
}

References ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_SCHED_DEL, chan_iax2_pvt::callno, iax_frame::callno, chan_iax2_pvt::callno_entry, CALLNO_ENTRY_GET_CALLNO, CALLNO_ENTRY_IS_VALIDATED, CALLNO_ENTRY_TO_PTR, CALLNO_TYPE_TRUNK, get_unused_callno(), iax2_sched_add(), iaxs, iaxsl, chan_iax2_pvt::lagid, lagrq_time, LOG_WARNING, MIN_REUSE_TIME, NULL, iax_frame::oseqno, ping_time, chan_iax2_pvt::pingid, replace_callno(), send_lagrq(), send_ping(), and TRUNK_CALL_START.

Referenced by iax2_request(), and socket_process_helper().

manager_iax2_show_netstats()

static int manager_iax2_show_netstats ( struct mansession *  s, const struct message *  m  )

static

Definition at line 7338 of file chan_iax2.c.

{
    ast_cli_netstats(s, -1, 0);
    astman_append(s, "\r\n");
    return RESULT_SUCCESS;
}

References ast_cli_netstats(), astman_append(), and RESULT_SUCCESS.

Referenced by load_module().

manager_iax2_show_peer_list()

static int manager_iax2_show_peer_list ( struct mansession *  s, const struct message *  m  )

static

callback to display iax peers in manager format

Definition at line 7407 of file chan_iax2.c.

{
    struct show_peers_context cont = {
        .havepattern = 0,
        .idtext = "",
        .registeredonly = 0,
 
        .peerlist = 1,
 
        .total_peers = 0,
        .online_peers = 0,
        .offline_peers = 0,
        .unmonitored_peers = 0,
    };
 
    struct iax2_peer *peer = NULL;
    struct ao2_iterator i;
 
    const char *id = astman_get_header(m,"ActionID");
 
    if (!ast_strlen_zero(id)) {
        snprintf(cont.idtext, sizeof(cont.idtext), "ActionID: %s\r\n", id);
    }
 
    astman_send_listack(s, m, "IAX Peer status list will follow", "start");
 
    i = ao2_iterator_init(peers, 0);
    for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
        _iax2_show_peers_one(-1, s, &cont, peer);
    }
    ao2_iterator_destroy(&i);
 
    astman_send_list_complete_start(s, m, "PeerlistComplete", cont.total_peers);
    astman_send_list_complete_end(s);
 
    return RESULT_SUCCESS;
}

References _iax2_show_peers_one(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_strlen_zero(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), show_peers_context::havepattern, show_peers_context::idtext, NULL, peer_unref(), RESULT_SUCCESS, and show_peers_context::total_peers.

Referenced by load_module().

manager_iax2_show_peers()

static int manager_iax2_show_peers ( struct mansession *  s, const struct message *  m  )

static

callback to display iax peers in manager

Definition at line 7385 of file chan_iax2.c.

{
    static const char * const a[] = { "iax2", "show", "peers" };
    const char *id = astman_get_header(m,"ActionID");
    char idtext[256] = "";
    int total = 0;
 
    if (!ast_strlen_zero(id))
        snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
 
    astman_send_listack(s, m, "Peer status list will follow", "start");
 
    /* List the peers in separate manager events */
    __iax2_show_peers(-1, &total, s, 3, a);
 
    /* Send final confirmation */
    astman_send_list_complete_start(s, m, "PeerlistComplete", total);
    astman_send_list_complete_end(s);
    return 0;
}

References __iax2_show_peers(), a, ast_strlen_zero(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), and total.

Referenced by load_module().

manager_iax2_show_registry()

static int manager_iax2_show_registry ( struct mansession *  s, const struct message *  m  )

static

Definition at line 7509 of file chan_iax2.c.

{
    const char *id = astman_get_header(m, "ActionID");
    struct iax2_registry *reg = NULL;
    char idtext[256] = "";
    char host[80] = "";
    char perceived[80] = "";
    int total = 0;
 
    if (!ast_strlen_zero(id))
        snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
 
    astman_send_listack(s, m, "Registrations will follow", "start");
 
    AST_LIST_LOCK(&registrations);
    AST_LIST_TRAVERSE(&registrations, reg, entry) {
        snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
 
        snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
 
        astman_append(s,
            "Event: RegistryEntry\r\n"
            "%s"
            "Host: %s\r\n"
            "DNSmanager: %s\r\n"
            "Username: %s\r\n"
            "Perceived: %s\r\n"
            "Refresh: %d\r\n"
            "State: %s\r\n"
            "\r\n", idtext, host, (reg->dnsmgr) ? "Y" : "N", reg->username, perceived,
            reg->refresh, regstate2str(reg->regstate));
 
        total++;
    }
    AST_LIST_UNLOCK(&registrations);
 
    astman_send_list_complete_start(s, m, "RegistrationsComplete", total);
    astman_send_list_complete_end(s);
 
    return 0;
}

References iax2_registry::addr, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_sockaddr_isnull(), ast_sockaddr_stringify(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), iax2_registry::dnsmgr, iax2_registry::entry, NULL, iax2_registry::refresh, iax2_registry::regstate, regstate2str(), total, iax2_registry::us, and iax2_registry::username.

Referenced by load_module().

match()

static int match ( struct ast_sockaddr *  addr, unsigned short  callno, unsigned short  dcallno, const struct chan_iax2_pvt *  cur, int  check_dcallno  )

static

Examples

app_skel.c.

Definition at line 2388 of file chan_iax2.c.

{
    if (!ast_sockaddr_cmp(&cur->addr, addr)) {
        /* This is the main host */
        if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
             (check_dcallno ? dcallno == cur->callno : 1) ) {
            /* That's us.  Be sure we keep track of the peer call number */
            return 1;
        }
    }
    if (!ast_sockaddr_cmp(&cur->transfer, addr) && cur->transferring) {
        /* We're transferring */
        if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
            return 1;
    }
    return 0;
}

References chan_iax2_pvt::addr, ast_sockaddr_cmp(), chan_iax2_pvt::callno, iax_frame::callno, iax_frame::dcallno, chan_iax2_pvt::peercallno, chan_iax2_pvt::transfer, TRANSFER_MEDIAPASS, chan_iax2_pvt::transfercallno, and chan_iax2_pvt::transferring.

Referenced by __find_callno(), aco_process_config(), action_listcategories(), ast_category_insert(), ast_cdr_generic_unregister(), ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_tech_register(), ast_msg_tech_unregister(), ast_namedgroups_intersect(), ast_parse_device_state(), ast_refer_tech_register(), ast_refer_tech_unregister(), ast_sched_clean_by_callback(), ast_srtp_add_stream(), ast_srtp_change_source(), ast_variable_delete(), ast_variable_retrieve(), ast_variable_update(), ast_xml_doc_item_cmp(), check_blacklist(), cli_print_body(), cli_show_module_options(), cli_show_module_type(), common_identify(), detect_callback(), does_category_match(), filter_cmp_fn(), find_command(), find_option_cb(), generic_mute_unmute_helper(), get_device_state_causing_channels(), handle_updates(), has_destination_cb(), help1(), help_workhorse(), internal_aco_type_category_check(), internal_aco_type_find(), internal_ao2_traverse(), kick_conference_participant(), lua_find_extension(), namedgroup_match(), pbx_find_extension(), pvt_cmp_cb(), read_dirs_cb(), realtime_switch_common(), scan_exec(), skel_level_cmp(), test_item_cmp(), transfercallno_pvt_cmp_cb(), xmldoc_attribute_match(), xmldoc_get_syntax_config_object(), and xmpp_config_cmp().

memcpy_decrypt()

static void memcpy_decrypt ( unsigned char *  dst, const unsigned char *  src, int  len, ast_aes_decrypt_key *  dcx  )

static

Definition at line 6515 of file chan_iax2.c.

{
#if 0
    /* Debug with "fake encryption" */
    int x;
    if (len % 16)
        ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
    for (x=0;x<len;x++)
        dst[x] = src[x] ^ 0xff;
#else
    unsigned char lastblock[16] = { 0 };
    int x;
    while(len > 0) {
        ast_aes_decrypt(src, dst, dcx);
        for (x=0;x<16;x++)
            dst[x] ^= lastblock[x];
        memcpy(lastblock, src, sizeof(lastblock));
        dst += 16;
        src += 16;
        len -= 16;
    }
#endif
}

References ast_aes_decrypt(), ast_log, len(), and LOG_WARNING.

Referenced by decode_frame().

memcpy_encrypt()

static void memcpy_encrypt ( unsigned char *  dst, const unsigned char *  src, int  len, ast_aes_encrypt_key *  ecx  )

static

Definition at line 6539 of file chan_iax2.c.

{
#if 0
    /* Debug with "fake encryption" */
    int x;
    if (len % 16)
        ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
    for (x=0;x<len;x++)
        dst[x] = src[x] ^ 0xff;
#else
    unsigned char curblock[16] = { 0 };
    int x;
    while(len > 0) {
        for (x=0;x<16;x++)
            curblock[x] ^= src[x];
        ast_aes_encrypt(curblock, dst, ecx);
        memcpy(curblock, dst, sizeof(curblock));
        dst += 16;
        src += 16;
        len -= 16;
    }
#endif
}

References ast_aes_encrypt(), ast_log, len(), and LOG_WARNING.

Referenced by encrypt_frame().

merge_encryption()

static void merge_encryption ( struct chan_iax2_pvt *  p, unsigned int  enc  )

static

Definition at line 8176 of file chan_iax2.c.

{
    /* Select exactly one common encryption if there are any */
    p->encmethods &= enc;
    if (p->encmethods) {
        if (!(p->encmethods & IAX_ENCRYPT_KEYROTATE)){ /* if key rotation is not supported, turn off keyrotation. */
            p->keyrotateid = -2;
        }
        if (p->encmethods & IAX_ENCRYPT_AES128)
            p->encmethods = IAX_ENCRYPT_AES128;
        else
            p->encmethods = 0;
    }
}

References chan_iax2_pvt::encmethods, IAX_ENCRYPT_AES128, IAX_ENCRYPT_KEYROTATE, and chan_iax2_pvt::keyrotateid.

Referenced by authenticate_reply(), and socket_process_helper().

network_change_sched_cb()

static int network_change_sched_cb ( const void *  data )

static

Definition at line 1557 of file chan_iax2.c.

{
    struct iax2_registry *reg;
    network_change_sched_id = -1;
    AST_LIST_LOCK(&registrations);
    AST_LIST_TRAVERSE(&registrations, reg, entry) {
        iax2_do_register(reg);
    }
    AST_LIST_UNLOCK(&registrations);
 
    return 0;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, iax2_registry::entry, iax2_do_register(), and network_change_sched_id.

Referenced by network_change_stasis_cb().

network_change_stasis_cb()

static void network_change_stasis_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 1570 of file chan_iax2.c.

{
    /* This callback is only concerned with network change messages from the system topic. */
    if (stasis_message_type(message) != ast_network_change_type()) {
        return;
    }
 
    ast_verb(1, "IAX, got a network change message, renewing all IAX registrations.\n");
    if (network_change_sched_id == -1) {
        network_change_sched_id = iax2_sched_add(sched, 1000, network_change_sched_cb, NULL);
    }
}

References ast_network_change_type(), ast_verb, iax2_sched_add(), network_change_sched_cb(), network_change_sched_id, NULL, and stasis_message_type().

Referenced by network_change_stasis_subscribe().

network_change_stasis_subscribe()

static void network_change_stasis_subscribe ( void  )

static

Definition at line 1527 of file chan_iax2.c.

{
    if (!network_change_sub) {
        network_change_sub = stasis_subscribe(ast_system_topic(),
            network_change_stasis_cb, NULL);
        stasis_subscription_accept_message_type(network_change_sub, ast_network_change_type());
        stasis_subscription_set_filter(network_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
    }
}

References ast_network_change_type(), ast_system_topic(), network_change_stasis_cb(), network_change_sub, NULL, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, and stasis_subscription_set_filter().

Referenced by load_module(), and set_config().

network_change_stasis_unsubscribe()

static void network_change_stasis_unsubscribe ( void  )

static

Definition at line 1537 of file chan_iax2.c.

{
    network_change_sub = stasis_unsubscribe_and_join(network_change_sub);
}

References network_change_sub, and stasis_unsubscribe_and_join().

Referenced by __unload_module(), and set_config().

network_thread()

static void * network_thread ( void *  ignore )

static

Definition at line 12793 of file chan_iax2.c.

{
    int res;
 
    if (timer) {
        ast_io_add(io, ast_timer_fd(timer), timing_read, AST_IO_IN | AST_IO_PRI, NULL);
    }
 
    for (;;) {
        pthread_testcancel();
        /* Wake up once a second just in case SIGURG was sent while
         * we weren't in poll(), to make sure we don't hang when trying
         * to unload. */
        res = ast_io_wait(io, 1000);
        /* Timeout(=0), and EINTR is not a thread exit condition. We do
         * not want to exit the thread loop on these conditions. */
        if (res < 0 && errno != -EINTR) {
            ast_log(LOG_ERROR, "IAX2 network thread unexpected exit: %s\n", strerror(errno));
            break;
        }
    }
 
    return NULL;
}

References ast_io_add(), AST_IO_IN, AST_IO_PRI, ast_io_wait(), ast_log, ast_timer_fd(), errno, io, LOG_ERROR, NULL, timer, and timing_read().

Referenced by start_network_thread().

new_iax()

static struct chan_iax2_pvt * new_iax ( struct ast_sockaddr *  addr, const char *  host  )

static

Definition at line 2316 of file chan_iax2.c.

{
    struct chan_iax2_pvt *tmp;
    jb_conf jbconf;
 
    if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
        return NULL;
    }
 
    tmp->pingid = -1;
    tmp->lagid = -1;
    tmp->autoid = -1;
    tmp->authid = -1;
    tmp->initid = -1;
    tmp->keyrotateid = -1;
    tmp->jbid = -1;
 
    if (ast_string_field_init(tmp, 32)) {
        ao2_ref(tmp, -1);
        tmp = NULL;
        return NULL;
    }
 
    tmp->prefs = prefs_global;
 
    ast_string_field_set(tmp,exten, "s");
    ast_string_field_set(tmp,host, host);
 
    tmp->jb = jb_new();
    jbconf.max_jitterbuf = maxjitterbuffer;
    jbconf.resync_threshold = resyncthreshold;
    jbconf.max_contig_interp = maxjitterinterps;
    jbconf.target_extra = jittertargetextra;
    jb_setconf(tmp->jb,&jbconf);
 
    AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
 
    tmp->hold_signaling = 1;
    AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
 
    return tmp;
}

References ao2_alloc, ao2_ref, AST_LIST_HEAD_INIT_NOLOCK, ast_string_field_init, ast_string_field_set, chan_iax2_pvt::authid, chan_iax2_pvt::autoid, chan_iax2_pvt::dpentries, chan_iax2_pvt::exten, chan_iax2_pvt::hold_signaling, chan_iax2_pvt::host, chan_iax2_pvt::initid, chan_iax2_pvt::jb, jb_new(), jb_setconf(), chan_iax2_pvt::jbid, jittertargetextra, chan_iax2_pvt::keyrotateid, chan_iax2_pvt::lagid, jb_conf::max_contig_interp, jb_conf::max_jitterbuf, maxjitterbuffer, maxjitterinterps, NULL, chan_iax2_pvt::pingid, chan_iax2_pvt::prefs, prefs_global, pvt_destructor(), jb_conf::resync_threshold, resyncthreshold, chan_iax2_pvt::signaling_queue, and jb_conf::target_extra.

Referenced by __find_callno().

parse_dial_string()

static void parse_dial_string ( char *  data, struct parsed_dial_string *  pds  )

static

Parses an IAX dial string into its component parts.

Parameters

data	the string to be parsed
pds	pointer to a struct parsed_dial_string to be filled in

This function parses the string and fills the structure with pointers to its component parts. The input string will be modified.

Note

This function supports both plaintext passwords and RSA key names; if the password string is formatted as '[keyname]', then the keyname will be placed into the key field, and the password field will be set to NULL.

The dial string format is:

[username[:password]@]peer[:port][/exten[@context]][/options] 

Definition at line 5132 of file chan_iax2.c.

{
    char *outkey = NULL;
 
    if (ast_strlen_zero(data))
        return;
 
    pds->peer = strsep(&data, "/");
    pds->exten = strsep(&data, "/");
    pds->options = data;
 
    if (pds->exten) {
        data = pds->exten;
        pds->exten = strsep(&data, "@");
        pds->context = data;
    }
 
    if (strchr(pds->peer, '@')) {
        data = pds->peer;
        pds->username = strsep(&data, "@");
        pds->peer = data;
    }
 
    if (pds->username) {
        data = pds->username;
        pds->username = strsep(&data, ":");
        pds->password = strsep(&data, ":");
        outkey = data;
    }
 
    data = pds->peer;
    pds->peer = strsep(&data, ":");
    pds->port = data;
 
    /*
     * Check for a key name wrapped in [] in the password position.
     * If found, move it to the key field instead.
     * Also allow for both key and secret to be specified, now that
     * encryption is possible with RSA authentication.
     */
    
    if (pds->password && (pds->password[0] == '[')) { /* key (then maybe secret) */
        pds->key = ast_strip_quoted(pds->password, "[", "]");
        if (ast_strlen_zero(outkey)) {
            pds->password = NULL;
            ast_debug(1, "Outkey (%s), no secret\n", pds->key);
        } else {
            pds->password = outkey;
            ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
        }
    } else if (outkey && (outkey[0] == '[')) { /* secret, then key */
        pds->key = ast_strip_quoted(outkey, "[", "]");
        if (ast_strlen_zero(pds->password)) {
            ast_debug(1, "Outkey (%s), no secret\n", pds->key);
        } else {
            ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
        }
    }
}

References ast_debug, ast_strip_quoted(), ast_strlen_zero(), parsed_dial_string::context, parsed_dial_string::exten, parsed_dial_string::key, NULL, parsed_dial_string::options, parsed_dial_string::password, parsed_dial_string::peer, parsed_dial_string::port, strsep(), and parsed_dial_string::username.

Referenced by cache_get_callno_locked(), iax2_call(), iax2_devicestate(), and iax2_request().

peer_cmp_cb()

static int peer_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Note

The only member of the peer passed here guaranteed to be set is the name field

Definition at line 2046 of file chan_iax2.c.

{
    struct iax2_peer *peer = obj, *peer2 = arg;
    const char *name = arg;
 
    return !strcmp(peer->name, flags & OBJ_KEY ? name : peer2->name) ?
            CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, iax2_peer::flags, name, iax2_peer::name, and OBJ_KEY.

Referenced by load_objects().

peer_delme_cb()

static int peer_delme_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 13601 of file chan_iax2.c.

{
    struct iax2_peer *peer = obj;
 
    ast_set_flag64(peer, IAX_DELME);
 
    return 0;
}

References ast_set_flag64, and IAX_DELME.

Referenced by delete_users().

peer_destructor()

static void peer_destructor ( void *  obj )

static

Definition at line 12986 of file chan_iax2.c.

{
    struct iax2_peer *peer = obj;
    int callno = peer->callno;
 
    ast_free_acl_list(peer->acl);
 
    if (callno > 0) {
        ast_mutex_lock(&iaxsl[callno]);
        iax2_destroy(callno);
        ast_mutex_unlock(&iaxsl[callno]);
    }
 
    register_peer_exten(peer, 0);
 
    if (peer->dnsmgr)
        ast_dnsmgr_release(peer->dnsmgr);
 
    if (peer->mwi_event_sub) {
        peer->mwi_event_sub = ast_mwi_unsubscribe(peer->mwi_event_sub);
    }
 
    ast_string_field_free_memory(peer);
 
    ast_endpoint_shutdown(peer->endpoint);
}

References iax2_peer::acl, ast_dnsmgr_release(), ast_endpoint_shutdown(), ast_free_acl_list(), ast_mutex_lock, ast_mutex_unlock, ast_mwi_unsubscribe(), ast_string_field_free_memory, iax2_peer::callno, iax2_peer::dnsmgr, iax2_peer::endpoint, iax2_destroy(), iaxsl, iax2_peer::mwi_event_sub, and register_peer_exten().

Referenced by build_peer().

peer_hash_cb()

static int peer_hash_cb ( const void *  obj, const int  flags  )

static

Note

The only member of the peer passed here guaranteed to be set is the name field

Definition at line 2035 of file chan_iax2.c.

{
    const struct iax2_peer *peer = obj;
    const char *name = obj;
 
    return ast_str_hash(flags & OBJ_KEY ? name : peer->name);
}

References ast_str_hash(), iax2_peer::flags, name, iax2_peer::name, and OBJ_KEY.

Referenced by load_objects().

peer_ref()

static struct iax2_peer * peer_ref ( struct iax2_peer *  peer )

static

Definition at line 2095 of file chan_iax2.c.

{
    ao2_ref(peer, +1);
    return peer;
}

References ao2_ref.

Referenced by __iax2_poke_noanswer(), handle_cli_iax2_prune_realtime(), handle_cli_iax2_unregister(), iax2_poke_peer(), realtime_peer(), reg_source_db(), socket_process_helper(), and update_registry().

peer_set_sock_cb()

static int peer_set_sock_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 14901 of file chan_iax2.c.

{
    struct iax2_peer *peer = obj;
 
    if (peer->sockfd < 0)
        peer->sockfd = defaultsockfd;
 
    return 0;
}

References defaultsockfd, and iax2_peer::sockfd.

Referenced by load_module().

peer_set_srcaddr()

static int peer_set_srcaddr ( struct iax2_peer *  peer, const char *  srcaddr  )

static

Parse the "sourceaddress" value, lookup in netsock list and set peer's sockfd. Defaults to defaultsockfd if not found.

Definition at line 12916 of file chan_iax2.c.

{
    struct ast_sockaddr addr;
    int nonlocal = 1;
    int port = IAX_DEFAULT_PORTNO;
    int sockfd = defaultsockfd;
    char *tmp;
    char *host;
    char *portstr;
 
    tmp = ast_strdupa(srcaddr);
    ast_sockaddr_split_hostport(tmp, &host, &portstr, 0);
 
    if (portstr) {
        port = atoi(portstr);
        if (port < 1)
            port = IAX_DEFAULT_PORTNO;
    }
 
    addr.ss.ss_family = AST_AF_UNSPEC;
    if (!ast_get_ip(&addr, host)) {
        struct ast_netsock *sock;
 
        if (check_srcaddr(&addr) == 0) {
            /* ip address valid. */
            ast_sockaddr_set_port(&addr, port);
 
            if (!(sock = ast_netsock_find(netsock, &addr)))
                sock = ast_netsock_find(outsock, &addr);
            if (sock) {
                sockfd = ast_netsock_sockfd(sock);
                nonlocal = 0;
            } else {
                /* INADDR_ANY matches anyway! */
                ast_sockaddr_parse(&addr, "0.0.0.0", 0);
                ast_sockaddr_set_port(&addr, port);
                if (ast_netsock_find(netsock, &addr)) {
                    sock = ast_netsock_bind(outsock, io, srcaddr, port, qos.tos, qos.cos, socket_read, NULL);
                    if (sock) {
                        sockfd = ast_netsock_sockfd(sock);
                        ast_netsock_unref(sock);
                        nonlocal = 0;
                    } else {
                        nonlocal = 2;
                    }
                }
            }
        }
    }
 
    peer->sockfd = sockfd;
 
    if (nonlocal == 1) {
        ast_log(LOG_WARNING,
            "Non-local or unbound address specified (%s) in sourceaddress for '%s', reverting to default\n",
            srcaddr,
            peer->name);
        return -1;
    } else if (nonlocal == 2) {
        ast_log(LOG_WARNING,
            "Unable to bind to sourceaddress '%s' for '%s', reverting to default\n",
            srcaddr,
            peer->name);
        return -1;
    } else {
        ast_debug(1, "Using sourceaddress %s for '%s'\n", srcaddr, peer->name);
        return 0;
    }
}

References AST_AF_UNSPEC, ast_debug, ast_get_ip(), ast_log, ast_netsock_bind(), ast_netsock_find(), ast_netsock_sockfd(), ast_netsock_unref(), ast_sockaddr_parse(), ast_sockaddr_set_port, ast_sockaddr_split_hostport(), ast_strdupa, check_srcaddr(), defaultsockfd, IAX_DEFAULT_PORTNO, io, LOG_WARNING, iax2_peer::name, netsock, NULL, outsock, qos, socket_read(), iax2_peer::sockfd, ast_netsock::sockfd, and ast_sockaddr::ss.

Referenced by build_peer().

peer_status()

static int peer_status ( struct iax2_peer *  peer, char *  status, int  statuslen  )

static

peer_status: Report Peer status in character string

Definition at line 3865 of file chan_iax2.c.

{
    int res = 0;
    if (peer->maxms) {
        if (peer->lastms < 0) {
            ast_copy_string(status, "UNREACHABLE", statuslen);
        } else if (peer->lastms > peer->maxms) {
            snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
            res = 1;
        } else if (peer->lastms) {
            snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
            res = 1;
        } else {
            ast_copy_string(status, "UNKNOWN", statuslen);
        }
    } else {
        ast_copy_string(status, "Unmonitored", statuslen);
        res = -1;
    }
    return res;
}

References ast_copy_string(), iax2_peer::lastms, iax2_peer::maxms, and status.

Referenced by _iax2_show_peers_one(), function_iaxpeer(), and handle_cli_iax2_show_peer().

peer_unref()

static struct iax2_peer * peer_unref ( struct iax2_peer *  peer )

inlinestatic

Definition at line 2101 of file chan_iax2.c.

{
    ao2_ref(peer, -1);
    return NULL;
}

References ao2_ref, and NULL.

Referenced by __expire_registry(), __iax2_poke_noanswer(), __iax2_poke_peer_s(), __iax2_show_peers(), authenticate_reply(), build_peer(), calltoken_required(), complete_iax2_peers(), complete_iax2_unregister(), create_addr(), function_iaxpeer(), handle_cli_iax2_prune_realtime(), handle_cli_iax2_show_peer(), handle_cli_iax2_unregister(), iax2_devicestate(), iax2_getpeername(), iax2_getpeertrunk(), iax2_poke_noanswer(), iax2_poke_peer(), manager_iax2_show_peer_list(), poke_all_peers(), prune_peers(), realtime_peer(), reg_source_db(), register_verify(), registry_authrequest(), requirecalltoken_mark_auto(), set_config(), socket_process_helper(), unlink_peer(), and update_registry().

peercnt_add()

static int peercnt_add ( struct ast_sockaddr *  addr )

static

Definition at line 2704 of file chan_iax2.c.

{
    struct peercnt *peercnt;
    int res = 0;
    struct peercnt tmp;
 
    ast_sockaddr_copy(&tmp.addr, addr);
 
    /* Reasoning for peercnts container lock:  Two identical ip addresses
     * could be added by different threads at the "same time". Without the container
     * lock, both threads could alloc space for the same object and attempt
     * to link to table.  With the lock, one would create the object and link
     * to table while the other would find the already created peercnt object
     * rather than creating a new one. */
    ao2_lock(peercnts);
    if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
        ao2_lock(peercnt);
    } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
        ao2_lock(peercnt);
        /* create and set defaults */
        ast_sockaddr_copy(&peercnt->addr, addr);
        set_peercnt_limit(peercnt);
        /* guarantees it does not go away after unlocking table
         * ao2_find automatically adds this */
        ao2_link(peercnts, peercnt);
    } else {
        ao2_unlock(peercnts);
        return -1;
    }
 
    /* check to see if the address has hit its callno limit.  If not increment cur. */
    if (peercnt->limit > peercnt->cur) {
        peercnt->cur++;
        ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(addr));
    } else { /* max num call numbers for this peer has been reached! */
        ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_sockaddr_stringify_addr(addr));
        res = -1;
    }
 
    /* clean up locks and ref count */
    ao2_unlock(peercnt);
    ao2_unlock(peercnts);
    ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
 
    return res;
}

References peercnt::addr, ao2_alloc, ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_log, ast_sockaddr_copy(), ast_sockaddr_stringify_addr(), peercnt::cur, peercnt::limit, LOG_ERROR, NULL, OBJ_POINTER, peercnts, and set_peercnt_limit().

Referenced by __find_callno(), and complete_transfer().

peercnt_cmp_cb()

static int peercnt_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2542 of file chan_iax2.c.

{
    struct peercnt *peercnt1 = obj, *peercnt2 = arg;
    return !ast_sockaddr_cmp_addr(&peercnt1->addr, &peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
}

References peercnt::addr, ast_sockaddr_cmp_addr(), CMP_MATCH, and CMP_STOP.

Referenced by load_objects().

peercnt_hash_cb()

static int peercnt_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 2532 of file chan_iax2.c.

{
    const struct peercnt *peercnt = obj;
 
    if (ast_sockaddr_isnull(&peercnt->addr)) {
        return 0;
    }
    return ast_sockaddr_hash(&peercnt->addr);
}

References peercnt::addr, ast_sockaddr_hash(), and ast_sockaddr_isnull().

Referenced by load_objects().

peercnt_modify()

static void peercnt_modify ( unsigned char  reg, uint16_t  limit, struct ast_sockaddr *  sockaddr  )

static

Definition at line 2676 of file chan_iax2.c.

{
    /* this function turns off and on custom callno limits set by peer registration */
    struct peercnt *peercnt;
    struct peercnt tmp;
 
    ast_sockaddr_copy(&tmp.addr, sockaddr);
 
    if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
        peercnt->reg = reg;
        if (limit) {
            peercnt->limit = limit;
        } else {
            set_peercnt_limit(peercnt);
        }
        ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_sockaddr_stringify_addr(sockaddr), peercnt->limit, peercnt->reg);
        ao2_ref(peercnt, -1); /* decrement ref from find */
    }
}

References peercnt::addr, ao2_find, ao2_ref, ast_debug, ast_sockaddr_copy(), ast_sockaddr_stringify_addr(), peercnt::limit, OBJ_POINTER, peercnts, peercnt::reg, and set_peercnt_limit().

Referenced by __expire_registry(), build_peer(), and update_registry().

peercnt_remove()

static void peercnt_remove ( struct peercnt *  peercnt )

static

Definition at line 2755 of file chan_iax2.c.

{
    struct ast_sockaddr addr;
 
    ast_sockaddr_copy(&addr, &peercnt->addr);
 
    /*
     * Container locked here since peercnt may be unlinked from
     * list.  If left unlocked, peercnt_add could try and grab this
     * entry from the table and modify it at the "same time" this
     * thread attempts to unlink it.
     */
    ao2_lock(peercnts);
    peercnt->cur--;
    ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(&addr));
    /* if this was the last connection from the peer remove it from table */
    if (peercnt->cur == 0) {
        ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
    }
    ao2_unlock(peercnts);
}

References peercnt::addr, ao2_lock, ao2_unlink, ao2_unlock, ast_debug, ast_sockaddr_copy(), ast_sockaddr_stringify_addr(), peercnt::cur, and peercnts.

Referenced by peercnt_remove_by_addr(), and peercnt_remove_cb().

peercnt_remove_by_addr()

static int peercnt_remove_by_addr ( struct ast_sockaddr *  addr )

static

Definition at line 2795 of file chan_iax2.c.

{
    struct peercnt *peercnt;
    struct peercnt tmp;
 
    ast_sockaddr_copy(&tmp.addr, addr);
 
    if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
        peercnt_remove(peercnt);
        ao2_ref(peercnt, -1); /* decrement ref from find */
    }
    return 0;
}

References peercnt::addr, ao2_find, ao2_ref, ast_sockaddr_copy(), OBJ_POINTER, peercnt_remove(), and peercnts.

Referenced by __find_callno(), and complete_transfer().

peercnt_remove_cb()

static int peercnt_remove_cb ( const void *  obj )

static

Definition at line 2781 of file chan_iax2.c.

{
    struct peercnt *peercnt = (struct peercnt *) obj;
 
    peercnt_remove(peercnt);
    ao2_ref(peercnt, -1); /* decrement ref from scheduler */
 
    return 0;
}

References ao2_ref, and peercnt_remove().

Referenced by __unload_module(), and sched_delay_remove().

poke_all_peers()

static void poke_all_peers ( void  )

static

Definition at line 14218 of file chan_iax2.c.

{
    struct ao2_iterator i;
    struct iax2_peer *peer;
 
    i = ao2_iterator_init(peers, 0);
    while ((peer = ao2_iterator_next(&i))) {
        iax2_poke_peer(peer, 0);
        peer_unref(peer);
    }
    ao2_iterator_destroy(&i);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, iax2_poke_peer(), and peer_unref().

Referenced by reload_config().

prune_addr_range_cb()

static int prune_addr_range_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2665 of file chan_iax2.c.

{
    struct addr_range *addr_range = obj;
 
    return addr_range->delme ? CMP_MATCH : 0;
}

References CMP_MATCH, and addr_range::delme.

Referenced by reload_config().

prune_peers()

static void prune_peers ( void  )

static

Definition at line 13664 of file chan_iax2.c.

{
    struct iax2_peer *peer;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(peers, 0);
    while ((peer = ao2_iterator_next(&i))) {
        if (ast_test_flag64(peer, IAX_DELME) || ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
            unlink_peer(peer);
        }
        peer_unref(peer);
    }
    ao2_iterator_destroy(&i);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_test_flag64, IAX_DELME, IAX_RTCACHEFRIENDS, peer_unref(), and unlink_peer().

Referenced by handle_cli_iax2_prune_realtime(), and reload_config().

prune_users()

static void prune_users ( void  )

static

Definition at line 13648 of file chan_iax2.c.

{
    struct iax2_user *user;
    struct ao2_iterator i;
 
    i = ao2_iterator_init(users, 0);
    while ((user = ao2_iterator_next(&i))) {
        if (ast_test_flag64(user, IAX_DELME) || ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
            ao2_unlink(users, user);
        }
        user_unref(user);
    }
    ao2_iterator_destroy(&i);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_unlink, ast_test_flag64, IAX_DELME, IAX_RTCACHEFRIENDS, user, and user_unref().

Referenced by handle_cli_iax2_prune_realtime(), and reload_config().

pvt_cmp_cb()

static int pvt_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 14918 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
 
    /* The frames_received field is used to hold whether we're matching
     * against a full frame or not ... */
 
    return match(&pvt2->addr, pvt2->peercallno, pvt2->callno, pvt,
        pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, chan_iax2_pvt::frames_received, and match().

Referenced by load_objects().

pvt_destructor()

static void pvt_destructor ( void *  obj )

static

Definition at line 2269 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt = obj;
    struct iax_frame *cur = NULL;
    struct signaling_queue_entry *s = NULL;
 
    ast_mutex_lock(&iaxsl[pvt->callno]);
 
    iax2_destroy_helper(pvt);
 
    sched_delay_remove(&pvt->addr, pvt->callno_entry);
    pvt->callno_entry = 0;
 
    /* Already gone */
    ast_set_flag64(pvt, IAX_ALREADYGONE);
 
    AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
        /* Cancel any pending transmissions */
        cur->retries = -1;
    }
 
    ast_mutex_unlock(&iaxsl[pvt->callno]);
 
    while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
        free_signaling_queue_entry(s);
    }
 
    if (pvt->reg) {
        pvt->reg->callno = 0;
    }
 
    if (!pvt->owner) {
        jb_frame frame;
        if (pvt->vars) {
            ast_variables_destroy(pvt->vars);
            pvt->vars = NULL;
        }
 
        while (jb_getall(pvt->jb, &frame) == JB_OK) {
            iax2_frame_free(frame.data);
        }
 
        jb_destroy(pvt->jb);
        ast_string_field_free_memory(pvt);
    }
}

References chan_iax2_pvt::addr, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE, ast_mutex_lock, ast_mutex_unlock, ast_set_flag64, ast_string_field_free_memory, ast_variables_destroy(), iax2_registry::callno, chan_iax2_pvt::callno, chan_iax2_pvt::callno_entry, jb_frame::data, frame_queue, free_signaling_queue_entry(), iax2_destroy_helper(), iax2_frame_free(), IAX_ALREADYGONE, iaxsl, chan_iax2_pvt::jb, jb_destroy(), jb_getall(), JB_OK, signaling_queue_entry::next, NULL, chan_iax2_pvt::owner, chan_iax2_pvt::reg, iax_frame::retries, sched_delay_remove(), chan_iax2_pvt::signaling_queue, and chan_iax2_pvt::vars.

Referenced by new_iax().

pvt_hash_cb()

static int pvt_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 14911 of file chan_iax2.c.

{
    const struct chan_iax2_pvt *pvt = obj;
 
    return pvt->peercallno;
}

References chan_iax2_pvt::peercallno.

Referenced by load_objects().

queue_signalling()

static int queue_signalling ( struct chan_iax2_pvt *  pvt, struct ast_frame *  f  )

static

All frames other than that of type AST_FRAME_IAX must be held until we have received a destination call number.

Definition at line 2244 of file chan_iax2.c.

{
    struct signaling_queue_entry *qe;
 
    if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
        return 1; /* do not queue this frame */
    } else if (!(qe = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
        return -1;  /* out of memory */
    }
 
    /* copy ast_frame into our queue entry */
    qe->f = *f;
    if (qe->f.datalen) {
        /* if there is data in this frame copy it over as well */
        if (!(qe->f.data.ptr = ast_malloc(qe->f.datalen))) {
            free_signaling_queue_entry(qe);
            return -1;
        }
        memcpy(qe->f.data.ptr, f->data.ptr, qe->f.datalen);
    }
    AST_LIST_INSERT_TAIL(&pvt->signaling_queue, qe, next);
 
    return 0;
}

References ast_calloc, AST_FRAME_IAX, AST_LIST_INSERT_TAIL, ast_malloc, ast_frame::data, ast_frame::datalen, signaling_queue_entry::f, ast_frame::frametype, free_signaling_queue_entry(), chan_iax2_pvt::hold_signaling, signaling_queue_entry::next, ast_frame::ptr, and chan_iax2_pvt::signaling_queue.

Referenced by __send_command().

raw_hangup()

static int raw_hangup ( struct ast_sockaddr *  addr, unsigned short  src, unsigned short  dst, int  sockfd  )

static

Definition at line 8160 of file chan_iax2.c.

{
    struct ast_iax2_full_hdr fh;
    fh.scallno = htons(src | IAX_FLAG_FULL);
    fh.dcallno = htons(dst);
    fh.ts = 0;
    fh.oseqno = 0;
    fh.iseqno = 0;
    fh.type = AST_FRAME_IAX;
    fh.csub = compress_subclass(IAX_COMMAND_INVAL);
    iax_outputframe(NULL, &fh, 0, addr, 0);
 
    ast_debug(1, "Raw Hangup %s, src=%d, dst=%d\n", ast_sockaddr_stringify(addr), src, dst);
    return ast_sendto(sockfd, &fh, sizeof(fh), 0, addr);
}

References ast_debug, AST_FRAME_IAX, ast_sendto(), ast_sockaddr_stringify(), compress_subclass(), ast_iax2_full_hdr::csub, ast_iax2_full_hdr::dcallno, IAX_COMMAND_INVAL, IAX_FLAG_FULL, iax_outputframe(), ast_iax2_full_hdr::iseqno, NULL, ast_iax2_full_hdr::oseqno, ast_iax2_full_hdr::scallno, ast_iax2_full_hdr::ts, and ast_iax2_full_hdr::type.

Referenced by socket_process_helper().

realtime_peer()

static struct iax2_peer * realtime_peer ( const char *  peername, struct ast_sockaddr *  addr  )

static

Note

This function calls reg_source_db -> iax2_poke_peer -> find_callno, so do not call this with a pvt lock held.

Note

If this one loaded something, then we need to ensure that the host field matched. The only reason why we can't have this as a criteria is because we only have the IP address and the host field might be set as a name (and the reverse PTR might not match).

Definition at line 4457 of file chan_iax2.c.

{
    struct ast_variable *var = NULL;
    struct ast_variable *tmp;
    struct iax2_peer *peer=NULL;
    time_t regseconds = 0, nowtime;
    int dynamic=0;
    char *str_addr, *str_port;
 
    str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
    str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
 
    if (peername) {
        var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", SENTINEL);
        if (!var && !ast_sockaddr_isnull(addr)) {
            var = ast_load_realtime("iaxpeers", "name", peername, "host", str_addr, SENTINEL);
        }
    } else if (!ast_sockaddr_isnull(addr)) {
        var = ast_load_realtime("iaxpeers", "ipaddr", str_addr, "port", str_port, SENTINEL);
        if (var) {
            /* We'll need the peer name in order to build the structure! */
            for (tmp = var; tmp; tmp = tmp->next) {
                if (!strcasecmp(tmp->name, "name"))
                    peername = tmp->value;
            }
        }
    }
    if (!var && peername) { /* Last ditch effort */
        var = ast_load_realtime("iaxpeers", "name", peername, SENTINEL);
        /*!\note
         * If this one loaded something, then we need to ensure that the host
         * field matched.  The only reason why we can't have this as a criteria
         * is because we only have the IP address and the host field might be
         * set as a name (and the reverse PTR might not match).
         */
        if (var && !ast_sockaddr_isnull(addr)) {
            for (tmp = var; tmp; tmp = tmp->next) {
                if (!strcasecmp(tmp->name, "host")) {
                    struct ast_sockaddr *hostaddr = NULL;
 
                    if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
                        || ast_sockaddr_cmp_addr(hostaddr, addr)) {
                        /* No match */
                        ast_variables_destroy(var);
                        var = NULL;
                    }
                    ast_free(hostaddr);
                    break;
                }
            }
        }
    }
    if (!var)
        return NULL;
 
    peer = build_peer(peername, var, NULL, ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
 
    if (!peer) {
        ast_variables_destroy(var);
        return NULL;
    }
 
    for (tmp = var; tmp; tmp = tmp->next) {
        /* Make sure it's not a user only... */
        if (!strcasecmp(tmp->name, "type")) {
            if (strcasecmp(tmp->value, "friend") &&
                strcasecmp(tmp->value, "peer")) {
                /* Whoops, we weren't supposed to exist! */
                peer = peer_unref(peer);
                break;
            }
        } else if (!strcasecmp(tmp->name, "regseconds")) {
            ast_get_time_t(tmp->value, &regseconds, 0, NULL);
        } else if (!strcasecmp(tmp->name, "ipaddr")) {
            int setport = ast_sockaddr_port(&peer->addr);
            if (ast_parse_arg(tmp->value, PARSE_ADDR | PARSE_PORT_FORBID, NULL)) {
                ast_log(LOG_WARNING, "Failed to parse sockaddr '%s' for ipaddr of realtime peer '%s'\n", tmp->value, tmp->name);
            } else {
                ast_sockaddr_parse(&peer->addr, tmp->value, 0);
            }
            ast_sockaddr_set_port(&peer->addr, setport);
        } else if (!strcasecmp(tmp->name, "port")) {
            int bindport;
            if (ast_parse_arg(tmp->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
                bindport = IAX_DEFAULT_PORTNO;
            }
            ast_sockaddr_set_port(&peer->addr, bindport);
        } else if (!strcasecmp(tmp->name, "host")) {
            if (!strcasecmp(tmp->value, "dynamic"))
                dynamic = 1;
        }
    }
 
    ast_variables_destroy(var);
 
    if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
        ast_copy_flags64(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
        if (ast_test_flag64(peer, IAX_RTAUTOCLEAR)) {
            if (peer->expire > -1) {
                if (!AST_SCHED_DEL(sched, peer->expire)) {
                    peer->expire = -1;
                    peer_unref(peer);
                }
            }
            peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
            if (peer->expire == -1)
                peer_unref(peer);
        }
        ao2_link(peers, peer);
        if (ast_test_flag64(peer, IAX_DYNAMIC))
            reg_source_db(peer);
    } else {
        ast_set_flag64(peer, IAX_TEMPONLY);
    }
 
    if (!ast_test_flag64(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
        time(&nowtime);
        if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
            memset(&peer->addr, 0, sizeof(peer->addr));
            realtime_update_peer(peer->name, &peer->addr, 0);
            ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
                peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
        }
        else {
            ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
                peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
        }
    }
 
    return peer;
}

References iax2_peer::addr, ao2_link, AST_AF_UNSPEC, ast_copy_flags64, ast_debug, ast_free, ast_get_time_t(), ast_load_realtime(), ast_log, ast_parse_arg(), AST_SCHED_DEL, ast_set_flag64, ast_sockaddr_cmp_addr(), ast_sockaddr_isnull(), ast_sockaddr_parse(), ast_sockaddr_port, ast_sockaddr_resolve(), ast_sockaddr_set_port, ast_sockaddr_stringify_addr(), ast_sockaddr_stringify_port(), ast_strdupa, ast_test_flag64, ast_variables_destroy(), build_peer(), iax2_peer::expire, expire_registry(), global_rtautoclear, globalflags, iax2_sched_add(), IAX_DEFAULT_PORTNO, IAX_DEFAULT_REG_EXPIRE, IAX_DYNAMIC, IAX_RTAUTOCLEAR, IAX_RTCACHEFRIENDS, IAX_RTIGNOREREGEXPIRE, IAX_TEMPONLY, LOG_WARNING, iax2_peer::name, ast_variable::name, ast_variable::next, NULL, PARSE_ADDR, PARSE_IN_RANGE, PARSE_PORT_FORBID, PARSE_UINT32, peer_ref(), peer_unref(), realtime_update_peer(), reg_source_db(), SENTINEL, ast_variable::value, and var.

Referenced by authenticate_reply(), calltoken_required(), find_peer(), and iax2_getpeername().

realtime_update_peer()

static void realtime_update_peer ( const char *  peername, struct ast_sockaddr *  sockaddr, time_t  regtime  )

static

Definition at line 4664 of file chan_iax2.c.

{
    char regseconds[20];
    const char *sysname = ast_config_AST_SYSTEM_NAME;
    char *syslabel = NULL;
    char *port;
 
    if (ast_strlen_zero(sysname))   /* No system name, disable this */
        sysname = NULL;
    else if (ast_test_flag64(&globalflags, IAX_RTSAVE_SYSNAME))
        syslabel = "regserver";
 
    snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
    port = ast_strdupa(ast_sockaddr_stringify_port(sockaddr));
    ast_update_realtime("iaxpeers", "name", peername,
        "ipaddr", ast_sockaddr_isnull(sockaddr) ? "" : ast_sockaddr_stringify_addr(sockaddr),
        "port", ast_sockaddr_isnull(sockaddr) ? "" : port,
        "regseconds", regseconds, syslabel, sysname, SENTINEL); /* note syslabel can be NULL */
}

References ast_config_AST_SYSTEM_NAME, ast_sockaddr_isnull(), ast_sockaddr_stringify_addr(), ast_sockaddr_stringify_port(), ast_strdupa, ast_strlen_zero(), ast_test_flag64, ast_update_realtime(), globalflags, IAX_RTSAVE_SYSNAME, NULL, and SENTINEL.

Referenced by __expire_registry(), realtime_peer(), and update_registry().

realtime_user()

static struct iax2_user * realtime_user ( const char *  username, struct ast_sockaddr *  addr  )

static

Note

If this one loaded something, then we need to ensure that the host field matched. The only reason why we can't have this as a criteria is because we only have the IP address and the host field might be set as a name (and the reverse PTR might not match).

Definition at line 4589 of file chan_iax2.c.

{
    struct ast_variable *var;
    struct ast_variable *tmp;
    struct iax2_user *user=NULL;
    char *str_addr, *str_port;
 
    str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
    str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
 
    var = ast_load_realtime("iaxusers", "name", username, "host", "dynamic", SENTINEL);
    if (!var)
        var = ast_load_realtime("iaxusers", "name", username, "host", str_addr, SENTINEL);
    if (!var && !ast_sockaddr_isnull(addr)) {
        var = ast_load_realtime("iaxusers", "name", username, "ipaddr", str_addr, "port", str_port, SENTINEL);
        if (!var)
            var = ast_load_realtime("iaxusers", "ipaddr", str_addr, "port", str_port, SENTINEL);
    }
    if (!var) { /* Last ditch effort */
        var = ast_load_realtime("iaxusers", "name", username, SENTINEL);
        /*!\note
         * If this one loaded something, then we need to ensure that the host
         * field matched.  The only reason why we can't have this as a criteria
         * is because we only have the IP address and the host field might be
         * set as a name (and the reverse PTR might not match).
         */
        if (var) {
            for (tmp = var; tmp; tmp = tmp->next) {
                if (!strcasecmp(tmp->name, "host")) {
                    struct ast_sockaddr *hostaddr = NULL;
 
                    if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
                        || ast_sockaddr_cmp_addr(hostaddr, addr)) {
                        /* No match */
                        ast_variables_destroy(var);
                        var = NULL;
                    }
                    ast_free(hostaddr);
                    break;
                }
            }
        }
    }
    if (!var)
        return NULL;
 
    tmp = var;
    while(tmp) {
        /* Make sure it's not a peer only... */
        if (!strcasecmp(tmp->name, "type")) {
            if (strcasecmp(tmp->value, "friend") &&
                strcasecmp(tmp->value, "user")) {
                return NULL;
            }
        }
        tmp = tmp->next;
    }
 
    user = build_user(username, var, NULL, !ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS));
 
    ast_variables_destroy(var);
 
    if (!user)
        return NULL;
 
    if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
        ast_set_flag64(user, IAX_RTCACHEFRIENDS);
        ao2_link(users, user);
    } else {
        ast_set_flag64(user, IAX_TEMPONLY);
    }
 
    return user;
}

References ao2_link, AST_AF_UNSPEC, ast_free, ast_load_realtime(), ast_set_flag64, ast_sockaddr_cmp_addr(), ast_sockaddr_isnull(), ast_sockaddr_resolve(), ast_sockaddr_stringify_addr(), ast_sockaddr_stringify_port(), ast_strdupa, ast_test_flag64, ast_variables_destroy(), build_user(), globalflags, IAX_RTCACHEFRIENDS, IAX_TEMPONLY, ast_variable::name, ast_variable::next, NULL, PARSE_PORT_FORBID, SENTINEL, user, ast_variable::value, and var.

Referenced by calltoken_required(), and check_access().

reg_source_db()

static void reg_source_db ( struct iax2_peer *  p )

static

Definition at line 9130 of file chan_iax2.c.

{
    char data[80];
    char *expiry;
 
    if (ast_test_flag64(p, IAX_TEMPONLY) || ast_db_get("IAX/Registry", p->name, data, sizeof(data))) {
        return;
    }
 
    expiry = strrchr(data, ':');
    if (!expiry) {
        ast_log(LOG_NOTICE, "IAX/Registry astdb entry missing expiry: '%s'\n", data);
        return;
    }
    *expiry++ = '\0';
 
    if (!ast_sockaddr_parse(&p->addr, data, PARSE_PORT_REQUIRE)) {
        ast_log(LOG_NOTICE, "IAX/Registry astdb host:port invalid - '%s'\n", data);
        return;
    }
 
    p->expiry = atoi(expiry);
 
    ast_verb(3, "Seeding '%s' at %s for %d\n", p->name,
        ast_sockaddr_stringify(&p->addr), p->expiry);
 
    iax2_poke_peer(p, 0);
    if (p->expire > -1) {
        if (!AST_SCHED_DEL(sched, p->expire)) {
            p->expire = -1;
            peer_unref(p);
        }
    }
 
    ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
 
    p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
    if (p->expire == -1) {
        peer_unref(p);
    }
 
    if (iax2_regfunk) {
        iax2_regfunk(p->name, 1);
    }
 
    register_peer_exten(p, 1);
}

References iax2_peer::addr, ast_db_get(), AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_log, AST_SCHED_DEL, ast_sockaddr_parse(), ast_sockaddr_stringify(), ast_test_flag64, ast_verb, iax2_peer::expire, expire_registry(), iax2_peer::expiry, iax2_poke_peer(), iax2_regfunk, iax2_sched_add(), IAX_TEMPONLY, LOG_NOTICE, iax2_peer::name, PARSE_PORT_REQUIRE, peer_ref(), peer_unref(), and register_peer_exten().

Referenced by realtime_peer(), and set_config().

register_peer_exten()

static void register_peer_exten ( struct iax2_peer *  peer, int  onoff  )

static

Definition at line 9042 of file chan_iax2.c.

{
    char multi[256];
    char *stringp, *ext;
    if (!ast_strlen_zero(regcontext)) {
        ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
        stringp = multi;
        while((ext = strsep(&stringp, "&"))) {
            if (onoff) {
                if (!ast_exists_extension(NULL, regcontext, ext, 1, NULL))
                    ast_add_extension(regcontext, 1, ext, 1, NULL, NULL,
                              "Noop", ast_strdup(peer->name), ast_free_ptr, "IAX2");
            } else
                ast_context_remove_extension(regcontext, ext, 1, NULL);
        }
    }
}

References ast_add_extension(), ast_context_remove_extension(), ast_copy_string(), ast_exists_extension(), ast_free_ptr(), ast_strdup, ast_strlen_zero(), ext, iax2_peer::name, NULL, regcontext, iax2_peer::regexten, S_OR, and strsep().

Referenced by __expire_registry(), peer_destructor(), reg_source_db(), and update_registry().

register_verify()

static int register_verify ( int  callno, struct ast_sockaddr *  addr, struct iax_ies *  ies  )

static

Verify inbound registration.

Definition at line 8343 of file chan_iax2.c.

{
    char requeststr[256] = "";
    char peer[256] = "";
    char md5secret[256] = "";
    char rsasecret[256] = "";
    char secret[256] = "";
    struct iax2_peer *p = NULL;
    struct ast_key *key;
    char *keyn;
    int x;
    int expire = 0;
    int res = -1;
 
    ast_clear_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
    /* iaxs[callno]->peer[0] = '\0'; not necc. any more-- stringfield is pre-inited to null string */
    if (ies->username)
        ast_copy_string(peer, ies->username, sizeof(peer));
    if (ies->password)
        ast_copy_string(secret, ies->password, sizeof(secret));
    if (ies->md5_result)
        ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
    if (ies->rsa_result)
        ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
    if (ies->refresh)
        expire = ies->refresh;
 
    if (ast_strlen_zero(peer)) {
        ast_log(LOG_NOTICE, "Empty registration from %s\n", ast_sockaddr_stringify_addr(addr));
        return -1;
    }
 
    /* SLD: first call to lookup peer during registration */
    ast_mutex_unlock(&iaxsl[callno]);
    p = find_peer(peer, 1);
    ast_mutex_lock(&iaxsl[callno]);
    if (!p || !iaxs[callno]) {
        if (iaxs[callno]) {
            int plaintext = ((last_authmethod & IAX_AUTH_PLAINTEXT) | (iaxs[callno]->authmethods & IAX_AUTH_PLAINTEXT));
            /* Anything, as long as it's non-blank */
            ast_string_field_set(iaxs[callno], secret, "badsecret");
            /* An AUTHREQ must be sent in response to a REGREQ of an invalid peer unless
             * 1. A challenge already exists indicating a AUTHREQ was already sent out.
             * 2. A plaintext secret is present in ie as result of a previous AUTHREQ requesting it.
             * 3. A plaintext secret is present in the ie and the last_authmethod used by a peer happened
             *    to be plaintext, indicating it is an authmethod used by other peers on the system.
             *
             * If none of these cases exist, res will be returned as 0 without authentication indicating
             * an AUTHREQ needs to be sent out. */
 
            if (ast_strlen_zero(iaxs[callno]->challenge) &&
                !(!ast_strlen_zero(secret) && plaintext)) {
                /* by setting res to 0, an REGAUTH will be sent */
                res = 0;
            }
        }
        if (authdebug && !p)
            ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
        goto return_unref;
    }
 
    if (!ast_test_flag64(p, IAX_DYNAMIC)) {
        if (authdebug)
            ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
        goto return_unref;
    }
 
    if (!ast_apply_acl(p->acl, addr, "IAX2 Peer ACL: ")) {
        if (authdebug)
            ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
        goto return_unref;
    }
    ast_string_field_set(iaxs[callno], secret, p->secret);
    ast_string_field_set(iaxs[callno], inkeys, p->inkeys);
    /* Check secret against what we have on file */
    if (!ast_strlen_zero(rsasecret) && (p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(iaxs[callno]->challenge)) {
        if (!ast_strlen_zero(p->inkeys)) {
            char *tmpkey;
            char *stringp=NULL;
            if (!(tmpkey = ast_strdup(p->inkeys))) {
                ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
                goto return_unref;
            }
            stringp = tmpkey;
            keyn = strsep(&stringp, ":");
            while(keyn) {
                key = ast_key_get(keyn, AST_KEY_PUBLIC);
                if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
                    ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
                    break;
                } else if (!key)
                    ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
                keyn = strsep(&stringp, ":");
            }
            ast_free(tmpkey);
            if (!keyn) {
                if (authdebug)
                    ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
                goto return_unref;
            }
        } else {
            if (authdebug)
                ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
            goto return_unref;
        }
    } else if (!ast_strlen_zero(md5secret) && (p->authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(iaxs[callno]->challenge)) {
        struct MD5Context md5;
        unsigned char digest[16];
        char *tmppw, *stringp;
 
        tmppw = ast_strdupa(p->secret);
        stringp = tmppw;
        while((tmppw = strsep(&stringp, ";"))) {
            MD5Init(&md5);
            MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
            MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
            MD5Final(digest, &md5);
            for (x=0;x<16;x++)
                sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
            if (!strcasecmp(requeststr, md5secret))
                break;
        }
        if (tmppw) {
            ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
        } else {
            if (authdebug)
                ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", ast_sockaddr_stringify_addr(addr), p->name, requeststr, md5secret);
            goto return_unref;
        }
    } else if (!ast_strlen_zero(secret) && (p->authmethods & IAX_AUTH_PLAINTEXT)) {
        /* They've provided a plain text password and we support that */
        if (strcmp(secret, p->secret)) {
            if (authdebug)
                ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
            goto return_unref;
        } else
            ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
    } else if (!ast_strlen_zero(iaxs[callno]->challenge) && ast_strlen_zero(md5secret) && ast_strlen_zero(rsasecret)) {
        /* if challenge has been sent, but no challenge response if given, reject. */
        goto return_unref;
    }
    ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
 
    /* either Authentication has taken place, or a REGAUTH must be sent before verifying registration */
    res = 0;
 
return_unref:
    if (iaxs[callno]) {
        ast_string_field_set(iaxs[callno], peer, peer);
 
        /* Choose lowest expiry number */
        if (expire && (expire < iaxs[callno]->expiry)) {
            iaxs[callno]->expiry = expire;
        }
    }
 
    if (p) {
        peer_unref(p);
    }
    return res;
}

References iax2_peer::acl, ast_apply_acl(), ast_check_signature(), ast_clear_flag, ast_copy_string(), AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_free, ast_key_get(), AST_KEY_PUBLIC, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_set_flag, ast_sockaddr_stringify_addr(), ast_strdup, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag64, authdebug, iax2_peer::authmethods, challenge(), chan_iax2_pvt::expiry, find_peer(), IAX_AUTH_MD5, IAX_AUTH_PLAINTEXT, IAX_AUTH_RSA, IAX_DYNAMIC, IAX_STATE_AUTHENTICATED, iaxs, iaxsl, iax2_peer::inkeys, last_authmethod, LOG_ERROR, LOG_NOTICE, LOG_WARNING, md5(), iax_ies::md5_result, MD5Final(), MD5Init(), MD5Update(), iax2_peer::name, NULL, iax_ies::password, peer_unref(), iax_ies::refresh, iax_ies::rsa_result, iax2_peer::secret, strsep(), and iax_ies::username.

Referenced by socket_process_helper().

registry_authrequest()

static int registry_authrequest ( int  callno )

static

Definition at line 9362 of file chan_iax2.c.

{
    struct iax_ie_data ied;
    struct iax2_peer *p;
    char challenge[10];
    const char *peer_name;
    int sentauthmethod;
 
    peer_name = ast_strdupa(iaxs[callno]->peer);
 
    /* SLD: third call to find_peer in registration */
    ast_mutex_unlock(&iaxsl[callno]);
    if ((p = find_peer(peer_name, 1))) {
        last_authmethod = p->authmethods;
    }
 
    ast_mutex_lock(&iaxsl[callno]);
    if (!iaxs[callno])
        goto return_unref;
 
    memset(&ied, 0, sizeof(ied));
    /* The selection of which delayed reject is sent may leak information,
     * if it sets a static response.  For example, if a host is known to only
     * use MD5 authentication, then an RSA response would indicate that the
     * peer does not exist, and vice-versa.
     * Therefore, we use whatever the last peer used (which may vary over the
     * course of a server, which should leak minimal information). */
    sentauthmethod = p ? p->authmethods : last_authmethod ? last_authmethod : IAX_AUTH_MD5;
    if (!p) {
        iaxs[callno]->authmethods = sentauthmethod;
    }
    iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, sentauthmethod);
    if (sentauthmethod & (IAX_AUTH_RSA | IAX_AUTH_MD5)) {
        /* Build the challenge */
        snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
        ast_string_field_set(iaxs[callno], challenge, challenge);
        iax_ie_append_str(&ied, IAX_IE_CHALLENGE, iaxs[callno]->challenge);
    }
    iax_ie_append_str(&ied, IAX_IE_USERNAME, peer_name);
 
return_unref:
    if (p) {
        peer_unref(p);
    }
 
    return iaxs[callno] ? send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGAUTH, 0, ied.buf, ied.pos, -1) : -1;
}

References AST_FRAME_IAX, ast_mutex_lock, ast_mutex_unlock, ast_random(), ast_strdupa, ast_string_field_set, iax2_peer::authmethods, chan_iax2_pvt::authmethods, iax_ie_data::buf, iax2_peer::callno, challenge(), find_peer(), IAX_AUTH_MD5, IAX_AUTH_RSA, IAX_COMMAND_REGAUTH, iax_ie_append_short(), iax_ie_append_str(), IAX_IE_AUTHMETHODS, IAX_IE_CHALLENGE, IAX_IE_USERNAME, iaxs, iaxsl, last_authmethod, peer_unref(), iax_ie_data::pos, and send_command().

Referenced by socket_process_helper().

registry_rerequest()

static int registry_rerequest ( struct iax_ies *  ies, int  callno, struct ast_sockaddr *  addr  )

static

Definition at line 9410 of file chan_iax2.c.

{
    struct iax2_registry *reg;
    /* Start pessimistic */
    struct iax_ie_data ied;
    char peer[256] = "";
    char challenge[256] = "";
    int res;
    int authmethods = 0;
    if (ies->authmethods)
        authmethods = ies->authmethods;
    if (ies->username)
        ast_copy_string(peer, ies->username, sizeof(peer));
    if (ies->challenge)
        ast_copy_string(challenge, ies->challenge, sizeof(challenge));
    memset(&ied, 0, sizeof(ied));
    reg = iaxs[callno]->reg;
    if (reg) {
 
        if (ast_sockaddr_cmp(&reg->addr, addr)) {
            ast_log(LOG_WARNING, "Received unsolicited registry authenticate request from '%s'\n", ast_sockaddr_stringify(addr));
            return -1;
        }
        if (ast_strlen_zero(reg->secret)) {
            ast_log(LOG_NOTICE, "No secret associated with peer '%s'\n", reg->username);
            reg->regstate = REG_STATE_NOAUTH;
            return -1;
        }
        iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
        iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
        if (reg->secret[0] == '[') {
            char tmpkey[256];
            ast_copy_string(tmpkey, reg->secret + 1, sizeof(tmpkey));
            tmpkey[strlen(tmpkey) - 1] = '\0';
            res = authenticate(challenge, NULL, tmpkey, authmethods, &ied, addr, NULL);
        } else
            res = authenticate(challenge, reg->secret, NULL, authmethods, &ied, addr, NULL);
        if (!res) {
            reg->regstate = REG_STATE_AUTHSENT;
            add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
            return send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
        } else
            return -1;
        ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
    } else
        ast_log(LOG_NOTICE, "Can't reregister without a reg\n");
    return -1;
}

References add_empty_calltoken_ie(), iax2_registry::addr, ast_copy_string(), AST_FRAME_IAX, ast_log, ast_sockaddr_cmp(), ast_sockaddr_stringify(), ast_strlen_zero(), authenticate(), iax_ies::authmethods, iax_ie_data::buf, iax_ies::challenge, challenge(), IAX_COMMAND_REGREQ, iax_ie_append_short(), iax_ie_append_str(), IAX_IE_REFRESH, IAX_IE_USERNAME, iaxs, LOG_NOTICE, LOG_WARNING, NULL, iax_ie_data::pos, iax2_registry::refresh, chan_iax2_pvt::reg, REG_STATE_AUTHSENT, REG_STATE_NOAUTH, iax2_registry::regstate, iax2_registry::secret, send_command(), iax2_registry::username, and iax_ies::username.

Referenced by socket_process_helper().

regstate2str()

static char * regstate2str ( int  regstate )

static

Definition at line 7446 of file chan_iax2.c.

{
    switch(regstate) {
    case REG_STATE_UNREGISTERED:
        return "Unregistered";
    case REG_STATE_REGSENT:
        return "Request Sent";
    case REG_STATE_AUTHSENT:
        return "Auth. Sent";
    case REG_STATE_REGISTERED:
        return "Registered";
    case REG_STATE_REJECTED:
        return "Rejected";
    case REG_STATE_TIMEOUT:
        return "Timeout";
    case REG_STATE_NOAUTH:
        return "No Authentication";
    default:
        return "Unknown";
    }
}

References REG_STATE_AUTHSENT, REG_STATE_NOAUTH, REG_STATE_REGISTERED, REG_STATE_REGSENT, REG_STATE_REJECTED, REG_STATE_TIMEOUT, and REG_STATE_UNREGISTERED.

Referenced by handle_cli_iax2_show_registry(), and manager_iax2_show_registry().

reload()

static int reload ( void  )

static

Definition at line 14279 of file chan_iax2.c.

{
    return reload_config(0);
}

References reload_config().

Referenced by set_config().

reload_config()

static int reload_config ( int  forced_reload )

static

Definition at line 14230 of file chan_iax2.c.

{
    static const char config[] = "iax.conf";
    struct iax2_registry *reg;
 
    if (set_config(config, 1, forced_reload) > 0) {
        prune_peers();
        prune_users();
        ao2_callback(callno_limits, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
        ao2_callback(calltoken_ignores, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
        ao2_callback(peercnts, OBJ_NODATA, set_peercnt_limit_all_cb, NULL);
        trunk_timed = trunk_untimed = 0;
        trunk_nmaxmtu = trunk_maxmtu = 0;
        memset(&debugaddr, '\0', sizeof(debugaddr));
 
        AST_LIST_LOCK(&registrations);
        AST_LIST_TRAVERSE(&registrations, reg, entry)
            iax2_do_register(reg);
        AST_LIST_UNLOCK(&registrations);
 
        /* Qualify hosts, too */
        poke_all_peers();
    }
 
    iax_firmware_reload();
    iax_provision_reload(1);
    ast_unload_realtime("iaxpeers");
 
    return 0;
}

References ao2_callback, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_unload_realtime(), callno_limits, calltoken_ignores, config, debugaddr, iax2_registry::entry, iax2_do_register(), iax_firmware_reload(), iax_provision_reload(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, peercnts, poke_all_peers(), prune_addr_range_cb(), prune_peers(), prune_users(), set_config(), set_peercnt_limit_all_cb(), trunk_maxmtu, trunk_nmaxmtu, trunk_timed, and trunk_untimed.

Referenced by acl_change_stasis_cb(), handle_cli_iax2_reload(), and reload().

remove_by_peercallno()

static void remove_by_peercallno ( struct chan_iax2_pvt *  pvt )

static

Definition at line 2501 of file chan_iax2.c.

{
    if (!pvt->peercallno) {
        ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
        return;
    }
 
    ao2_unlink(iax_peercallno_pvts, pvt);
}

References ao2_unlink, ast_log, iax_peercallno_pvts, LOG_ERROR, and chan_iax2_pvt::peercallno.

Referenced by complete_transfer(), iax2_destroy(), resend_with_token(), and socket_process_helper().

remove_by_transfercallno()

static void remove_by_transfercallno ( struct chan_iax2_pvt *  pvt )

static

Definition at line 2482 of file chan_iax2.c.

{
    if (!pvt->transfercallno) {
        ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
        return;
    }
 
    ao2_unlink(iax_transfercallno_pvts, pvt);
}

References ao2_unlink, ast_log, iax_transfercallno_pvts, LOG_ERROR, and chan_iax2_pvt::transfercallno.

Referenced by complete_transfer(), and iax2_destroy().

replace_callno()

static int replace_callno ( const void *  obj )

static

Definition at line 3055 of file chan_iax2.c.

{
    callno_entry entry = PTR_TO_CALLNO_ENTRY(obj);
    struct call_number_pool *pool;
 
    /* We lock here primarily to ensure thread safety of the
     * total_nonval_callno_used check and decrement */
    ast_mutex_lock(&callno_pool_lock);
 
    if (!CALLNO_ENTRY_IS_VALIDATED(entry)) {
        if (total_nonval_callno_used) {
            total_nonval_callno_used--;
        } else {
            ast_log(LOG_ERROR,
                "Attempted to decrement total non calltoken validated "
                "callnumbers below zero.  Callno is: %d\n",
                CALLNO_ENTRY_GET_CALLNO(entry));
        }
    }
 
    if (CALLNO_ENTRY_GET_CALLNO(entry) < TRUNK_CALL_START) {
        pool = &callno_pool;
    } else {
        pool = &callno_pool_trunk;
    }
 
    ast_assert(pool->capacity > pool->available);
 
    /* This clears the validated flag */
    entry = CALLNO_ENTRY_GET_CALLNO(entry);
 
    pool->numbers[pool->available] = entry;
    pool->available++;
 
    ast_mutex_unlock(&callno_pool_lock);
 
    return 0;
}

References ast_assert, ast_log, ast_mutex_lock, ast_mutex_unlock, call_number_pool::available, CALLNO_ENTRY_GET_CALLNO, CALLNO_ENTRY_IS_VALIDATED, callno_pool, callno_pool_lock, callno_pool_trunk, call_number_pool::capacity, LOG_ERROR, call_number_pool::numbers, PTR_TO_CALLNO_ENTRY, total_nonval_callno_used, and TRUNK_CALL_START.

Referenced by __find_callno(), make_trunk(), and sched_delay_remove().

requirecalltoken_mark_auto()

static void requirecalltoken_mark_auto ( const char *  name, int  subclass  )

static

Definition at line 4990 of file chan_iax2.c.

{
    struct iax2_user *user = NULL;
    struct iax2_peer *peer = NULL;
 
    if (ast_strlen_zero(name)) {
        return; /* no username given */
    }
 
    if ((subclass == IAX_COMMAND_NEW) && (user = find_user(name)) && (user->calltoken_required == CALLTOKEN_AUTO)) {
        user->calltoken_required = CALLTOKEN_YES;
    } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(name, 1)) && (peer->calltoken_required == CALLTOKEN_AUTO)) {
        peer->calltoken_required = CALLTOKEN_YES;
    }
 
    if (peer) {
        peer_unref(peer);
    }
    if (user) {
        user_unref(user);
    }
}

References ast_strlen_zero(), CALLTOKEN_AUTO, iax2_peer::calltoken_required, CALLTOKEN_YES, find_peer(), find_user(), IAX_COMMAND_NEW, name, NULL, peer_unref(), and user_unref().

Referenced by handle_call_token().

resend_with_token()

static void resend_with_token ( int  callno, struct iax_frame *  f, const char *  newtoken  )

static

Definition at line 4908 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt = iaxs[callno];
    int frametype = f->af.frametype;
    int subclass = f->af.subclass.integer;
    struct {
        struct ast_iax2_full_hdr fh;
        struct iax_ie_data ied;
    } data = {
        .ied.buf = { 0 },
        .ied.pos = 0,
    };
    /* total len - header len gives us the frame's IE len */
    int ie_data_pos = f->datalen - sizeof(struct ast_iax2_full_hdr);
 
    if (!pvt) {
        return;  /* this should not be possible if called from socket_process() */
    }
 
    /*
     * Check to make sure last frame sent is valid for call token resend
     * 1. Frame should _NOT_ be encrypted since it starts the IAX dialog
     * 2. Frame should _NOT_ already have a destination callno
     * 3. Frame must be a valid iax_frame subclass capable of starting dialog
     * 4. Pvt must have a calltoken_ie_len which represents the number of
     *    bytes at the end of the frame used for the previous calltoken ie.
     * 5. Pvt's calltoken_ie_len must be _LESS_ than the total IE length
     * 6. Total length of f->data must be _LESS_ than size of our data struct
     *    because f->data must be able to fit within data.
     */
    if (f->encmethods || f->dcallno || !iax2_allow_new(frametype, subclass, 0)
        || !pvt->calltoken_ie_len || (pvt->calltoken_ie_len > ie_data_pos) ||
        (f->datalen > sizeof(data))) {
 
        return;  /* ignore resend, token was not valid for the dialog */
    }
 
    /* token is valid
     * 1. Copy frame data over
     * 2. Redo calltoken IE, it will always be the last ie in the frame.
     *    NOTE: Having the ie always be last is not protocol specified,
     *    it is only an implementation choice.  Since we only expect the ie to
     *    be last for frames we have sent, this can no way be affected by
     *    another end point.
     * 3. Remove frame from queue
     * 4. Free old frame
     * 5. Clear previous seqnos
     * 6. Resend with CALLTOKEN ie.
     */
 
    /* ---1.--- */
    memcpy(&data, f->data, f->datalen);
    data.ied.pos = ie_data_pos;
 
    /* ---2.--- */
    /* move to the beginning of the calltoken ie so we can write over it */
    data.ied.pos -= pvt->calltoken_ie_len;
    iax_ie_append_str(&data.ied, IAX_IE_CALLTOKEN, newtoken);
 
    /* make sure to update token length incase it ever has to be stripped off again */
    pvt->calltoken_ie_len = data.ied.pos - ie_data_pos; /* new pos minus old pos tells how big token ie is */
 
    /* ---3.--- */
    AST_LIST_REMOVE(&frame_queue[callno], f, list);
 
    /* ---4.--- */
    iax2_frame_free(f);
 
    /* ---5.--- */
    pvt->oseqno = 0;
    pvt->rseqno = 0;
    pvt->iseqno = 0;
    pvt->aseqno = 0;
    if (pvt->peercallno) {
        remove_by_peercallno(pvt);
        pvt->peercallno = 0;
    }
 
    /* ---6.--- */
    send_command(pvt, AST_FRAME_IAX, subclass, 0, data.ied.buf, data.ied.pos, -1);
}

References iax_frame::af, chan_iax2_pvt::aseqno, AST_FRAME_IAX, AST_LIST_REMOVE, iax_ie_data::buf, chan_iax2_pvt::callno, chan_iax2_pvt::calltoken_ie_len, iax_frame::data, iax_frame::datalen, iax_frame::dcallno, iax_frame::encmethods, frame_queue, ast_frame::frametype, iax2_allow_new(), iax2_frame_free(), iax_ie_append_str(), IAX_IE_CALLTOKEN, iaxs, ast_frame_subclass::integer, chan_iax2_pvt::iseqno, chan_iax2_pvt::oseqno, chan_iax2_pvt::peercallno, remove_by_peercallno(), chan_iax2_pvt::rseqno, send_command(), and ast_frame::subclass.

Referenced by socket_process_helper().

save_osptoken()

static void save_osptoken ( struct iax_frame *  fr, struct iax_ies *  ies  )

static

Definition at line 9821 of file chan_iax2.c.

{
    int i;
    unsigned int length, offset = 0;
    char full_osptoken[IAX_MAX_OSPBUFF_SIZE];
 
    for (i = 0; i < IAX_MAX_OSPBLOCK_NUM; i++) {
        length = ies->ospblocklength[i];
        if (length != 0) {
            if (length > IAX_MAX_OSPBLOCK_SIZE) {
                /* OSP token block length wrong, clear buffer */
                offset = 0;
                break;
            } else {
                memcpy(full_osptoken + offset, ies->osptokenblock[i], length);
                offset += length;
            }
        } else {
            break;
        }
    }
    *(full_osptoken + offset) = '\0';
    if (strlen(full_osptoken) != offset) {
        /* OSP token length wrong, clear buffer */
        *full_osptoken = '\0';
    }
 
    ast_string_field_set(iaxs[fr->callno], osptoken, full_osptoken);
}

References ast_string_field_set, iax_frame::callno, IAX_MAX_OSPBLOCK_NUM, IAX_MAX_OSPBLOCK_SIZE, IAX_MAX_OSPBUFF_SIZE, iaxs, iax_ies::ospblocklength, and iax_ies::osptokenblock.

Referenced by socket_process_helper().

save_rr()

static void save_rr ( struct iax_frame *  fr, struct iax_ies *  ies  )

static

Definition at line 9810 of file chan_iax2.c.

{
    iaxs[fr->callno]->remote_rr.jitter = ies->rr_jitter;
    iaxs[fr->callno]->remote_rr.losspct = ies->rr_loss >> 24;
    iaxs[fr->callno]->remote_rr.losscnt = ies->rr_loss & 0xffffff;
    iaxs[fr->callno]->remote_rr.packets = ies->rr_pkts;
    iaxs[fr->callno]->remote_rr.delay = ies->rr_delay;
    iaxs[fr->callno]->remote_rr.dropped = ies->rr_dropped;
    iaxs[fr->callno]->remote_rr.ooo = ies->rr_ooo;
}

References iax_frame::callno, iax_rr::delay, iax_rr::dropped, iaxs, iax_rr::jitter, iax_rr::losscnt, iax_rr::losspct, iax_rr::ooo, iax_rr::packets, chan_iax2_pvt::remote_rr, iax_ies::rr_delay, iax_ies::rr_dropped, iax_ies::rr_jitter, iax_ies::rr_loss, iax_ies::rr_ooo, and iax_ies::rr_pkts.

Referenced by socket_process_helper().

sched_delay_remove()

static void sched_delay_remove ( struct ast_sockaddr *  addr, callno_entry  entry  )

static

Definition at line 3127 of file chan_iax2.c.

{
    int i;
    struct peercnt *peercnt;
    struct peercnt tmp;
 
    ast_sockaddr_copy(&tmp.addr, addr);
 
    if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
        /* refcount is incremented with ao2_find.  keep that ref for the scheduler */
        ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_sockaddr_stringify_addr(addr), MIN_REUSE_TIME);
        i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
        if (i == -1) {
            ao2_ref(peercnt, -1);
        }
    }
 
    iax2_sched_add(
        sched,
        MIN_REUSE_TIME * 1000,
        replace_callno,
        CALLNO_ENTRY_TO_PTR(entry));
}

References peercnt::addr, ao2_find, ao2_ref, ast_debug, ast_sockaddr_copy(), ast_sockaddr_stringify_addr(), CALLNO_ENTRY_TO_PTR, iax2_sched_add(), MIN_REUSE_TIME, OBJ_POINTER, peercnt_remove_cb(), peercnts, and replace_callno().

Referenced by pvt_destructor().

schedule_delivery()

static int schedule_delivery ( struct iax_frame *  fr, int  updatehistory, int  fromtrunk, unsigned int *  tsout  )

static

Note

This function assumes fr->callno is locked

IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno] was valid before calling it, it may no longer be valid after calling it.

Definition at line 4316 of file chan_iax2.c.

{
    int type, len;
    int ret;
    int needfree = 0;
 
    /*
     * Clear fr->af.data if there is no data in the buffer.  Things
     * like AST_CONTROL_HOLD without a suggested music class must
     * have a NULL pointer.
     */
    if (!fr->af.datalen) {
        memset(&fr->af.data, 0, sizeof(fr->af.data));
    }
 
    /* Attempt to recover wrapped timestamps */
    unwrap_timestamp(fr);
 
    /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
    if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
        fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
    else {
#if 0
        ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
#endif
        fr->af.delivery = ast_tv(0,0);
    }
 
    type = JB_TYPE_CONTROL;
    len = 0;
 
    if(fr->af.frametype == AST_FRAME_VOICE) {
        type = JB_TYPE_VOICE;
        len = ast_codec_samples_count(&fr->af) / (ast_format_get_sample_rate(fr->af.subclass.format) / 1000);
    } else if(fr->af.frametype == AST_FRAME_CNG) {
        type = JB_TYPE_SILENCE;
    }
 
    if ( (!ast_test_flag64(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
        if (tsout)
            *tsout = fr->ts;
        __do_deliver(fr);
        return -1;
    }
 
    /* insert into jitterbuffer */
    /* TODO: Perhaps we could act immediately if it's not droppable and late */
    ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
            calc_rxstamp(iaxs[fr->callno],fr->ts));
    if (ret == JB_DROP) {
        needfree++;
    } else if (ret == JB_SCHED) {
        update_jbsched(iaxs[fr->callno]);
    }
    if (tsout)
        *tsout = fr->ts;
    if (needfree) {
        /* Free our iax frame */
        iax2_frame_free(fr);
        return -1;
    }
    return 0;
}

References __do_deliver(), iax_frame::af, ast_codec_samples_count(), ast_debug, ast_format_get_sample_rate(), AST_FRAME_CNG, AST_FRAME_VOICE, ast_samp2tv(), ast_test_flag64, ast_tv(), ast_tvadd(), ast_tvzero(), calc_rxstamp(), iax_frame::callno, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_frame_subclass::format, ast_frame::frametype, iax2_frame_free(), IAX_USEJITTERBUF, iaxs, chan_iax2_pvt::jb, JB_DROP, jb_put(), JB_SCHED, JB_TYPE_CONTROL, JB_TYPE_SILENCE, JB_TYPE_VOICE, len(), chan_iax2_pvt::rxcore, ast_frame::subclass, iax_frame::ts, type, unwrap_timestamp(), and update_jbsched().

Referenced by socket_process_helper(), and socket_process_meta().

scheduled_destroy()

static int scheduled_destroy ( const void *  vid )

static

Definition at line 2209 of file chan_iax2.c.

{
    unsigned short callno = PTR_TO_CALLNO(vid);
    ast_mutex_lock(&iaxsl[callno]);
    if (iaxs[callno]) {
        ast_debug(1, "Really destroying %d now...\n", callno);
        iax2_destroy(callno);
    }
    ast_mutex_unlock(&iaxsl[callno]);
    return 0;
}

References ast_debug, ast_mutex_lock, ast_mutex_unlock, iax2_destroy(), iaxs, iaxsl, and PTR_TO_CALLNO.

Referenced by iax2_hangup().

send_apathetic_reply()

static int send_apathetic_reply ( unsigned short  callno, unsigned short  dcallno, struct ast_sockaddr *  addr, int  command, int  ts, unsigned char  seqno, int  sockfd, struct iax_ie_data *  ied  )

static

Definition at line 4870 of file chan_iax2.c.

{
    struct {
        struct ast_iax2_full_hdr f;
        struct iax_ie_data ied;
    } data;
    size_t size = sizeof(struct ast_iax2_full_hdr);
 
    if (ied) {
        size += ied->pos;
        memcpy(&data.ied, ied->buf, ied->pos);
    }
 
    data.f.scallno = htons(0x8000 | callno);
    data.f.dcallno = htons(dcallno & ~IAX_FLAG_RETRANS);
    data.f.ts = htonl(ts);
    data.f.iseqno = seqno;
    data.f.oseqno = 0;
    data.f.type = AST_FRAME_IAX;
    data.f.csub = compress_subclass(command);
 
    iax_outputframe(NULL, &data.f, 0, addr, size - sizeof(struct ast_iax2_full_hdr));
 
    return ast_sendto(sockfd, &data, size, 0, addr);
}

References AST_FRAME_IAX, ast_sendto(), iax_ie_data::buf, compress_subclass(), ast_iax2_full_hdr::dcallno, IAX_FLAG_RETRANS, iax_outputframe(), NULL, iax_ie_data::pos, and ast_iax2_full_hdr::ts.

Referenced by handle_call_token(), and socket_process_helper().

send_command()

static int send_command ( struct chan_iax2_pvt *  i, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen, int  seqno  )

static

Definition at line 7871 of file chan_iax2.c.

{
    if (type == AST_FRAME_CONTROL && !iax2_is_control_frame_allowed(command)) {
        /* Control frame should not go out on the wire. */
        ast_debug(2, "Callno %d: Blocked sending control frame %d.\n",
            i->callno, command);
        return 0;
    }
    return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
}

References __send_command(), ast_debug, AST_FRAME_CONTROL, chan_iax2_pvt::callno, ast_frame::data, ast_frame::datalen, iax2_is_control_frame_allowed(), ast_frame::seqno, ast_frame::ts, and type.

Referenced by __attempt_transmit(), __send_lagrq(), __send_ping(), authenticate_reply(), authenticate_request(), cache_get_callno_locked(), dp_lookup(), iax2_call(), iax2_do_register(), iax2_dprequest(), iax2_indicate(), iax2_key_rotate(), iax2_poke_peer(), iax2_provision(), registry_authrequest(), registry_rerequest(), resend_with_token(), send_command_locked(), and socket_process_helper().

send_command_final()

static int send_command_final ( struct chan_iax2_pvt *  i, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen, int  seqno  )

static

Note

Since this function calls iax2_predestroy() -> iax2_queue_hangup(), the pvt struct for the given call number may disappear during its execution.

Definition at line 7896 of file chan_iax2.c.

{
    int call_num = i->callno;
    /* It is assumed that the callno has already been locked */
    iax2_predestroy(i->callno);
    if (!iaxs[call_num])
        return -1;
    return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
}

References __send_command(), chan_iax2_pvt::callno, ast_frame::data, ast_frame::datalen, iax2_predestroy(), iaxs, ast_frame::seqno, ast_frame::ts, and type.

Referenced by __auth_reject(), __auto_hangup(), authenticate_request(), iax2_hangup(), socket_process_helper(), and update_registry().

send_command_immediate()

static int send_command_immediate ( struct chan_iax2_pvt *  i, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen, int  seqno  )

static

Definition at line 7906 of file chan_iax2.c.

{
    return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
}

References __send_command(), ast_frame::data, ast_frame::datalen, ast_frame::seqno, ast_frame::ts, and type.

Referenced by iax2_vnak(), and socket_process_helper().

send_command_locked()

static int send_command_locked ( unsigned short  callno, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen, int  seqno  )

static

Definition at line 7882 of file chan_iax2.c.

{
    int res;
    ast_mutex_lock(&iaxsl[callno]);
    res = send_command(iaxs[callno], type, command, ts, data, datalen, seqno);
    ast_mutex_unlock(&iaxsl[callno]);
    return res;
}

References ast_mutex_lock, ast_mutex_unlock, ast_frame::data, ast_frame::datalen, iaxs, iaxsl, send_command(), ast_frame::seqno, ast_frame::ts, and type.

Referenced by iax2_answer(), iax2_digit_begin(), iax2_digit_end(), iax2_sendhtml(), iax2_sendimage(), iax2_sendtext(), iax2_setoption(), and iax2_transfer().

send_command_transfer()

static int send_command_transfer ( struct chan_iax2_pvt *  i, char  type, int  command, unsigned int  ts, const unsigned char *  data, int  datalen  )

static

Definition at line 7911 of file chan_iax2.c.

{
    return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
}

References __send_command(), ast_frame::data, ast_frame::datalen, ast_frame::ts, and type.

Referenced by socket_process_helper(), and try_transfer().

send_lagrq()

static int send_lagrq ( const void *  data )

static

Definition at line 1877 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__send_lagrq, data))
#endif
        __send_lagrq(data);
    return 0;
}

References __send_lagrq(), and schedule_action.

Referenced by __find_callno(), __send_lagrq(), and make_trunk().

send_packet()

static int send_packet ( struct iax_frame *  f )

static

Definition at line 3475 of file chan_iax2.c.

{
    int res;
    int callno = f->callno;
 
    /* Don't send if there was an error, but return error instead */
    if (!callno || !iaxs[callno] || iaxs[callno]->error)
        return -1;
 
    /* Called with iaxsl held */
    if (iaxdebug) {
        ast_debug(8, "Sending %u on %d/%d to %s\n", f->ts, callno, iaxs[callno]->peercallno, ast_sockaddr_stringify(&iaxs[callno]->addr));
    }
    if (f->transfer) {
        iax_outputframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
        res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->transfer);
    } else {
        iax_outputframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
        res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->addr);
    }
    if (res < 0) {
        if (iaxdebug)
            ast_debug(1, "Received error: %s\n", strerror(errno));
        handle_error();
    } else
        res = 0;
 
    return res;
}

References chan_iax2_pvt::addr, ast_debug, ast_sendto(), ast_sockaddr_stringify(), iax_frame::callno, iax_frame::data, iax_frame::datalen, errno, error(), handle_error(), iax_outputframe(), iaxdebug, iaxs, NULL, chan_iax2_pvt::peercallno, chan_iax2_pvt::transfer, transfer(), iax_frame::transfer, and iax_frame::ts.

Referenced by __attempt_transmit(), iax2_send(), transmit_frame(), and vnak_retransmit().

send_ping()

static int send_ping ( const void *  data )

static

Definition at line 1813 of file chan_iax2.c.

{
#ifdef SCHED_MULTITHREADED
    if (schedule_action(__send_ping, data))
#endif
        __send_ping(data);
 
    return 0;
}

References __send_ping(), and schedule_action.

Referenced by __find_callno(), __send_ping(), and make_trunk().

send_signaling()

static void send_signaling ( struct chan_iax2_pvt *  pvt )

static

This function must be called once we are sure the other side has given us a call number. All signaling is held here until that point.

Definition at line 2231 of file chan_iax2.c.

{
    struct signaling_queue_entry *s = NULL;
 
    while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
        iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
        free_signaling_queue_entry(s);
    }
    pvt->hold_signaling = 0;
}

References AST_LIST_REMOVE_HEAD, signaling_queue_entry::f, free_signaling_queue_entry(), chan_iax2_pvt::hold_signaling, iax2_send(), signaling_queue_entry::next, NULL, and chan_iax2_pvt::signaling_queue.

Referenced by socket_process_helper().

send_trunk()

static int send_trunk ( struct iax2_trunk_peer *  tpeer, struct timeval *  now  )

static

Definition at line 9591 of file chan_iax2.c.

{
    int res = 0;
    struct iax_frame *fr;
    struct ast_iax2_meta_hdr *meta;
    struct ast_iax2_meta_trunk_hdr *mth;
    int calls = 0;
 
    /* Point to frame */
    fr = (struct iax_frame *)tpeer->trunkdata;
    /* Point to meta data */
    meta = (struct ast_iax2_meta_hdr *)fr->afdata;
    mth = (struct ast_iax2_meta_trunk_hdr *)meta->data;
    if (tpeer->trunkdatalen) {
        /* We're actually sending a frame, so fill the meta trunk header and meta header */
        meta->zeros = 0;
        meta->metacmd = IAX_META_TRUNK;
        if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS))
            meta->cmddata = IAX_META_TRUNK_MINI;
        else
            meta->cmddata = IAX_META_TRUNK_SUPERMINI;
        mth->ts = htonl(calc_txpeerstamp(tpeer, trunkfreq, now));
        /* And the rest of the ast_iax2 header */
        fr->direction = DIRECTION_OUTGRESS;
        fr->retrans = -1;
        fr->transfer = 0;
        /* Any appropriate call will do */
        fr->data = fr->afdata;
        fr->datalen = tpeer->trunkdatalen + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr);
        res = transmit_trunk(fr, &tpeer->addr, tpeer->sockfd);
        calls = tpeer->calls;
#if 0
        ast_debug(1, "Trunking %d call chunks in %d bytes to %s:%d, ts=%d\n", calls, fr->datalen, ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port), ntohl(mth->ts));
#endif
        /* Reset transmit trunk side data */
        tpeer->trunkdatalen = 0;
        tpeer->calls = 0;
    }
    if (res < 0)
        return res;
    return calls;
}

References iax2_trunk_peer::addr, iax_frame::afdata, ast_debug, ast_inet_ntoa(), ast_test_flag64, calc_txpeerstamp(), iax2_trunk_peer::calls, iax_frame::data, iax_frame::datalen, iax_frame::direction, DIRECTION_OUTGRESS, globalflags, IAX_META_TRUNK, IAX_META_TRUNK_MINI, IAX_META_TRUNK_SUPERMINI, IAX_TRUNKTIMESTAMPS, if(), env::meta, iax_frame::retrans, iax2_trunk_peer::sockfd, iax_frame::transfer, transmit_trunk(), iax2_trunk_peer::trunkdata, iax2_trunk_peer::trunkdatalen, trunkfreq, and ast_iax2_meta_trunk_hdr::ts.

Referenced by iax2_trunk_queue(), and timing_read().

set_config()

static int set_config ( const char *  config_file, int  reload, int  forced  )

static

Load configuration.

Definition at line 13696 of file chan_iax2.c.

{
    struct ast_config *cfg, *ucfg;
    iax2_format capability;
    struct ast_variable *v;
    char *cat;
    const char *utype;
    const char *tosval;
    int format;
    int portno = IAX_DEFAULT_PORTNO;
    int  x;
    int mtuv;
    int subscribe_network_change = 1;
    struct iax2_user *user;
    struct iax2_peer *peer;
    struct ast_netsock *ns;
    struct ast_flags config_flags = { (reload && !forced) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    struct ast_sockaddr bindaddr;
    struct iax2_codec_pref prefs_new;
 
    cfg = ast_config_load(config_file, config_flags);
 
    if (!cfg) {
        ast_log(LOG_ERROR, "Unable to load config %s\n", config_file);
        return -1;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        ucfg = ast_config_load("users.conf", config_flags);
        if (ucfg == CONFIG_STATUS_FILEUNCHANGED)
            return 0;
        /* Otherwise we need to reread both files */
        ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
        if ((cfg = ast_config_load(config_file, config_flags)) == CONFIG_STATUS_FILEINVALID) {
            ast_log(LOG_ERROR, "Config file %s is in an invalid format.  Aborting.\n", config_file);
            ast_config_destroy(ucfg);
            return 0;
        }
        if (!cfg) {
            /* should have been able to load the config here */
            ast_log(LOG_ERROR, "Unable to load config %s again\n", config_file);
            return -1;
        }
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file %s is in an invalid format.  Aborting.\n", config_file);
        return 0;
    } else { /* iax.conf changed, gotta reread users.conf, too */
        ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
        if ((ucfg = ast_config_load("users.conf", config_flags)) == CONFIG_STATUS_FILEINVALID) {
            ast_log(LOG_ERROR, "Config file users.conf is in an invalid format.  Aborting.\n");
            ast_config_destroy(cfg);
            return 0;
        }
    }
 
    if (reload) {
        set_config_destroy();
    }
 
    ast_sockaddr_parse(&bindaddr, "0.0.0.0:0", 0);
 
    /* Setup new codec prefs */
    capability = iax2_codec_pref_from_bitfield(&prefs_new, IAX_CAPABILITY_FULLBANDWIDTH);
 
    /* Reset Global Flags */
    memset(&globalflags, 0, sizeof(globalflags));
    ast_set_flag64(&globalflags, IAX_RTUPDATE);
    ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
 
#ifdef SO_NO_CHECK
    nochecksums = 0;
#endif
    /* Reset default parking lot */
    default_parkinglot[0] = '\0';
 
    min_reg_expire = IAX_DEFAULT_REG_EXPIRE;
    max_reg_expire = IAX_DEFAULT_REG_EXPIRE;
    global_max_trunk_mtu = MAX_TRUNK_MTU;
    global_maxcallno = DEFAULT_MAXCALLNO_LIMIT;
    global_maxcallno_nonval = DEFAULT_MAXCALLNO_LIMIT_NONVAL;
 
    maxauthreq = 3;
 
    srvlookup = 0;
    iax2_authmethods = 0;
 
    v = ast_variable_browse(cfg, "general");
 
    /* Seed initial tos value */
    tosval = ast_variable_retrieve(cfg, "general", "tos");
    if (tosval) {
        if (ast_str2tos(tosval, &qos.tos))
            ast_log(LOG_WARNING, "Invalid tos value, refer to QoS documentation\n");
    }
    /* Seed initial cos value */
    tosval = ast_variable_retrieve(cfg, "general", "cos");
    if (tosval) {
        if (ast_str2cos(tosval, &qos.cos))
            ast_log(LOG_WARNING, "Invalid cos value, refer to QoS documentation\n");
    }
    while(v) {
        if (!strcasecmp(v->name, "bindport")) {
            if (reload) {
                ast_log(LOG_NOTICE, "Ignoring bindport on reload\n");
            }
            else if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &portno, 1024, 65535)) {
                portno = IAX_DEFAULT_PORTNO;
            }
        } else if (!strcasecmp(v->name, "pingtime")){
            ping_time = atoi(v->value);
        }
        else if (!strcasecmp(v->name, "iaxthreadcount")) {
            if (reload) {
                if (atoi(v->value) != iaxthreadcount)
                    ast_log(LOG_NOTICE, "Ignoring any changes to iaxthreadcount during reload\n");
            } else {
                iaxthreadcount = atoi(v->value);
                if (iaxthreadcount < 1) {
                    ast_log(LOG_NOTICE, "iaxthreadcount must be at least 1.\n");
                    iaxthreadcount = 1;
                } else if (iaxthreadcount > 256) {
                    ast_log(LOG_NOTICE, "limiting iaxthreadcount to 256\n");
                    iaxthreadcount = 256;
                }
            }
        } else if (!strcasecmp(v->name, "iaxmaxthreadcount")) {
            if (reload) {
                AST_LIST_LOCK(&dynamic_list);
                iaxmaxthreadcount = atoi(v->value);
                AST_LIST_UNLOCK(&dynamic_list);
            } else {
                iaxmaxthreadcount = atoi(v->value);
                if (iaxmaxthreadcount < 0) {
                    ast_log(LOG_NOTICE, "iaxmaxthreadcount must be at least 0.\n");
                    iaxmaxthreadcount = 0;
                } else if (iaxmaxthreadcount > 256) {
                    ast_log(LOG_NOTICE, "Limiting iaxmaxthreadcount to 256\n");
                    iaxmaxthreadcount = 256;
                }
            }
        } else if (!strcasecmp(v->name, "nochecksums")) {
#ifdef SO_NO_CHECK
            if (ast_true(v->value))
                nochecksums = 1;
            else
                nochecksums = 0;
#else
            if (ast_true(v->value))
                ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
#endif
        }
        else if (!strcasecmp(v->name, "maxjitterbuffer"))
            maxjitterbuffer = atoi(v->value);
        else if (!strcasecmp(v->name, "resyncthreshold"))
            resyncthreshold = atoi(v->value);
        else if (!strcasecmp(v->name, "maxjitterinterps"))
            maxjitterinterps = atoi(v->value);
        else if (!strcasecmp(v->name, "jittertargetextra"))
            jittertargetextra = atoi(v->value);
        else if (!strcasecmp(v->name, "lagrqtime"))
            lagrq_time = atoi(v->value);
        else if (!strcasecmp(v->name, "maxregexpire"))
            max_reg_expire = atoi(v->value);
        else if (!strcasecmp(v->name, "minregexpire"))
            min_reg_expire = atoi(v->value);
        else if (!strcasecmp(v->name, "bindaddr")) {
            if (reload) {
                ast_log(LOG_NOTICE, "Ignoring bindaddr on reload\n");
            } else {
 
                if (!ast_parse_arg(v->value, PARSE_ADDR, NULL)) {
 
                    ast_sockaddr_parse(&bindaddr, v->value, 0);
 
                    if (!ast_sockaddr_port(&bindaddr)) {
                        ast_sockaddr_set_port(&bindaddr, portno);
                    }
 
                    if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
                        ast_log(LOG_WARNING, "Unable to apply binding to '%s' at line %d\n", v->value, v->lineno);
                    } else {
                        ast_verb(2, "Binding IAX2 to address %s\n", ast_sockaddr_stringify(&bindaddr));
 
                        if (defaultsockfd < 0) {
                            defaultsockfd = ast_netsock_sockfd(ns);
                        }
                        ast_netsock_unref(ns);
                    }
 
                } else {
                    ast_log(LOG_WARNING, "Invalid address '%s' specified, at line %d\n", v->value, v->lineno);
                }
            }
        } else if (!strcasecmp(v->name, "auth")) {
            iax2_authmethods = get_auth_methods(v->value);
            if (iax2_authmethods & IAX_AUTH_PLAINTEXT) {
                ast_log(LOG_WARNING, "Default auth method is set to deprecated 'plaintext' at line %d of iax.conf\n", v->lineno);
            }
        } else if (!strcasecmp(v->name, "authdebug")) {
            authdebug = ast_true(v->value);
        } else if (!strcasecmp(v->name, "encryption")) {
                iax2_encryption |= get_encrypt_methods(v->value);
                if (!iax2_encryption) {
                    ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
                }
        } else if (!strcasecmp(v->name, "forceencryption")) {
            if (ast_false(v->value)) {
                ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
            } else {
                iax2_encryption |= get_encrypt_methods(v->value);
                if (iax2_encryption) {
                    ast_set_flag64((&globalflags), IAX_FORCE_ENCRYPT);
                }
            }
        } else if (!strcasecmp(v->name, "transfer")) {
            if (!strcasecmp(v->value, "mediaonly")) {
                ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
            } else if (ast_true(v->value)) {
                ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
            } else
                ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
        } else if (!strcasecmp(v->name, "codecpriority")) {
            if(!strcasecmp(v->value, "caller"))
                ast_set_flag64((&globalflags), IAX_CODEC_USER_FIRST);
            else if(!strcasecmp(v->value, "disabled"))
                ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
            else if(!strcasecmp(v->value, "reqonly")) {
                ast_set_flag64((&globalflags), IAX_CODEC_NOCAP);
                ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
            }
        } else if (!strcasecmp(v->name, "jitterbuffer"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_USEJITTERBUF);
        else if (!strcasecmp(v->name, "delayreject"))
            delayreject = ast_true(v->value);
        else if (!strcasecmp(v->name, "allowfwdownload"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_ALLOWFWDOWNLOAD);
        else if (!strcasecmp(v->name, "rtcachefriends"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTCACHEFRIENDS);
        else if (!strcasecmp(v->name, "rtignoreregexpire"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTIGNOREREGEXPIRE);
        else if (!strcasecmp(v->name, "rtupdate"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTUPDATE);
        else if (!strcasecmp(v->name, "rtsavesysname"))
            ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTSAVE_SYSNAME);
        else if (!strcasecmp(v->name, "trunktimestamps"))
            ast_set2_flag64(&globalflags, ast_true(v->value), IAX_TRUNKTIMESTAMPS);
        else if (!strcasecmp(v->name, "rtautoclear")) {
            int i = atoi(v->value);
            if(i > 0)
                global_rtautoclear = i;
            else
                i = 0;
            ast_set2_flag64((&globalflags), i || ast_true(v->value), IAX_RTAUTOCLEAR);
        } else if (!strcasecmp(v->name, "trunkfreq")) {
            trunkfreq = atoi(v->value);
            if (trunkfreq < 10) {
                ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 10ms instead.\n");
                trunkfreq = 10;
            } else if (trunkfreq > 1000) {
                ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 1000ms instead.\n");
                trunkfreq = 1000;
            }
            if (timer) {
                ast_timer_set_rate(timer, 1000 / trunkfreq);
            }
        } else if (!strcasecmp(v->name, "trunkmtu")) {
            mtuv = atoi(v->value);
            if (mtuv  == 0 )
                global_max_trunk_mtu = 0;
            else if (mtuv >= 172 && mtuv < 4000)
                global_max_trunk_mtu = mtuv;
            else
                ast_log(LOG_NOTICE, "trunkmtu value out of bounds (%d) at line %d\n",
                    mtuv, v->lineno);
        } else if (!strcasecmp(v->name, "trunkmaxsize")) {
            trunkmaxsize = atoi(v->value);
            if (trunkmaxsize == 0)
                trunkmaxsize = MAX_TRUNKDATA;
        } else if (!strcasecmp(v->name, "autokill")) {
            if (sscanf(v->value, "%30d", &x) == 1) {
                if (x >= 0)
                    autokill = x;
                else
                    ast_log(LOG_NOTICE, "Nice try, but autokill has to be >0 or 'yes' or 'no' at line %d\n", v->lineno);
            } else if (ast_true(v->value)) {
                autokill = DEFAULT_MAXMS;
            } else {
                autokill = 0;
            }
        } else if (!strcasecmp(v->name, "bandwidth")) {
            if (!strcasecmp(v->value, "low")) {
                capability = iax2_codec_pref_from_bitfield(&prefs_new,
                    IAX_CAPABILITY_LOWBANDWIDTH);
            } else if (!strcasecmp(v->value, "medium")) {
                capability = iax2_codec_pref_from_bitfield(&prefs_new,
                    IAX_CAPABILITY_MEDBANDWIDTH);
            } else if (!strcasecmp(v->value, "high")) {
                capability = iax2_codec_pref_from_bitfield(&prefs_new,
                    IAX_CAPABILITY_FULLBANDWIDTH);
            } else {
                ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
            }
        } else if (!strcasecmp(v->name, "allow")) {
            iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 1);
        } else if (!strcasecmp(v->name, "disallow")) {
            iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 0);
        } else if (!strcasecmp(v->name, "register")) {
            iax2_register(v->value, v->lineno);
        } else if (!strcasecmp(v->name, "iaxcompat")) {
            iaxcompat = ast_true(v->value);
        } else if (!strcasecmp(v->name, "regcontext")) {
            ast_copy_string(regcontext, v->value, sizeof(regcontext));
            /* Create context if it doesn't exist already */
            ast_context_find_or_create(NULL, NULL, regcontext, "IAX2");
        } else if (!strcasecmp(v->name, "tos")) {
            if (ast_str2tos(v->value, &qos.tos))
                ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
        } else if (!strcasecmp(v->name, "cos")) {
            if (ast_str2cos(v->value, &qos.cos))
                ast_log(LOG_WARNING, "Invalid cos value at line %d, refer to QoS documentation\n", v->lineno);
        } else if (!strcasecmp(v->name, "parkinglot")) {
            ast_copy_string(default_parkinglot, v->value, sizeof(default_parkinglot));
        } else if (!strcasecmp(v->name, "accountcode")) {
            ast_copy_string(accountcode, v->value, sizeof(accountcode));
        } else if (!strcasecmp(v->name, "mohinterpret")) {
            ast_copy_string(mohinterpret, v->value, sizeof(mohinterpret));
        } else if (!strcasecmp(v->name, "mohsuggest")) {
            ast_copy_string(mohsuggest, v->value, sizeof(mohsuggest));
        } else if (!strcasecmp(v->name, "amaflags")) {
            format = ast_channel_string2amaflag(v->value);
            if (format < 0) {
                ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
            } else {
                amaflags = format;
            }
        } else if (!strcasecmp(v->name, "language")) {
            ast_copy_string(language, v->value, sizeof(language));
        } else if (!strcasecmp(v->name, "maxauthreq")) {
            maxauthreq = atoi(v->value);
            if (maxauthreq < 0)
                maxauthreq = 0;
        } else if (!strcasecmp(v->name, "adsi")) {
            adsi = ast_true(v->value);
        } else if (!strcasecmp(v->name, "srvlookup")) {
            srvlookup = ast_true(v->value);
        } else if (!strcasecmp(v->name, "connectedline")) {
            if (ast_true(v->value)) {
                ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
            } else if (!strcasecmp(v->value, "send")) {
                ast_clear_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
                ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
            } else if (!strcasecmp(v->value, "receive")) {
                ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
                ast_set_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
            } else {
                ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
            }
        } else if (!strcasecmp(v->name, "maxcallnumbers")) {
            if (sscanf(v->value, "%10hu", &global_maxcallno) != 1) {
                ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number.  %s is not valid at line %d\n", v->value, v->lineno);
            }
        } else if (!strcasecmp(v->name, "maxcallnumbers_nonvalidated")) {
            if (sscanf(v->value, "%10hu", &global_maxcallno_nonval) != 1) {
                ast_log(LOG_WARNING, "maxcallnumbers_nonvalidated must be set to a valid number.  %s is not valid at line %d.\n", v->value, v->lineno);
            }
        } else if (!strcasecmp(v->name, "calltokenoptional")) {
            if (add_calltoken_ignore(v->value)) {
                ast_log(LOG_WARNING, "Invalid calltokenoptional address range - '%s' line %d\n", v->value, v->lineno);
                return -1;
            }
        } else if (!strcasecmp(v->name, "calltokenexpiration")) {
            int temp = -1;
            sscanf(v->value, "%u", &temp);
            if( temp <= 0 ){
                ast_log(LOG_WARNING, "Invalid calltokenexpiration value %s. Should be integer greater than 0.\n", v->value);
            } else {
                max_calltoken_delay = temp;
            }
        }  else if (!strcasecmp(v->name, "subscribe_network_change_event")) {
            if (ast_true(v->value)) {
                subscribe_network_change = 1;
            } else if (ast_false(v->value)) {
                subscribe_network_change = 0;
            } else {
                ast_log(LOG_WARNING, "subscribe_network_change_event value %s is not valid at line %d.\n", v->value, v->lineno);
            }
        } else if (!strcasecmp(v->name, "shrinkcallerid")) {
            if (ast_true(v->value)) {
                ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
            } else if (ast_false(v->value)) {
                ast_clear_flag64((&globalflags), IAX_SHRINKCALLERID);
            } else {
                ast_log(LOG_WARNING, "shrinkcallerid value %s is not valid at line %d.\n", v->value, v->lineno);
            }
        }/*else if (strcasecmp(v->name,"type")) */
        /*  ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
        v = v->next;
    }
 
    if (subscribe_network_change) {
        network_change_stasis_subscribe();
    } else {
        network_change_stasis_unsubscribe();
    }
 
    if (defaultsockfd < 0) {
 
        ast_sockaddr_set_port(&bindaddr, portno);
 
        if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
            ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
        } else {
            ast_verb(2, "Binding IAX2 to default address %s\n", ast_sockaddr_stringify(&bindaddr));
            defaultsockfd = ast_netsock_sockfd(ns);
            ast_netsock_unref(ns);
        }
    }
    if (reload) {
        ast_netsock_release(outsock);
        outsock = ast_netsock_list_alloc();
        if (!outsock) {
            ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
            return -1;
        }
        ast_netsock_init(outsock);
    }
 
    if (min_reg_expire > max_reg_expire) {
        ast_log(LOG_WARNING, "Minimum registration interval of %d is more than maximum of %d, resetting minimum to %d\n",
            min_reg_expire, max_reg_expire, max_reg_expire);
        min_reg_expire = max_reg_expire;
    }
    prefs_global = prefs_new;
    iax2_capability = capability;
 
    if (ucfg) {
        struct ast_variable *gen;
        int genhasiax;
        int genregisteriax;
        const char *hasiax, *registeriax;
 
        genhasiax = ast_true(ast_variable_retrieve(ucfg, "general", "hasiax"));
        genregisteriax = ast_true(ast_variable_retrieve(ucfg, "general", "registeriax"));
        gen = ast_variable_browse(ucfg, "general");
        cat = ast_category_browse(ucfg, NULL);
        while (cat) {
            if (strcasecmp(cat, "general")) {
                hasiax = ast_variable_retrieve(ucfg, cat, "hasiax");
                registeriax = ast_variable_retrieve(ucfg, cat, "registeriax");
                if (ast_true(hasiax) || (!hasiax && genhasiax)) {
                    /* Start with general parameters, then specific parameters, user and peer */
                    user = build_user(cat, gen, ast_variable_browse(ucfg, cat), 0);
                    if (user) {
                        ao2_link(users, user);
                        user = user_unref(user);
                    }
                    peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
                    if (peer) {
                        if (ast_test_flag64(peer, IAX_DYNAMIC)) {
                            reg_source_db(peer);
                        }
                        ao2_link(peers, peer);
                        peer = peer_unref(peer);
                    }
                }
                if (ast_true(registeriax) || (!registeriax && genregisteriax)) {
                    char tmp[256];
                    const char *host = ast_variable_retrieve(ucfg, cat, "host");
                    const char *username = ast_variable_retrieve(ucfg, cat, "username");
                    const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
                    if (!host)
                        host = ast_variable_retrieve(ucfg, "general", "host");
                    if (!username)
                        username = ast_variable_retrieve(ucfg, "general", "username");
                    if (!secret)
                        secret = ast_variable_retrieve(ucfg, "general", "secret");
                    if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
                        if (!ast_strlen_zero(secret))
                            snprintf(tmp, sizeof(tmp), "%s:%s@%s", username, secret, host);
                        else
                            snprintf(tmp, sizeof(tmp), "%s@%s", username, host);
                        iax2_register(tmp, 0);
                    }
                }
            }
            cat = ast_category_browse(ucfg, cat);
        }
        ast_config_destroy(ucfg);
    }
 
    cat = ast_category_browse(cfg, NULL);
    while(cat) {
        if (strcasecmp(cat, "general")) {
            utype = ast_variable_retrieve(cfg, cat, "type");
            if (!strcasecmp(cat, "callnumberlimits")) {
                build_callno_limits(ast_variable_browse(cfg, cat));
            } else if (utype) {
                if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) {
                    user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
                    if (user) {
                        ao2_link(users, user);
                        user = user_unref(user);
                    }
                }
                if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) {
                    peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
                    if (peer) {
                        if (ast_test_flag64(peer, IAX_DYNAMIC))
                            reg_source_db(peer);
                        ao2_link(peers, peer);
                        peer = peer_unref(peer);
                    }
                } else if (strcasecmp(utype, "user")) {
                    ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file);
                }
            } else
                ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
        }
        cat = ast_category_browse(cfg, cat);
    }
    ast_config_destroy(cfg);
    return 1;
}

References accountcode, add_calltoken_ignore(), adsi, amaflags, ao2_link, ast_category_browse(), ast_channel_string2amaflag(), ast_clear_flag, ast_clear_flag64, ast_config_destroy(), ast_config_load, ast_context_find_or_create(), ast_copy_string(), ast_false(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, ast_netsock_bindaddr(), ast_netsock_init(), ast_netsock_list_alloc(), ast_netsock_release(), ast_netsock_sockfd(), ast_netsock_unref(), ast_parse_arg(), ast_set2_flag64, ast_set_flag64, ast_set_flags_to64, ast_sockaddr_parse(), ast_sockaddr_port, ast_sockaddr_set_port, ast_sockaddr_stringify(), ast_str2cos(), ast_str2tos(), ast_strlen_zero(), ast_test_flag64, ast_timer_set_rate(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), ast_verb, authdebug, autokill, bindaddr, build_callno_limits(), build_peer(), build_user(), config_file, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_MAXCALLNO_LIMIT, DEFAULT_MAXCALLNO_LIMIT_NONVAL, DEFAULT_MAXMS, default_parkinglot, defaultsockfd, delayreject, errno, gen, get_auth_methods(), get_encrypt_methods(), global_max_trunk_mtu, global_maxcallno, global_maxcallno_nonval, global_rtautoclear, globalflags, iax2_authmethods, iax2_capability, iax2_codec_pref_from_bitfield(), iax2_encryption, iax2_parse_allow_disallow(), iax2_register(), IAX_ALLOWFWDOWNLOAD, IAX_AUTH_PLAINTEXT, IAX_CAPABILITY_FULLBANDWIDTH, IAX_CAPABILITY_LOWBANDWIDTH, IAX_CAPABILITY_MEDBANDWIDTH, IAX_CODEC_NOCAP, IAX_CODEC_NOPREFS, IAX_CODEC_USER_FIRST, IAX_DEFAULT_PORTNO, IAX_DEFAULT_REG_EXPIRE, IAX_DYNAMIC, IAX_FORCE_ENCRYPT, IAX_NOTRANSFER, IAX_RECVCONNECTEDLINE, IAX_RTAUTOCLEAR, IAX_RTCACHEFRIENDS, IAX_RTIGNOREREGEXPIRE, IAX_RTSAVE_SYSNAME, IAX_RTUPDATE, IAX_SENDCONNECTEDLINE, IAX_SHRINKCALLERID, IAX_TRANSFERMEDIA, IAX_TRUNKTIMESTAMPS, IAX_USEJITTERBUF, iaxcompat, iaxmaxthreadcount, iaxthreadcount, io, jittertargetextra, lagrq_time, language, ast_variable::lineno, LOG_ERROR, LOG_NOTICE, LOG_WARNING, max_calltoken_delay, max_reg_expire, MAX_TRUNK_MTU, MAX_TRUNKDATA, maxauthreq, maxjitterbuffer, maxjitterinterps, min_reg_expire, mohinterpret, mohsuggest, ast_variable::name, netsock, network_change_stasis_subscribe(), network_change_stasis_unsubscribe(), ast_variable::next, NULL, outsock, PARSE_ADDR, PARSE_IN_RANGE, PARSE_UINT32, peer_unref(), ping_time, prefs_global, qos, reg_source_db(), regcontext, reload(), resyncthreshold, set_config_destroy(), socket_read(), srvlookup, timer, trunkfreq, trunkmaxsize, user, user_unref(), and ast_variable::value.

Referenced by load_module(), and reload_config().

set_config_destroy()

static void set_config_destroy ( void  )

static

Definition at line 13679 of file chan_iax2.c.

{
    strcpy(accountcode, "");
    strcpy(language, "");
    strcpy(mohinterpret, "");
    strcpy(mohsuggest, "");
    trunkmaxsize = MAX_TRUNKDATA;
    amaflags = 0;
    delayreject = 0;
    ast_clear_flag64((&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF |
        IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
    delete_users();
    ao2_callback(callno_limits, OBJ_NODATA, addr_range_delme_cb, NULL);
    ao2_callback(calltoken_ignores, OBJ_NODATA, addr_range_delme_cb, NULL);
}

References accountcode, addr_range_delme_cb(), amaflags, ao2_callback, ast_clear_flag64, callno_limits, calltoken_ignores, delayreject, delete_users(), globalflags, IAX_NOTRANSFER, IAX_RECVCONNECTEDLINE, IAX_SENDCONNECTEDLINE, IAX_TRANSFERMEDIA, IAX_USEJITTERBUF, language, MAX_TRUNKDATA, mohinterpret, mohsuggest, NULL, OBJ_NODATA, and trunkmaxsize.

Referenced by set_config().

set_hangup_source_and_cause()

static void set_hangup_source_and_cause ( int  callno, unsigned char  causecode  )

static

Definition at line 10244 of file chan_iax2.c.

{
    iax2_lock_owner(callno);
    if (iaxs[callno] && iaxs[callno]->owner) {
        struct ast_channel *owner;
        const char *name;
 
        owner = iaxs[callno]->owner;
        if (causecode) {
            ast_channel_hangupcause_set(owner, causecode);
        }
        name = ast_strdupa(ast_channel_name(owner));
        ast_channel_ref(owner);
        ast_channel_unlock(owner);
        ast_mutex_unlock(&iaxsl[callno]);
        ast_set_hangupsource(owner, name, 0);
        ast_channel_unref(owner);
        ast_mutex_lock(&iaxsl[callno]);
    }
}

References ast_channel_hangupcause_set(), ast_channel_name(), ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_mutex_lock, ast_mutex_unlock, ast_set_hangupsource(), ast_strdupa, iax2_lock_owner(), iaxs, iaxsl, name, and chan_iax2_pvt::owner.

Referenced by socket_process_helper().

set_peercnt_limit()

static void set_peercnt_limit ( struct peercnt *  peercnt )

static

Definition at line 2626 of file chan_iax2.c.

{
    uint16_t limit = global_maxcallno;
    struct addr_range *addr_range;
    struct ast_sockaddr addr;
 
    ast_sockaddr_copy(&addr, &peercnt->addr);
 
    if (peercnt->reg && peercnt->limit) {
        return; /* this peercnt has a custom limit set by a registration */
    }
 
    if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &addr))) {
        limit = addr_range->limit;
        ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_sockaddr_stringify(&addr));
        ao2_ref(addr_range, -1);
    }
 
    peercnt->limit = limit;
}

References peercnt::addr, addr_range_match_address_cb(), ao2_callback, ao2_ref, ast_debug, ast_sockaddr_copy(), ast_sockaddr_stringify(), callno_limits, global_maxcallno, peercnt::limit, addr_range::limit, and peercnt::reg.

Referenced by peercnt_add(), peercnt_modify(), and set_peercnt_limit_all_cb().

set_peercnt_limit_all_cb()

static int set_peercnt_limit_all_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2651 of file chan_iax2.c.

{
    struct peercnt *peercnt = obj;
 
    set_peercnt_limit(peercnt);
    ast_debug(1, "Reset limits for peercnts table\n");
 
    return 0;
}

References ast_debug, and set_peercnt_limit().

Referenced by reload_config().

signal_condition()

static void signal_condition ( ast_mutex_t *  lock, ast_cond_t *  cond  )

static

Definition at line 1183 of file chan_iax2.c.

{
    ast_mutex_lock(lock);
    ast_cond_signal(cond);
    ast_mutex_unlock(lock);
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, cond, and lock.

Referenced by __schedule_action(), cleanup_thread_list(), iax2_process_thread(), and socket_read().

socket_process()

static int socket_process ( struct iax2_thread *  thread )

static

Definition at line 12186 of file chan_iax2.c.

{
    int res = socket_process_helper(thread);
    if (ast_read_threadstorage_callid()) {
        ast_callid_threadassoc_remove();
    }
    return res;
}

References ast_callid_threadassoc_remove(), ast_read_threadstorage_callid(), socket_process_helper(), and thread.

Referenced by handle_deferred_full_frames(), and iax2_process_thread().

socket_process_helper()

static int socket_process_helper ( struct iax2_thread *  thread )

static

Definition at line 10265 of file chan_iax2.c.

{
    struct ast_sockaddr addr;
    int res;
    int updatehistory=1;
    int new = NEW_PREVENT;
    int dcallno = 0;
    char decrypted = 0;
    struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)thread->buf;
    struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)thread->buf;
    struct ast_iax2_meta_hdr *meta = (struct ast_iax2_meta_hdr *)thread->buf;
    struct ast_iax2_video_hdr *vh = (struct ast_iax2_video_hdr *)thread->buf;
    struct iax_frame *fr;
    struct iax_frame *cur;
    struct ast_frame f = { 0, };
    struct ast_channel *c = NULL;
    struct iax2_dpcache *dp;
    struct iax2_peer *peer;
    struct iax_ies ies;
    struct iax_ie_data ied0, ied1;
    iax2_format format;
    int fd;
    int exists;
    int minivid = 0;
    char empty[32]="";      /* Safety measure */
    struct iax_frame *duped_fr;
    char host_pref_buf[128];
    char caller_pref_buf[128];
    struct iax2_codec_pref pref;
    char *using_prefs = "mine";
 
    /* allocate an iax_frame with 4096 bytes of data buffer */
    fr = ast_alloca(sizeof(*fr) + 4096);
    memset(fr, 0, sizeof(*fr));
    fr->afdatalen = 4096; /* From ast_alloca() above */
 
    /* Copy frequently used parameters to the stack */
    res = thread->buf_len;
    fd = thread->iofd;
    ast_sockaddr_copy(&addr, &thread->ioaddr);
 
    if (res < sizeof(*mh)) {
        ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, (int) sizeof(*mh));
        return 1;
    }
    if ((vh->zeros == 0) && (ntohs(vh->callno) & 0x8000)) {
        if (res < sizeof(*vh)) {
            ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a video frame but is too short\n",
                    ast_sockaddr_stringify(&addr));
            return 1;
        }
 
        /* This is a video frame, get call number */
        fr->callno = find_callno(ntohs(vh->callno) & ~0x8000, dcallno, &addr, new, fd, 0);
        minivid = 1;
    } else if ((meta->zeros == 0) && !(ntohs(meta->metacmd) & 0x8000))
        return socket_process_meta(res, meta, &addr, fd, fr);
 
#ifdef DEBUG_SUPPORT
    if (res >= sizeof(*fh))
        iax_outputframe(NULL, fh, 1, &addr, res - sizeof(*fh));
#endif
    if (ntohs(mh->callno) & IAX_FLAG_FULL) {
        if (res < sizeof(*fh)) {
            ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a full frame but is too short\n",
                ast_sockaddr_stringify(&addr));
            return 1;
        }
 
        /* Get the destination call number */
        dcallno = ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS;
 
 
        /* check to make sure this full frame isn't encrypted before we attempt
         * to look inside of it. If it is encrypted, decrypt it first. Its ok if the
         * callno is not found here, that just means one hasn't been allocated for
         * this connection yet. */
        if ((dcallno != 1) && (fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, NEW_PREVENT, fd, 1))) {
            ast_mutex_lock(&iaxsl[fr->callno]);
            if (iaxs[fr->callno] && ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED)) {
                if (decrypt_frame(fr->callno, fh, &f, &res)) {
                    ast_log(LOG_NOTICE, "Packet Decrypt Failed!\n");
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    return 1;
                }
                decrypted = 1;
            }
            ast_mutex_unlock(&iaxsl[fr->callno]);
        }
 
        /* Retrieve the type and subclass */
        f.frametype = fh->type;
        if (f.frametype == AST_FRAME_VIDEO) {
            f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40));
            if (!f.subclass.format) {
                return 1;
            }
            if ((fh->csub >> 6) & 0x1) {
                f.subclass.frame_ending = 1;
            }
        } else if (f.frametype == AST_FRAME_VOICE) {
            f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
            if (!f.subclass.format) {
                return 1;
            }
        } else {
            f.subclass.integer = uncompress_subclass(fh->csub);
        }
 
        /* Deal with POKE/PONG without allocating a callno */
        if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_POKE) {
            /* Reply back with a PONG, but don't care about the result. */
            send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_PONG, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
            return 1;
        } else if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_ACK && dcallno == 1) {
            /* Ignore */
            return 1;
        }
 
        f.datalen = res - sizeof(*fh);
        if (f.datalen) {
            if (f.frametype == AST_FRAME_IAX) {
                if (iax_parse_ies(&ies, thread->buf + sizeof(struct ast_iax2_full_hdr), f.datalen)) {
                    char subclass[40];
                    iax_frame_subclass2str(f.subclass.integer, subclass, sizeof(subclass));
                    ast_log(LOG_WARNING, "Undecodable %s frame received from '%s'\n", subclass, ast_sockaddr_stringify(&addr));
                    ast_variables_destroy(ies.vars);
                    return 1;
                }
                f.data.ptr = NULL;
                f.datalen = 0;
            } else {
                f.data.ptr = thread->buf + sizeof(struct ast_iax2_full_hdr);
                memset(&ies, 0, sizeof(ies));
            }
        } else {
            if (f.frametype == AST_FRAME_IAX)
                f.data.ptr = NULL;
            else
                f.data.ptr = empty;
            memset(&ies, 0, sizeof(ies));
        }
 
        if (!dcallno && iax2_allow_new(f.frametype, f.subclass.integer, 1)) {
            /* only set NEW_ALLOW if calltoken checks out */
            if (handle_call_token(fh, &ies, &addr, fd)) {
                ast_variables_destroy(ies.vars);
                return 1;
            }
 
            if (ies.calltoken && ies.calltokendata) {
                /* if we've gotten this far, and the calltoken ie data exists,
                 * then calltoken validation _MUST_ have taken place.  If calltoken
                 * data is provided, it is always validated regardless of any
                 * calltokenoptional or requirecalltoken options */
                new = NEW_ALLOW_CALLTOKEN_VALIDATED;
            } else {
                new = NEW_ALLOW;
            }
        }
    } else {
        /* Don't know anything about it yet */
        f.frametype = AST_FRAME_NULL;
        f.subclass.integer = 0;
        memset(&ies, 0, sizeof(ies));
    }
 
    if (!fr->callno) {
        int check_dcallno = 0;
 
        /*
         * We enforce accurate destination call numbers for ACKs.  This forces the other
         * end to know the destination call number before call setup can complete.
         *
         * Discussed in the following thread:
         *    http://lists.digium.com/pipermail/asterisk-dev/2008-May/033217.html
         */
 
        if ((ntohs(mh->callno) & IAX_FLAG_FULL) && ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer == IAX_COMMAND_ACK))) {
            check_dcallno = 1;
        }
 
        if (!(fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, new, fd, check_dcallno))) {
            ast_debug(1, "Received frame without existent call number (%d)\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
            if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_NEW) {
                send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
            } else if (f.frametype == AST_FRAME_IAX && (f.subclass.integer == IAX_COMMAND_REGREQ || f.subclass.integer == IAX_COMMAND_REGREL)) {
                send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
            } else {
                ast_log(LOG_WARNING, "Silently dropping frame without existent call number: %d\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
            }
            ast_variables_destroy(ies.vars);
            return 1;
        }
    }
 
    if (fr->callno > 0) {
        ast_callid mount_callid;
        ast_mutex_lock(&iaxsl[fr->callno]);
        if (iaxs[fr->callno] && ((mount_callid = iax_pvt_callid_get(fr->callno)))) {
            /* Bind to thread */
            ast_callid_threadassoc_add(mount_callid);
        }
    }
 
    if (!fr->callno || !iaxs[fr->callno]) {
        /* A call arrived for a nonexistent destination.  Unless it's an "inval"
           frame, reply with an inval */
        if (ntohs(mh->callno) & IAX_FLAG_FULL) {
            /* We can only raw hangup control frames */
            if (((f.subclass.integer != IAX_COMMAND_INVAL) &&
                 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
                 (f.subclass.integer != IAX_COMMAND_TXACC) &&
                 (f.subclass.integer != IAX_COMMAND_FWDOWNL))||
                (f.frametype != AST_FRAME_IAX))
                raw_hangup(&addr, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, ntohs(mh->callno) & ~IAX_FLAG_FULL,
                fd);
        }
        if (fr->callno > 0){
            ast_mutex_unlock(&iaxsl[fr->callno]);
        }
        ast_variables_destroy(ies.vars);
        return 1;
    }
    if (ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED) && !decrypted) {
        if (decrypt_frame(fr->callno, fh, &f, &res)) {
            ast_log(LOG_WARNING, "Packet Decrypt Failed!\n");
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        decrypted = 1;
    }
 
#ifdef DEBUG_SUPPORT
    if (decrypted) {
        iax_outputframe(NULL, fh, 3, &addr, res - sizeof(*fh));
    }
#endif
 
    if (iaxs[fr->callno]->owner && fh->type == AST_FRAME_IAX &&
            (fh->csub == IAX_COMMAND_HANGUP
            || fh->csub == IAX_COMMAND_REJECT
            || fh->csub == IAX_COMMAND_REGREJ
            || fh->csub == IAX_COMMAND_TXREJ)) {
        struct ast_control_pvt_cause_code *cause_code;
        int data_size = sizeof(*cause_code);
        char subclass[40] = "";
 
        /* get subclass text */
        iax_frame_subclass2str(fh->csub, subclass, sizeof(subclass));
 
        /* add length of "IAX2 " */
        data_size += 5;
        /* for IAX hangup frames, add length of () and number */
        data_size += 3;
        if (ies.causecode > 9) {
            data_size++;
        }
        if (ies.causecode > 99) {
            data_size++;
        }
        /* add length of subclass */
        data_size += strlen(subclass);
 
        cause_code = ast_alloca(data_size);
        memset(cause_code, 0, data_size);
        ast_copy_string(cause_code->chan_name, ast_channel_name(iaxs[fr->callno]->owner), AST_CHANNEL_NAME);
 
        cause_code->ast_cause = ies.causecode;
        snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "IAX2 %s(%d)", subclass, ies.causecode);
 
        iax2_lock_owner(fr->callno);
        if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
            ast_queue_control_data(iaxs[fr->callno]->owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
            ast_channel_hangupcause_hash_set(iaxs[fr->callno]->owner, cause_code, data_size);
            ast_channel_unlock(iaxs[fr->callno]->owner);
        }
        if (!iaxs[fr->callno]) {
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
    }
 
    /* count this frame */
    iaxs[fr->callno]->frames_received++;
 
    if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) && !minivid &&
        f.subclass.integer != IAX_COMMAND_TXCNT &&      /* for attended transfer */
        f.subclass.integer != IAX_COMMAND_TXACC) {      /* for attended transfer */
        unsigned short new_peercallno;
 
        new_peercallno = (unsigned short) (ntohs(mh->callno) & ~IAX_FLAG_FULL);
        if (new_peercallno && new_peercallno != iaxs[fr->callno]->peercallno) {
            if (iaxs[fr->callno]->peercallno) {
                remove_by_peercallno(iaxs[fr->callno]);
            }
            iaxs[fr->callno]->peercallno = new_peercallno;
            store_by_peercallno(iaxs[fr->callno]);
        }
    }
    if (ntohs(mh->callno) & IAX_FLAG_FULL) {
        if (iaxdebug)
            ast_debug(1, "Received packet %d, (%u, %d)\n", fh->oseqno, f.frametype, f.subclass.integer);
        /* Check if it's out of order (and not an ACK or INVAL) */
        fr->oseqno = fh->oseqno;
        fr->iseqno = fh->iseqno;
        fr->ts = ntohl(fh->ts);
#ifdef IAXTESTS
        if (test_resync) {
            ast_debug(1, "Simulating frame ts resync, was %u now %u\n", fr->ts, fr->ts + test_resync);
            fr->ts += test_resync;
        }
#endif /* IAXTESTS */
#if 0
        if ( (ntohs(fh->dcallno) & IAX_FLAG_RETRANS) ||
             ( (f.frametype != AST_FRAME_VOICE) && ! (f.frametype == AST_FRAME_IAX &&
                                (f.subclass == IAX_COMMAND_NEW ||
                                 f.subclass == IAX_COMMAND_AUTHREQ ||
                                 f.subclass == IAX_COMMAND_ACCEPT ||
                                 f.subclass == IAX_COMMAND_REJECT))      ) )
#endif
        if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) || (f.frametype != AST_FRAME_VOICE))
            updatehistory = 0;
        if ((iaxs[fr->callno]->iseqno != fr->oseqno) &&
            (iaxs[fr->callno]->iseqno ||
                ((f.subclass.integer != IAX_COMMAND_TXCNT) &&
                (f.subclass.integer != IAX_COMMAND_TXREADY) &&      /* for attended transfer */
                (f.subclass.integer != IAX_COMMAND_TXREL) &&        /* for attended transfer */
                (f.subclass.integer != IAX_COMMAND_UNQUELCH ) &&    /* for attended transfer */
                (f.subclass.integer != IAX_COMMAND_TXACC)) ||
                (f.frametype != AST_FRAME_IAX))) {
            if (
             ((f.subclass.integer != IAX_COMMAND_ACK) &&
              (f.subclass.integer != IAX_COMMAND_INVAL) &&
              (f.subclass.integer != IAX_COMMAND_TXCNT) &&
              (f.subclass.integer != IAX_COMMAND_TXREADY) &&        /* for attended transfer */
              (f.subclass.integer != IAX_COMMAND_TXREL) &&      /* for attended transfer */
              (f.subclass.integer != IAX_COMMAND_UNQUELCH ) &&  /* for attended transfer */
              (f.subclass.integer != IAX_COMMAND_TXACC) &&
              (f.subclass.integer != IAX_COMMAND_VNAK)) ||
              (f.frametype != AST_FRAME_IAX)) {
                /* If it's not an ACK packet, it's out of order. */
                ast_debug(1, "Packet arrived out of order (expecting %d, got %d) (frametype = %u, subclass = %d)\n",
                    iaxs[fr->callno]->iseqno, fr->oseqno, f.frametype, f.subclass.integer);
                /* Check to see if we need to request retransmission,
                 * and take sequence number wraparound into account */
                if ((unsigned char) (iaxs[fr->callno]->iseqno - fr->oseqno) < 128) {
                    /* If we've already seen it, ack it XXX There's a border condition here XXX */
                    if ((f.frametype != AST_FRAME_IAX) ||
                            ((f.subclass.integer != IAX_COMMAND_ACK) && (f.subclass.integer != IAX_COMMAND_INVAL))) {
                        ast_debug(1, "Acking anyway\n");
                        /* XXX Maybe we should handle its ack to us, but then again, it's probably outdated anyway, and if
                           we have anything to send, we'll retransmit and get an ACK back anyway XXX */
                        send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                    }
                } else {
                    /* Send a VNAK requesting retransmission */
                    iax2_vnak(fr->callno);
                }
                ast_variables_destroy(ies.vars);
                ast_mutex_unlock(&iaxsl[fr->callno]);
                return 1;
            }
        } else {
            /* Increment unless it's an ACK or VNAK */
            if (((f.subclass.integer != IAX_COMMAND_ACK) &&
                (f.subclass.integer != IAX_COMMAND_INVAL) &&
                (f.subclass.integer != IAX_COMMAND_TXCNT) &&
                (f.subclass.integer != IAX_COMMAND_TXACC) &&
                (f.subclass.integer != IAX_COMMAND_VNAK)) ||
                (f.frametype != AST_FRAME_IAX))
                iaxs[fr->callno]->iseqno++;
        }
        /* Ensure text frames are NULL-terminated */
        if (f.frametype == AST_FRAME_TEXT && thread->buf[res - 1] != '\0') {
            if (res < thread->buf_size)
                thread->buf[res++] = '\0';
            else /* Trims one character from the text message, but that's better than overwriting the end of the buffer. */
                thread->buf[res - 1] = '\0';
        }
 
        /* Handle implicit ACKing unless this is an INVAL, and only if this is
           from the real peer, not the transfer peer */
        if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
            ((f.subclass.integer != IAX_COMMAND_INVAL) ||
             (f.frametype != AST_FRAME_IAX))) {
            unsigned char x;
            int call_to_destroy;
            /* First we have to qualify that the ACKed value is within our window */
            if (iaxs[fr->callno]->rseqno >= iaxs[fr->callno]->oseqno || (fr->iseqno >= iaxs[fr->callno]->rseqno && fr->iseqno < iaxs[fr->callno]->oseqno))
                x = fr->iseqno;
            else
                x = iaxs[fr->callno]->oseqno;
            if ((x != iaxs[fr->callno]->oseqno) || (iaxs[fr->callno]->oseqno == fr->iseqno)) {
                /* The acknowledgement is within our window.  Time to acknowledge everything
                   that it says to */
                for (x=iaxs[fr->callno]->rseqno; x != fr->iseqno; x++) {
                    /* Ack the packet with the given timestamp */
                    if (iaxdebug)
                        ast_debug(1, "Cancelling transmission of packet %d\n", x);
                    call_to_destroy = 0;
                    AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
                        /* If it's our call, and our timestamp, mark -1 retries */
                        if (x == cur->oseqno) {
                            cur->retries = -1;
                            /* Destroy call if this is the end */
                            if (cur->final)
                                call_to_destroy = fr->callno;
                        }
                    }
                    if (call_to_destroy) {
                        if (iaxdebug)
                            ast_debug(1, "Really destroying %d, having been acked on final message\n", call_to_destroy);
                        ast_mutex_lock(&iaxsl[call_to_destroy]);
                        iax2_destroy(call_to_destroy);
                        ast_mutex_unlock(&iaxsl[call_to_destroy]);
                    }
                }
                /* Note how much we've received acknowledgement for */
                if (iaxs[fr->callno])
                    iaxs[fr->callno]->rseqno = fr->iseqno;
                else {
                    /* Stop processing now */
                    ast_variables_destroy(ies.vars);
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    return 1;
                }
            } else {
                ast_debug(1, "Received iseqno %d not within window %d->%d\n", fr->iseqno, iaxs[fr->callno]->rseqno, iaxs[fr->callno]->oseqno);
            }
        }
        if (ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
            ((f.frametype != AST_FRAME_IAX) ||
             ((f.subclass.integer != IAX_COMMAND_TXACC) &&
              (f.subclass.integer != IAX_COMMAND_TXCNT)))) {
            /* Only messages we accept from a transfer host are TXACC and TXCNT */
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
 
        /* when we receive the first full frame for a new incoming channel,
           it is safe to start the PBX on the channel because we have now
           completed a 3-way handshake with the peer */
        if ((f.frametype == AST_FRAME_VOICE) ||
            (f.frametype == AST_FRAME_VIDEO) ||
            (f.frametype == AST_FRAME_IAX)) {
            if (ast_test_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART)) {
                ast_clear_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
                if (!ast_iax2_new(fr->callno, AST_STATE_RING,
                    iaxs[fr->callno]->chosenformat, &iaxs[fr->callno]->rprefs, NULL, NULL,
                    ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
                    ast_variables_destroy(ies.vars);
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    return 1;
                }
            }
 
            if (ies.vars) {
                struct ast_datastore *variablestore = NULL;
                struct ast_variable *var, *prev = NULL;
                AST_LIST_HEAD(, ast_var_t) *varlist;
 
                iax2_lock_owner(fr->callno);
                if (!iaxs[fr->callno]) {
                    ast_variables_destroy(ies.vars);
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    return 1;
                }
                if ((c = iaxs[fr->callno]->owner)) {
                    varlist = ast_calloc(1, sizeof(*varlist));
                    variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
 
                    if (variablestore && varlist) {
                        variablestore->data = varlist;
                        variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
                        AST_LIST_HEAD_INIT(varlist);
                        ast_debug(1, "I can haz IAX vars?\n");
                        for (var = ies.vars; var; var = var->next) {
                            struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
                            if (prev) {
                                ast_free(prev);
                            }
                            prev = var;
                            if (!newvar) {
                                /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
                                ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                            } else {
                                AST_LIST_INSERT_TAIL(varlist, newvar, entries);
                            }
                        }
                        if (prev) {
                            ast_free(prev);
                        }
                        ies.vars = NULL;
                        ast_channel_datastore_add(c, variablestore);
                    } else {
                        ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                        if (variablestore) {
                            ast_datastore_free(variablestore);
                        }
                        if (varlist) {
                            ast_free(varlist);
                        }
                    }
                    ast_channel_unlock(c);
                } else {
                    /* No channel yet, so transfer the variables directly over to the pvt,
                     * for later inheritance. */
                    ast_debug(1, "No channel, so populating IAXVARs to the pvt, as an intermediate step.\n");
                    for (var = ies.vars; var && var->next; var = var->next);
                    if (var) {
                        var->next = iaxs[fr->callno]->iaxvars;
                        iaxs[fr->callno]->iaxvars = ies.vars;
                        ies.vars = NULL;
                    }
                }
            }
 
            if (ies.vars) {
                ast_debug(1, "I have IAX variables, but they were not processed\n");
            }
        }
 
        /* once we receive our first IAX Full Frame that is not CallToken related, send all
         * queued signaling frames that were being held. */
        if ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer != IAX_COMMAND_CALLTOKEN) && iaxs[fr->callno]->hold_signaling) {
            send_signaling(iaxs[fr->callno]);
        }
 
        if (f.frametype == AST_FRAME_VOICE) {
            if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->voiceformat) {
                    iaxs[fr->callno]->voiceformat = ast_format_compatibility_format2bitfield(f.subclass.format);
                    ast_debug(1, "Ooh, voice format changed to '%s'\n", ast_format_get_name(f.subclass.format));
                    if (iaxs[fr->callno]->owner) {
                        iax2_lock_owner(fr->callno);
                        if (iaxs[fr->callno]) {
                            if (iaxs[fr->callno]->owner) {
                                struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
                                if (native) {
                                    ast_format_cap_append(native, f.subclass.format, 0);
                                    ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
                                    if (ast_channel_readformat(iaxs[fr->callno]->owner)) {
                                        ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
                                    }
                                    ao2_ref(native, -1);
                                }
                                ast_channel_unlock(iaxs[fr->callno]->owner);
                            }
                        } else {
                            ast_debug(1, "Neat, somebody took away the channel at a magical time but i found it!\n");
                            /* Free remote variables (if any) */
                            if (ies.vars) {
                                ast_variables_destroy(ies.vars);
                                ast_debug(1, "I can haz iaxvars, but they is no good.  :-(\n");
                                ies.vars = NULL;
                            }
                            ast_mutex_unlock(&iaxsl[fr->callno]);
                            return 1;
                        }
                    }
            }
        }
        if (f.frametype == AST_FRAME_VIDEO) {
            if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->videoformat) {
                ast_debug(1, "Ooh, video format changed to %s\n", ast_format_get_name(f.subclass.format));
                iaxs[fr->callno]->videoformat = ast_format_compatibility_format2bitfield(f.subclass.format);
            }
        }
        if (f.frametype == AST_FRAME_IAX) {
            AST_SCHED_DEL(sched, iaxs[fr->callno]->initid);
            /* Handle the IAX pseudo frame itself */
            if (iaxdebug)
                ast_debug(1, "IAX subclass %d received\n", f.subclass.integer);
 
                        /* Update last ts unless the frame's timestamp originated with us. */
            if (iaxs[fr->callno]->last < fr->ts &&
                            f.subclass.integer != IAX_COMMAND_ACK &&
                            f.subclass.integer != IAX_COMMAND_PONG &&
                            f.subclass.integer != IAX_COMMAND_LAGRP) {
                iaxs[fr->callno]->last = fr->ts;
                if (iaxdebug)
                    ast_debug(1, "For call=%d, set last=%u\n", fr->callno, fr->ts);
            }
            iaxs[fr->callno]->last_iax_message = f.subclass.integer;
            if (!iaxs[fr->callno]->first_iax_message) {
                iaxs[fr->callno]->first_iax_message = f.subclass.integer;
            }
            switch(f.subclass.integer) {
            case IAX_COMMAND_ACK:
                /* Do nothing */
                break;
            case IAX_COMMAND_QUELCH:
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
                    ast_set_flag64(iaxs[fr->callno], IAX_QUELCH);
                    if (ies.musiconhold) {
                        const char *moh_suggest;
 
                        iax2_lock_owner(fr->callno);
                        if (!iaxs[fr->callno] || !iaxs[fr->callno]->owner) {
                            break;
                        }
 
                        /*
                         * We already hold the owner lock so we do not
                         * need to check iaxs[fr->callno] after it returns.
                         */
                        moh_suggest = iaxs[fr->callno]->mohsuggest;
                        iax2_queue_hold(fr->callno, moh_suggest);
                        ast_channel_unlock(iaxs[fr->callno]->owner);
                    }
                }
                break;
            case IAX_COMMAND_UNQUELCH:
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
                    iax2_lock_owner(fr->callno);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
 
                    ast_clear_flag64(iaxs[fr->callno], IAX_QUELCH);
                    if (!iaxs[fr->callno]->owner) {
                        break;
                    }
 
                    /*
                     * We already hold the owner lock so we do not
                     * need to check iaxs[fr->callno] after it returns.
                     */
                    iax2_queue_unhold(fr->callno);
                    ast_channel_unlock(iaxs[fr->callno]->owner);
                }
                break;
            case IAX_COMMAND_TXACC:
                if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
                    /* Ack the packet with the given timestamp */
                    AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
                        /* Cancel any outstanding txcnt's */
                        if (cur->transfer) {
                            cur->retries = -1;
                        }
                    }
                    memset(&ied1, 0, sizeof(ied1));
                    iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
                    send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
                    iaxs[fr->callno]->transferring = TRANSFER_READY;
                }
                break;
            case IAX_COMMAND_NEW:
                /* Ignore if it's already up */
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD))
                    break;
                if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    check_provisioning(&addr, fd, ies.serviceident, ies.provver);
                    ast_mutex_lock(&iaxsl[fr->callno]);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                }
                /* If we're in trunk mode, do it now, and update the trunk number in our frame before continuing */
                if (ast_test_flag64(iaxs[fr->callno], IAX_TRUNK)) {
                    int new_callno;
                    if ((new_callno = make_trunk(fr->callno, 1)) != -1)
                        fr->callno = new_callno;
                }
                /* For security, always ack immediately */
                if (delayreject)
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                if (check_access(fr->callno, &addr, &ies)) {
                    /* They're not allowed on */
                    auth_fail(fr->callno, IAX_COMMAND_REJECT);
                    if (authdebug) {
                        ast_log(LOG_NOTICE, "Rejected connect attempt from %s, who was trying to reach '%s@%s'\n",
                                ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
                    }
                    break;
                }
                if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_test_flag64(iaxs[fr->callno], IAX_FORCE_ENCRYPT)) {
                    auth_fail(fr->callno, IAX_COMMAND_REJECT);
                    ast_log(LOG_WARNING, "Rejected connect attempt.  No secret present while force encrypt enabled.\n");
                    break;
                }
                if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
                    const char *context, *exten, *cid_num;
 
                    context = ast_strdupa(iaxs[fr->callno]->context);
                    exten = ast_strdupa(iaxs[fr->callno]->exten);
                    cid_num = ast_strdupa(iaxs[fr->callno]->cid_num);
 
                    /* This might re-enter the IAX code and need the lock */
                    ast_mutex_unlock(&iaxsl[fr->callno]);
                    exists = ast_exists_extension(NULL, context, exten, 1, cid_num);
                    ast_mutex_lock(&iaxsl[fr->callno]);
 
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                } else
                    exists = 0;
                /* Get OSP token if it does exist */
                save_osptoken(fr, &ies);
                if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) {
                    if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
                        memset(&ied0, 0, sizeof(ied0));
                        iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
                        iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
                        send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                        if (!iaxs[fr->callno]) {
                            break;
                        }
                        if (authdebug) {
                            ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
                                    ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
                        }
                    } else {
                        /* Select an appropriate format */
 
                        if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
                            if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                using_prefs = "reqonly";
                            } else {
                                using_prefs = "disabled";
                            }
                            format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
                            memset(&pref, 0, sizeof(pref));
                            strcpy(caller_pref_buf, "disabled");
                            strcpy(host_pref_buf, "disabled");
                        } else {
                            struct ast_format *tmpfmt;
                            using_prefs = "mine";
                            /* If the information elements are in here... use them */
                            if (ies.codec_prefs)
                                iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
                            if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
                                /* If we are codec_first_choice we let the caller have the 1st shot at picking the codec.*/
                                if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
                                    pref = iaxs[fr->callno]->rprefs;
                                    using_prefs = "caller";
                                } else {
                                    pref = iaxs[fr->callno]->prefs;
                                }
                            } else
                                pref = iaxs[fr->callno]->prefs;
 
                            format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
                            iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
                            iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
                        }
                        if (!format) {
                            if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP))
                                format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
                            if (!format) {
                                memset(&ied0, 0, sizeof(ied0));
                                iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
                                iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                                send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                                if (!iaxs[fr->callno]) {
                                    break;
                                }
                                if (authdebug) {
                                    struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                    struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                    struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                                    if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                        ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                    } else {
                                        ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                    }
                                }
                            } else {
                                /* Pick one... */
                                if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                    if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
                                        format = 0;
                                } else {
                                    if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
                                        using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
                                        memset(&pref, 0, sizeof(pref));
                                        format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                        strcpy(caller_pref_buf,"disabled");
                                        strcpy(host_pref_buf,"disabled");
                                    } else {
                                        struct ast_format *tmpfmt;
                                        using_prefs = "mine";
                                        if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
                                            /* Do the opposite of what we tried above. */
                                            if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
                                                pref = iaxs[fr->callno]->prefs;
                                            } else {
                                                pref = iaxs[fr->callno]->rprefs;
                                                using_prefs = "caller";
                                            }
                                            format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                        } else /* if no codec_prefs IE do it the old way */
                                            format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                    }
                                }
 
                                if (!format) {
                                    struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                    struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                    struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                                    memset(&ied0, 0, sizeof(ied0));
                                    iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
                                    iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                                    ast_log(LOG_ERROR, "No best format in '%s'???\n", iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
                                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                                    if (!iaxs[fr->callno]) {
                                        break;
                                    }
                                    if (authdebug) {
                                        ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                    }
                                    ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
                                    break;
                                }
                            }
                        }
                        if (format) {
                            /* No authentication required, let them in */
                            memset(&ied1, 0, sizeof(ied1));
                            iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
                            iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
                            send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
                            if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
                                ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                                ast_verb(3, "Accepting UNAUTHENTICATED call from %s:\n"
                                                "%srequested format = %s,\n"
                                                "%srequested prefs = %s,\n"
                                                "%sactual format = %s,\n"
                                                "%shost prefs = %s,\n"
                                                "%spriority = %s\n",
                                                ast_sockaddr_stringify(&addr),
                                                VERBOSE_PREFIX_4,
                                                iax2_getformatname(iaxs[fr->callno]->peerformat),
                                                VERBOSE_PREFIX_4,
                                                caller_pref_buf,
                                                VERBOSE_PREFIX_4,
                                                iax2_getformatname(format),
                                                VERBOSE_PREFIX_4,
                                                host_pref_buf,
                                                VERBOSE_PREFIX_4,
                                                using_prefs);
 
                                iaxs[fr->callno]->chosenformat = format;
 
                                /* Since this is a new call, we should go ahead and set the callid for it. */
                                iax_pvt_callid_new(fr->callno);
                                ast_set_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
                            } else {
                                ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
                                /* If this is a TBD call, we're ready but now what...  */
                                ast_verb(3, "Accepted unauthenticated TBD call from %s\n", ast_sockaddr_stringify(&addr));
                            }
                        }
                    }
                    break;
                }
                if (iaxs[fr->callno]->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA))
                    merge_encryption(iaxs[fr->callno], ies.encmethods);
                else
                    iaxs[fr->callno]->encmethods = 0;
                if (!authenticate_request(fr->callno) && iaxs[fr->callno])
                    ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED);
                break;
            case IAX_COMMAND_DPREQ:
                /* Request status in the dialplan */
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD) &&
                    !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED) && ies.called_number) {
                    if (iaxcompat) {
                        /* Spawn a thread for the lookup */
                        spawn_dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num);
                    } else {
                        /* Just look it up */
                        dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num, 1);
                    }
                }
                break;
            case IAX_COMMAND_HANGUP:
                ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
                ast_debug(1, "Immediately destroying %d, having received hangup\n", fr->callno);
                /* Set hangup cause according to remote and hangupsource */
                if (iaxs[fr->callno]->owner) {
                    set_hangup_source_and_cause(fr->callno, ies.causecode);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                }
 
                /* Send ack immediately, before we destroy */
                send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                iax2_destroy(fr->callno);
                break;
            case IAX_COMMAND_REJECT:
                /* Set hangup cause according to remote and hangup source */
                if (iaxs[fr->callno]->owner) {
                    set_hangup_source_and_cause(fr->callno, ies.causecode);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                }
 
                if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
                    if (iaxs[fr->callno]->owner && authdebug)
                        ast_log(LOG_WARNING, "Call rejected by %s: %s\n",
                            ast_sockaddr_stringify(&addr),
                            ies.cause ? ies.cause : "<Unknown>");
                    ast_debug(1, "Immediately destroying %d, having received reject\n",
                        fr->callno);
                }
                /* Send ack immediately, before we destroy */
                send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK,
                               fr->ts, NULL, 0, fr->iseqno);
                if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION))
                    iaxs[fr->callno]->error = EPERM;
                iax2_destroy(fr->callno);
                break;
            case IAX_COMMAND_TRANSFER:
            {
                iax2_lock_owner(fr->callno);
                if (!iaxs[fr->callno]) {
                    /* Initiating call went away before we could transfer. */
                    break;
                }
                if (iaxs[fr->callno]->owner) {
                    struct ast_channel *owner = iaxs[fr->callno]->owner;
                    char *context = ast_strdupa(iaxs[fr->callno]->context);
 
                    ast_channel_ref(owner);
                    ast_channel_unlock(owner);
                    ast_mutex_unlock(&iaxsl[fr->callno]);
 
                    if (ast_bridge_transfer_blind(1, owner, ies.called_number,
                                context, NULL, NULL) != AST_BRIDGE_TRANSFER_SUCCESS) {
                        ast_log(LOG_WARNING, "Blind transfer of '%s' to '%s@%s' failed\n",
                            ast_channel_name(owner), ies.called_number,
                            context);
                    }
 
                    ast_channel_unref(owner);
                    ast_mutex_lock(&iaxsl[fr->callno]);
                }
 
                break;
            }
            case IAX_COMMAND_ACCEPT:
                /* Ignore if call is already up or needs authentication or is a TBD */
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD | IAX_STATE_AUTHENTICATED))
                    break;
                if (ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
                    /* Send ack immediately, before we destroy */
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                    iax2_destroy(fr->callno);
                    break;
                }
                if (ies.format) {
                    iaxs[fr->callno]->peerformat = ies.format;
                } else {
                    if (iaxs[fr->callno]->owner)
                        iaxs[fr->callno]->peerformat = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(iaxs[fr->callno]->owner));
                    else
                        iaxs[fr->callno]->peerformat = iaxs[fr->callno]->capability;
                }
                ast_verb(3, "Call accepted by %s (format %s)\n", ast_sockaddr_stringify(&addr),
                        iax2_getformatname(iaxs[fr->callno]->peerformat));
                if (!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability)) {
                    memset(&ied0, 0, sizeof(ied0));
                    iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
                    iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                    if (authdebug) {
                        struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                        struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                        ast_log(LOG_NOTICE, "Rejected call to %s, format %s incompatible with our capability %s.\n",
                            ast_sockaddr_stringify(&addr),
                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_buf),
                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                    }
                } else {
                    struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
                    ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                    iax2_lock_owner(fr->callno);
                    if (iaxs[fr->callno] && iaxs[fr->callno]->owner && native) {
                        struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                        /* Switch us to use a compatible format */
                        iax2_codec_pref_best_bitfield2cap(
                            iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
                            native);
                        ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
                        ast_verb(3, "Format for call is %s\n", ast_format_cap_get_names(ast_channel_nativeformats(iaxs[fr->callno]->owner), &cap_buf));
 
                        /* Setup read/write formats properly. */
                        if (ast_channel_writeformat(iaxs[fr->callno]->owner))
                            ast_set_write_format(iaxs[fr->callno]->owner, ast_channel_writeformat(iaxs[fr->callno]->owner));
                        if (ast_channel_readformat(iaxs[fr->callno]->owner))
                            ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
                        ast_channel_unlock(iaxs[fr->callno]->owner);
                    }
 
                    ao2_cleanup(native);
                }
                if (iaxs[fr->callno]) {
                    AST_LIST_LOCK(&dpcache);
                    AST_LIST_TRAVERSE(&iaxs[fr->callno]->dpentries, dp, peer_list)
                        if (!(dp->flags & CACHE_FLAG_TRANSMITTED))
                            iax2_dprequest(dp, fr->callno);
                    AST_LIST_UNLOCK(&dpcache);
                }
                break;
            case IAX_COMMAND_POKE:
                /* Send back a pong packet with the original timestamp */
                send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, NULL, 0, -1);
                break;
            case IAX_COMMAND_PING:
            {
                struct iax_ie_data pingied;
                construct_rr(iaxs[fr->callno], &pingied);
                /* Send back a pong packet with the original timestamp */
                send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, pingied.buf, pingied.pos, -1);
            }
                break;
            case IAX_COMMAND_PONG:
                /* Calculate ping time */
                iaxs[fr->callno]->pingtime =  calc_timestamp(iaxs[fr->callno], 0, &f) - fr->ts;
                /* save RR info */
                save_rr(fr, &ies);
 
                /* Good time to write jb stats for this call */
                log_jitterstats(fr->callno);
 
                if (iaxs[fr->callno]->peerpoke) {
                    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
                    peer = iaxs[fr->callno]->peerpoke;
                    if ((peer->lastms < 0)  || (peer->historicms > peer->maxms)) {
                        if (iaxs[fr->callno]->pingtime <= peer->maxms) {
                            ast_log(LOG_NOTICE, "Peer '%s' is now REACHABLE! Time: %u\n", peer->name, iaxs[fr->callno]->pingtime);
                            ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
                            blob = ast_json_pack("{s: s, s: I}",
                                "peer_status", "Reachable",
                                "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
                            ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
                        }
                    } else if ((peer->historicms > 0) && (peer->historicms <= peer->maxms)) {
                        if (iaxs[fr->callno]->pingtime > peer->maxms) {
                            ast_log(LOG_NOTICE, "Peer '%s' is now TOO LAGGED (%u ms)!\n", peer->name, iaxs[fr->callno]->pingtime);
                            ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
                            blob = ast_json_pack("{s: s, s: I}",
                                "peer_status", "Lagged",
                                "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
                            ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
                        }
                    }
                    ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
                    peer->lastms = iaxs[fr->callno]->pingtime;
                    if (peer->smoothing && (peer->lastms > -1))
                        peer->historicms = (iaxs[fr->callno]->pingtime + peer->historicms) / 2;
                    else if (peer->smoothing && peer->lastms < 0)
                        peer->historicms = (0 + peer->historicms) / 2;
                    else
                        peer->historicms = iaxs[fr->callno]->pingtime;
 
                    /* Remove scheduled iax2_poke_noanswer */
                    if (peer->pokeexpire > -1) {
                        if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
                            peer_unref(peer);
                            peer->pokeexpire = -1;
                        }
                    }
                    /* Schedule the next cycle */
                    if ((peer->lastms < 0)  || (peer->historicms > peer->maxms))
                        peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
                    else
                        peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqok, iax2_poke_peer_s, peer_ref(peer));
                    if (peer->pokeexpire == -1)
                        peer_unref(peer);
                    /* and finally send the ack */
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                    /* And wrap up the qualify call */
                    iax2_destroy(fr->callno);
                    peer->callno = 0;
                    ast_debug(1, "Peer %s: got pong, lastms %d, historicms %d, maxms %d\n", peer->name, peer->lastms, peer->historicms, peer->maxms);
                }
                break;
            case IAX_COMMAND_LAGRQ:
            case IAX_COMMAND_LAGRP:
                f.src = "LAGRQ";
                f.mallocd = 0;
                f.offset = 0;
                f.samples = 0;
                iax_frame_wrap(fr, &f);
                if (f.subclass.integer == IAX_COMMAND_LAGRQ) {
                    /* Received a LAGRQ - echo back a LAGRP */
                    fr->af.subclass.integer = IAX_COMMAND_LAGRP;
                    iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
                } else {
                    /* Received LAGRP in response to our LAGRQ */
                    unsigned int ts;
                    /* This is a reply we've been given, actually measure the difference */
                    ts = calc_timestamp(iaxs[fr->callno], 0, &fr->af);
                    iaxs[fr->callno]->lag = ts - fr->ts;
                    if (iaxdebug)
                        ast_debug(1, "Peer %s lag measured as %dms\n",
                            ast_sockaddr_stringify(&addr), iaxs[fr->callno]->lag);
                }
                break;
            case IAX_COMMAND_AUTHREQ:
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
                    ast_log(LOG_WARNING, "Call on %s is already up, can't start on it\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
                    break;
                }
                if (authenticate_reply(iaxs[fr->callno], &iaxs[fr->callno]->addr, &ies, iaxs[fr->callno]->secret, iaxs[fr->callno]->outkey)) {
                    struct ast_frame hangup_fr = { .frametype = AST_FRAME_CONTROL,
                                .subclass.integer = AST_CONTROL_HANGUP,
                    };
                    ast_log(LOG_WARNING,
                        "I don't know how to authenticate %s to %s\n",
                        ies.username ? ies.username : "<unknown>", ast_sockaddr_stringify(&addr));
                    iax2_queue_frame(fr->callno, &hangup_fr);
                }
                break;
            case IAX_COMMAND_AUTHREP:
                /* For security, always ack immediately */
                if (delayreject)
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                /* Ignore once we've started */
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
                    ast_log(LOG_WARNING, "Call on %s is already up, can't start on it\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
                    break;
                }
                if (authenticate_verify(iaxs[fr->callno], &ies)) {
                    if (authdebug)
                        ast_log(LOG_WARNING, "Host %s failed to authenticate as %s\n", ast_sockaddr_stringify(&addr),
                                iaxs[fr->callno]->username);
                    memset(&ied0, 0, sizeof(ied0));
                    auth_fail(fr->callno, IAX_COMMAND_REJECT);
                    break;
                }
                if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
                    /* This might re-enter the IAX code and need the lock */
                    exists = ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num);
                } else
                    exists = 0;
                if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
                    if (authdebug)
                        ast_log(LOG_WARNING, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
                                ast_sockaddr_stringify(&addr),
                                iaxs[fr->callno]->exten,
                                iaxs[fr->callno]->context);
                    memset(&ied0, 0, sizeof(ied0));
                    iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
                    iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                } else {
                    /* Select an appropriate format */
                    if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
                        if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                            using_prefs = "reqonly";
                        } else {
                            using_prefs = "disabled";
                        }
                        format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
                        memset(&pref, 0, sizeof(pref));
                        strcpy(caller_pref_buf, "disabled");
                        strcpy(host_pref_buf, "disabled");
                    } else {
                        struct ast_format *tmpfmt;
                        using_prefs = "mine";
                        if (ies.codec_prefs)
                            iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
                        if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
                            if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
                                pref = iaxs[fr->callno]->rprefs;
                                using_prefs = "caller";
                            } else {
                                pref = iaxs[fr->callno]->prefs;
                            }
                        } else /* if no codec_prefs IE do it the old way */
                            pref = iaxs[fr->callno]->prefs;
                        format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
                        iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
                        iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
                    }
                    if (!format) {
                        struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                        struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                        struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                        if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                            ast_debug(1, "We don't do requested format %s, falling back to peer capability '%s'\n",
                                iax2_getformatname(iaxs[fr->callno]->peerformat),
                                iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf));
                            format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
                        }
                        if (!format) {
                            if (authdebug) {
                                if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                    ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                        iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                        iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                } else {
                                    ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
                                        ast_sockaddr_stringify(&addr),
                                        iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                        iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
                                        iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                }
                            }
                            memset(&ied0, 0, sizeof(ied0));
                            iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
                            iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                            send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                            if (!iaxs[fr->callno]) {
                                break;
                            }
                        } else {
                            /* Pick one... */
                            if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
                                    format = 0;
                            } else {
                                if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
                                    using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
                                    memset(&pref, 0, sizeof(pref));
                                    format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)
                                        ? iaxs[fr->callno]->peerformat
                                        : iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                    strcpy(caller_pref_buf,"disabled");
                                    strcpy(host_pref_buf,"disabled");
                                } else {
                                    struct ast_format *tmpfmt;
                                    using_prefs = "mine";
                                    if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
                                        /* Do the opposite of what we tried above. */
                                        if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
                                            pref = iaxs[fr->callno]->prefs;
                                        } else {
                                            pref = iaxs[fr->callno]->rprefs;
                                            using_prefs = "caller";
                                        }
                                        format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                    } else /* if no codec_prefs IE do it the old way */
                                        format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
                                }
                            }
                            if (!format) {
                                struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                                struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                                ast_log(LOG_ERROR, "No best format in %s???\n",
                                    iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
                                if (authdebug) {
                                    if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
                                        ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                    } else {
                                        ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
                                            ast_sockaddr_stringify(&addr),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
                                            iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
                                    }
                                }
                                memset(&ied0, 0, sizeof(ied0));
                                iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
                                iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
                                send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                                if (!iaxs[fr->callno]) {
                                    break;
                                }
                            }
                        }
                    }
                    if (format) {
                        /* Authentication received */
                        memset(&ied1, 0, sizeof(ied1));
                        iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
                        iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
                        send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
                        if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
                            char authmethodnames[AUTH_METHOD_NAMES_BUFSIZE];
                            ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                            ast_verb(3, "Accepting AUTHENTICATED call from %s:\n"
                                            "%srequested auth methods = (%s),\n"
                                            "%sactual auth method = %s,\n"
                                            "%sencrypted = %s,\n"
                                            "%srequested format = %s,\n"
                                            "%srequested prefs = %s,\n"
                                            "%sactual format = %s,\n"
                                            "%shost prefs = %s,\n"
                                            "%spriority = %s\n",
                                            ast_sockaddr_stringify(&addr),
                                            VERBOSE_PREFIX_4,
                                            auth_method_names(iaxs[fr->callno]->authmethods, authmethodnames),
                                            VERBOSE_PREFIX_4,
                                            auth_method_labels[iaxs[fr->callno]->eff_auth_method],
                                            VERBOSE_PREFIX_4,
                                            IAX_CALLENCRYPTED(iaxs[fr->callno]) ? "yes" : "no",
                                            VERBOSE_PREFIX_4,
                                            iax2_getformatname(iaxs[fr->callno]->peerformat),
                                            VERBOSE_PREFIX_4,
                                            caller_pref_buf,
                                            VERBOSE_PREFIX_4,
                                            iax2_getformatname(format),
                                            VERBOSE_PREFIX_4,
                                            host_pref_buf,
                                            VERBOSE_PREFIX_4,
                                            using_prefs);
 
                            /* Unlike unauthenticated calls, we don't need to store
                             * the chosen format for channel creation.
                             * However, this is helpful for __get_from_jb. */
                            iaxs[fr->callno]->chosenformat = format;
 
                            ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                            c = ast_iax2_new(fr->callno, AST_STATE_RING, format,
                                &iaxs[fr->callno]->rprefs, NULL, NULL, 1);
                            if (!c) {
                                iax2_destroy(fr->callno);
                            } else if (ies.vars) {
                                struct ast_datastore *variablestore;
                                struct ast_variable *var, *prev = NULL;
                                AST_LIST_HEAD(, ast_var_t) *varlist;
                                varlist = ast_calloc(1, sizeof(*varlist));
                                variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
                                if (variablestore && varlist) {
                                    variablestore->data = varlist;
                                    variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
                                    AST_LIST_HEAD_INIT(varlist);
                                    ast_debug(1, "I can haz IAX vars? w00t\n");
                                    for (var = ies.vars; var; var = var->next) {
                                        struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
                                        if (prev)
                                            ast_free(prev);
                                        prev = var;
                                        if (!newvar) {
                                            /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
                                            ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                                        } else {
                                            AST_LIST_INSERT_TAIL(varlist, newvar, entries);
                                        }
                                    }
                                    if (prev)
                                        ast_free(prev);
                                    ies.vars = NULL;
                                    ast_channel_datastore_add(c, variablestore);
                                } else {
                                    ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                                    if (variablestore)
                                        ast_datastore_free(variablestore);
                                    if (varlist)
                                        ast_free(varlist);
                                }
                            }
                        } else {
                            ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
                            /* If this is a TBD call, we're ready but now what...  */
                            ast_verb(3, "Accepted AUTHENTICATED TBD call from %s\n", ast_sockaddr_stringify(&addr));
                            if (ast_test_flag64(iaxs[fr->callno], IAX_IMMEDIATE)) {
                                goto immediatedial;
                            }
                        }
                    }
                }
                break;
            case IAX_COMMAND_DIAL:
immediatedial:
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD)) {
                    ast_clear_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
                    ast_string_field_set(iaxs[fr->callno], exten, ies.called_number ? ies.called_number : "s");
                    if (!ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num)) {
                        if (authdebug)
                            ast_log(LOG_WARNING, "Rejected dial attempt from %s, request '%s@%s' does not exist\n",
                                    ast_sockaddr_stringify(&addr),
                                    iaxs[fr->callno]->exten,
                                    iaxs[fr->callno]->context);
                        memset(&ied0, 0, sizeof(ied0));
                        iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
                        iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
                        send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                        if (!iaxs[fr->callno]) {
                            break;
                        }
                    } else {
                        struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
                        ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                        ast_verb(3, "Accepting DIAL from %s, formats = %s\n",
                                ast_sockaddr_stringify(&addr),
                                iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &cap_buf));
                        ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
                        send_command(iaxs[fr->callno], AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, 0, NULL, 0, -1);
                        c = ast_iax2_new(fr->callno, AST_STATE_RING,
                            iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
                            NULL, NULL, 1);
                        if (!c) {
                            iax2_destroy(fr->callno);
                        } else if (ies.vars) {
                            struct ast_datastore *variablestore;
                            struct ast_variable *var, *prev = NULL;
                            AST_LIST_HEAD(, ast_var_t) *varlist;
                            varlist = ast_calloc(1, sizeof(*varlist));
                            variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
                            ast_debug(1, "I can haz IAX vars? w00t\n");
                            if (variablestore && varlist) {
                                variablestore->data = varlist;
                                variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
                                AST_LIST_HEAD_INIT(varlist);
                                for (var = ies.vars; var; var = var->next) {
                                    struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
                                    if (prev)
                                        ast_free(prev);
                                    prev = var;
                                    if (!newvar) {
                                        /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
                                        ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                                    } else {
                                        AST_LIST_INSERT_TAIL(varlist, newvar, entries);
                                    }
                                }
                                if (prev)
                                    ast_free(prev);
                                ies.vars = NULL;
                                ast_channel_datastore_add(c, variablestore);
                            } else {
                                ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
                                if (variablestore)
                                    ast_datastore_free(variablestore);
                                if (varlist)
                                    ast_free(varlist);
                            }
                        }
                    }
                }
                break;
            case IAX_COMMAND_INVAL:
                iaxs[fr->callno]->error = ENOTCONN;
                ast_debug(1, "Immediately destroying %d, having received INVAL\n", fr->callno);
                iax2_destroy(fr->callno);
                ast_debug(1, "Destroying call %d\n", fr->callno);
                break;
            case IAX_COMMAND_VNAK:
                ast_debug(1, "Received VNAK: resending outstanding frames\n");
                /* Force retransmission */
                vnak_retransmit(fr->callno, fr->iseqno);
                break;
            case IAX_COMMAND_REGREQ:
            case IAX_COMMAND_REGREL:
                /* For security, always ack immediately */
                if (delayreject)
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                if (register_verify(fr->callno, &addr, &ies)) {
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                    /* Send delayed failure */
                    auth_fail(fr->callno, IAX_COMMAND_REGREJ);
                    break;
                }
                if (!iaxs[fr->callno]) {
                    break;
                }
                if ((ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) ||
                        ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED)) {
 
                    if (f.subclass.integer == IAX_COMMAND_REGREL) {
                        ast_sockaddr_setnull(&addr);
                    }
                    if (update_registry(&addr, fr->callno, ies.devicetype, fd, ies.refresh)) {
                        ast_log(LOG_WARNING, "Registry error\n");
                    }
                    if (!iaxs[fr->callno]) {
                        break;
                    }
                    if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
                        ast_mutex_unlock(&iaxsl[fr->callno]);
                        check_provisioning(&addr, fd, ies.serviceident, ies.provver);
                        ast_mutex_lock(&iaxsl[fr->callno]);
                    }
                    break;
                }
                registry_authrequest(fr->callno);
                break;
            case IAX_COMMAND_REGACK:
                if (iax2_ack_registry(&ies, &addr, fr->callno)) {
                    ast_log(LOG_WARNING, "Registration failure\n");
                }
                /* Send ack immediately, before we destroy */
                send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                iax2_destroy(fr->callno);
                break;
            case IAX_COMMAND_REGREJ:
                if (iaxs[fr->callno]->reg) {
                    if (authdebug) {
                        ast_log(LOG_NOTICE, "Registration of '%s' rejected: '%s' from: '%s'\n",
                                iaxs[fr->callno]->reg->username, ies.cause ? ies.cause : "<unknown>",
                                ast_sockaddr_stringify(&addr));
                    }
                    iax2_publish_registry(iaxs[fr->callno]->reg->username, ast_sockaddr_stringify(&addr), "Rejected", S_OR(ies.cause, "<unknown>"));
                    iaxs[fr->callno]->reg->regstate = REG_STATE_REJECTED;
                }
                /* Send ack immediately, before we destroy */
                send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                iax2_destroy(fr->callno);
                break;
            case IAX_COMMAND_REGAUTH:
                /* Authentication request */
                if (registry_rerequest(&ies, fr->callno, &addr)) {
                    memset(&ied0, 0, sizeof(ied0));
                    iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No authority found");
                    iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                }
                break;
            case IAX_COMMAND_TXREJ:
                while (iaxs[fr->callno]
                    && iaxs[fr->callno]->bridgecallno
                    && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
                    DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
                }
                if (!iaxs[fr->callno]) {
                    break;
                }
 
                iaxs[fr->callno]->transferring = TRANSFER_NONE;
                ast_verb(3, "Channel '%s' unable to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
                memset(&iaxs[fr->callno]->transfer, 0, sizeof(iaxs[fr->callno]->transfer));
 
                if (!iaxs[fr->callno]->bridgecallno) {
                    break;
                }
 
                if (iaxs[iaxs[fr->callno]->bridgecallno]
                    && iaxs[iaxs[fr->callno]->bridgecallno]->transferring) {
                    iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_NONE;
                    send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
                }
                ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
                break;
            case IAX_COMMAND_TXREADY:
                while (iaxs[fr->callno]
                    && iaxs[fr->callno]->bridgecallno
                    && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
                    DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
                }
                if (!iaxs[fr->callno]) {
                    break;
                }
 
                if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
                    iaxs[fr->callno]->transferring = TRANSFER_READY;
                } else if (iaxs[fr->callno]->transferring == TRANSFER_MBEGIN) {
                    iaxs[fr->callno]->transferring = TRANSFER_MREADY;
                } else {
                    if (iaxs[fr->callno]->bridgecallno) {
                        ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
                    }
                    break;
                }
                ast_verb(3, "Channel '%s' ready to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
 
                if (!iaxs[fr->callno]->bridgecallno) {
                    break;
                }
 
                if (!iaxs[iaxs[fr->callno]->bridgecallno]
                    || (iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_READY
                        && iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_MREADY)) {
                    ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
                    break;
                }
 
                /* Both sides are ready */
 
                /* XXX what isn't checked here is that both sides match transfer types. */
 
                if (iaxs[fr->callno]->transferring == TRANSFER_MREADY) {
                    ast_verb(3, "Attempting media bridge of %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
                            iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
 
                    iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_MEDIA;
                    iaxs[fr->callno]->transferring = TRANSFER_MEDIA;
 
                    memset(&ied0, 0, sizeof(ied0));
                    memset(&ied1, 0, sizeof(ied1));
                    iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
                    iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
                    send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied0.buf, ied0.pos, -1);
                    send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied1.buf, ied1.pos, -1);
                } else {
                    ast_verb(3, "Releasing %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
                            iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
 
                    iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_RELEASED;
                    iaxs[fr->callno]->transferring = TRANSFER_RELEASED;
                    ast_set_flag64(iaxs[iaxs[fr->callno]->bridgecallno], IAX_ALREADYGONE);
                    ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
 
                    /* Stop doing lag & ping requests */
                    stop_stuff(fr->callno);
                    stop_stuff(iaxs[fr->callno]->bridgecallno);
 
                    memset(&ied0, 0, sizeof(ied0));
                    memset(&ied1, 0, sizeof(ied1));
                    iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
                    iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
                    send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied0.buf, ied0.pos, -1);
                    send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied1.buf, ied1.pos, -1);
                }
                ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
                break;
            case IAX_COMMAND_TXREQ:
                try_transfer(iaxs[fr->callno], &ies);
                break;
            case IAX_COMMAND_TXCNT:
                if (iaxs[fr->callno]->transferring)
                    send_command_transfer(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, NULL, 0);
                break;
            case IAX_COMMAND_TXREL:
                /* Send ack immediately, rather than waiting until we've changed addresses */
                send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                complete_transfer(fr->callno, &ies);
                stop_stuff(fr->callno); /* for attended transfer to work with libiax */
                break;
            case IAX_COMMAND_TXMEDIA:
                if (iaxs[fr->callno]->transferring == TRANSFER_READY) {
                    AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
                        /* Cancel any outstanding frames and start anew */
                        if (cur->transfer) {
                            cur->retries = -1;
                        }
                    }
                    /* Start sending our media to the transfer address, but otherwise leave the call as-is */
                    iaxs[fr->callno]->transferring = TRANSFER_MEDIAPASS;
                }
                break;
            case IAX_COMMAND_RTKEY:
                if (!IAX_CALLENCRYPTED(iaxs[fr->callno])) {
                    ast_log(LOG_WARNING,
                        "we've been told to rotate our encryption key, "
                        "but this isn't an encrypted call. bad things will happen.\n"
                    );
                    break;
                }
 
                IAX_DEBUGDIGEST("Receiving", ies.challenge);
 
                ast_aes_set_decrypt_key((unsigned char *) ies.challenge, &iaxs[fr->callno]->dcx);
                break;
            case IAX_COMMAND_DPREP:
                complete_dpreply(iaxs[fr->callno], &ies);
                break;
            case IAX_COMMAND_UNSUPPORT:
                ast_log(LOG_NOTICE, "Peer did not understand our iax command '%d'\n", ies.iax_unknown);
                break;
            case IAX_COMMAND_FWDOWNL:
                /* Firmware download */
                if (!ast_test_flag64(&globalflags, IAX_ALLOWFWDOWNLOAD)) {
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, NULL, 0, -1);
                    break;
                }
                memset(&ied0, 0, sizeof(ied0));
                res = iax_firmware_append(&ied0, ies.devicetype, ies.fwdesc);
                if (res < 0)
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
                else if (res > 0)
                    send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
                else
                    send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
                break;
            case IAX_COMMAND_CALLTOKEN:
            {
                struct iax_frame *cur;
                /* find last sent frame */
                if ((cur = AST_LIST_LAST(&frame_queue[fr->callno])) && ies.calltoken && ies.calltokendata) {
                    resend_with_token(fr->callno, cur, (char *) ies.calltokendata);
                }
                break;
            }
            default:
                ast_debug(1, "Unknown IAX command %d on %d/%d\n", f.subclass.integer, fr->callno, iaxs[fr->callno]->peercallno);
                memset(&ied0, 0, sizeof(ied0));
                iax_ie_append_byte(&ied0, IAX_IE_IAX_UNKNOWN, f.subclass.integer);
                send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, ied0.buf, ied0.pos, -1);
            }
            /* Free remote variables (if any) */
            if (ies.vars) {
                ast_variables_destroy(ies.vars);
                ast_debug(1, "I can haz IAX vars, but they is no good :-(\n");
                ies.vars = NULL;
            }
 
            /* Don't actually pass these frames along */
            if ((f.subclass.integer != IAX_COMMAND_ACK) &&
                (f.subclass.integer != IAX_COMMAND_TXCNT) &&
                (f.subclass.integer != IAX_COMMAND_TXACC) &&
                (f.subclass.integer != IAX_COMMAND_INVAL) &&
                (f.subclass.integer != IAX_COMMAND_VNAK)) {
                if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno) {
                    send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
                }
            }
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        /* Unless this is an ACK or INVAL frame, ack it */
        if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno)
            send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
    } else if (minivid) {
        f.frametype = AST_FRAME_VIDEO;
        if (iaxs[fr->callno]->videoformat > 0) {
            if (ntohs(vh->ts) & 0x8000LL) {
                f.subclass.frame_ending = 1;
            }
            f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->videoformat);
            if (!f.subclass.format) {
                ast_variables_destroy(ies.vars);
                ast_mutex_unlock(&iaxsl[fr->callno]);
                return 1;
            }
        } else {
            ast_log(LOG_WARNING, "Received mini frame before first full video frame\n");
            iax2_vnak(fr->callno);
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        f.datalen = res - sizeof(*vh);
        if (f.datalen)
            f.data.ptr = thread->buf + sizeof(*vh);
        else
            f.data.ptr = NULL;
#ifdef IAXTESTS
        if (test_resync) {
            fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
        } else
#endif /* IAXTESTS */
            fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | (ntohs(vh->ts) & 0x7fff);
    } else {
        /* A mini frame */
        f.frametype = AST_FRAME_VOICE;
        if (iaxs[fr->callno]->voiceformat > 0) {
            f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->voiceformat);
            if (!f.subclass.format) {
                ast_variables_destroy(ies.vars);
                ast_mutex_unlock(&iaxsl[fr->callno]);
                return 1;
            }
        } else {
            ast_debug(1, "Received mini frame before first full voice frame\n");
            iax2_vnak(fr->callno);
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        f.datalen = res - sizeof(struct ast_iax2_mini_hdr);
        if (f.datalen < 0) {
            ast_log(LOG_WARNING, "Datalen < 0?\n");
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        if (f.datalen)
            f.data.ptr = thread->buf + sizeof(*mh);
        else
            f.data.ptr = NULL;
#ifdef IAXTESTS
        if (test_resync) {
            fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
        } else
#endif /* IAXTESTS */
        fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
        /* FIXME? Surely right here would be the right place to undo timestamp wraparound? */
    }
 
    /* Don't pass any packets until we're started */
    if (!iaxs[fr->callno]
        || !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
        ast_variables_destroy(ies.vars);
        ast_mutex_unlock(&iaxsl[fr->callno]);
        return 1;
    }
 
    if (f.frametype == AST_FRAME_CONTROL) {
        if (!iax2_is_control_frame_allowed(f.subclass.integer)) {
            /* Control frame not allowed to come from the wire. */
            ast_debug(2, "Callno %d: Blocked receiving control frame %d.\n",
                fr->callno, f.subclass.integer);
            ast_variables_destroy(ies.vars);
            ast_mutex_unlock(&iaxsl[fr->callno]);
            return 1;
        }
        if (f.subclass.integer == AST_CONTROL_CONNECTED_LINE
            || f.subclass.integer == AST_CONTROL_REDIRECTING) {
            if (iaxs[fr->callno]
                && !ast_test_flag64(iaxs[fr->callno], IAX_RECVCONNECTEDLINE)) {
                /* We are not configured to allow receiving these updates. */
                ast_debug(2, "Callno %d: Config blocked receiving control frame %d.\n",
                    fr->callno, f.subclass.integer);
                ast_variables_destroy(ies.vars);
                ast_mutex_unlock(&iaxsl[fr->callno]);
                return 1;
            }
        }
 
        iax2_lock_owner(fr->callno);
        if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
            if (f.subclass.integer == AST_CONTROL_BUSY) {
                ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_BUSY);
            } else if (f.subclass.integer == AST_CONTROL_CONGESTION) {
                ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_CONGESTION);
            }
            ast_channel_unlock(iaxs[fr->callno]->owner);
        }
    }
 
    if (f.frametype == AST_FRAME_CONTROL
        && f.subclass.integer == AST_CONTROL_CONNECTED_LINE
        && iaxs[fr->callno]) {
        struct ast_party_connected_line connected;
 
        /*
         * Process a received connected line update.
         *
         * Initialize defaults.
         */
        ast_party_connected_line_init(&connected);
        connected.id.number.presentation = iaxs[fr->callno]->calling_pres;
        connected.id.name.presentation = iaxs[fr->callno]->calling_pres;
 
        if (!ast_connected_line_parse_data(f.data.ptr, f.datalen, &connected)) {
            ast_string_field_set(iaxs[fr->callno], cid_num, connected.id.number.str);
            ast_string_field_set(iaxs[fr->callno], cid_name, connected.id.name.str);
            iaxs[fr->callno]->calling_pres = ast_party_id_presentation(&connected.id);
 
            iax2_lock_owner(fr->callno);
            if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
                ast_set_callerid(iaxs[fr->callno]->owner,
                    S_COR(connected.id.number.valid, connected.id.number.str, ""),
                    S_COR(connected.id.name.valid, connected.id.name.str, ""),
                    NULL);
                ast_channel_caller(iaxs[fr->callno]->owner)->id.number.presentation = connected.id.number.presentation;
                ast_channel_caller(iaxs[fr->callno]->owner)->id.name.presentation = connected.id.name.presentation;
                ast_channel_unlock(iaxs[fr->callno]->owner);
            }
        }
        ast_party_connected_line_free(&connected);
    }
 
    /* Common things */
    f.src = "IAX2";
    f.mallocd = 0;
    f.offset = 0;
    f.len = 0;
    if (f.datalen && (f.frametype == AST_FRAME_VOICE)) {
        f.samples = ast_codec_samples_count(&f);
        /* We need to byteswap incoming slinear samples from network byte order */
        if (ast_format_cmp(f.subclass.format, ast_format_slin) == AST_FORMAT_CMP_EQUAL)
            ast_frame_byteswap_be(&f);
    } else
        f.samples = 0;
    iax_frame_wrap(fr, &f);
 
    /* If this is our most recent packet, use it as our basis for timestamping */
    if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
        /*iaxs[fr->callno]->last = fr->ts; (do it afterwards cos schedule/forward_delivery needs the last ts too)*/
        fr->outoforder = 0;
    } else {
        if (iaxdebug && iaxs[fr->callno]) {
            ast_debug(1, "Received out of order packet... (type=%u, subclass %d, ts = %u, last = %u)\n", f.frametype, f.subclass.integer, fr->ts, iaxs[fr->callno]->last);
        }
        fr->outoforder = 1;
    }
    fr->cacheable = ((f.frametype == AST_FRAME_VOICE) || (f.frametype == AST_FRAME_VIDEO));
    if (iaxs[fr->callno]) {
        duped_fr = iaxfrdup2(fr);
        if (duped_fr) {
            schedule_delivery(duped_fr, updatehistory, 0, &fr->ts);
        }
    }
    if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
        iaxs[fr->callno]->last = fr->ts;
#if 1
        if (iaxdebug)
            ast_debug(8, "For call=%d, set last=%u\n", fr->callno, fr->ts);
#endif
    }
 
    /* Always run again */
    ast_variables_destroy(ies.vars);
    ast_mutex_unlock(&iaxsl[fr->callno]);
    return 1;
}

References chan_iax2_pvt::addr, iax_frame::af, iax_frame::afdatalen, ao2_cleanup, ao2_ref, chan_iax2_pvt::aseqno, ast_aes_set_decrypt_key(), ast_alloca, ast_bridge_transfer_blind(), AST_BRIDGE_TRANSFER_SUCCESS, ast_callid_threadassoc_add(), ast_calloc, ast_control_pvt_cause_code::ast_cause, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_FACILITY_NOT_SUBSCRIBED, AST_CAUSE_NO_ROUTE_DESTINATION, ast_channel_caller(), ast_channel_datastore_add(), ast_channel_hangupcause_hash_set(), ast_channel_hangupcause_set(), AST_CHANNEL_NAME, ast_channel_name(), ast_channel_nativeformats(), ast_channel_nativeformats_set(), ast_channel_readformat(), ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_channel_writeformat(), ast_clear_flag, ast_clear_flag64, ast_codec_samples_count(), ast_connected_line_parse_data(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HANGUP, AST_CONTROL_PROGRESS, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, ast_copy_string(), ast_datastore_alloc, ast_datastore_free(), ast_debug, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_endpoint_blob_publish(), AST_ENDPOINT_ONLINE, ast_endpoint_set_state(), ast_endpoint_state_type(), ast_exists_extension(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_compatibility_bitfield2format(), ast_format_compatibility_format2bitfield(), ast_format_get_name(), ast_format_slin, ast_frame_byteswap_be, AST_FRAME_CONTROL, AST_FRAME_IAX, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_free, ast_iax2_new(), ast_json_pack(), ast_json_unref(), AST_LIST_HEAD, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, AST_LIST_LAST, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_trylock, ast_mutex_unlock, ast_party_connected_line_free(), ast_party_connected_line_init(), ast_party_id_presentation(), ast_queue_control_data(), AST_SCHED_DEL, ast_set_callerid(), ast_set_flag, ast_set_flag64, ast_set_read_format(), ast_set_write_format(), ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_setnull(), ast_sockaddr_stringify(), AST_STATE_RING, ast_str_alloca, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_test_flag64, ast_var_assign, ast_variables_destroy(), ast_verb, auth_fail(), auth_method_labels, auth_method_names(), AUTH_METHOD_NAMES_BUFSIZE, authdebug, authenticate_reply(), authenticate_request(), authenticate_verify(), chan_iax2_pvt::authmethods, chan_iax2_pvt::bridgecallno, iax_ie_data::buf, c, CACHE_FLAG_TRANSMITTED, iax_frame::cacheable, calc_timestamp(), iax_ies::called_number, chan_iax2_pvt::calling_pres, iax2_peer::callno, chan_iax2_pvt::callno, iax_frame::callno, iax_ies::calltoken, iax_ies::calltokendata, chan_iax2_pvt::capability, iax_ies::cause, iax_ies::causecode, iax_ies::challenge, ast_control_pvt_cause_code::chan_name, check_access(), check_provisioning(), chan_iax2_pvt::chosenformat, chan_iax2_pvt::cid_num, ast_control_pvt_cause_code::code, iax_ies::codec_prefs, complete_dpreply(), complete_transfer(), connected, construct_rr(), chan_iax2_pvt::context, voicemailpwcheck::context, ast_iax2_full_hdr::csub, ast_datastore::data, ast_frame::data, ast_frame::datalen, DATASTORE_INHERIT_FOREVER, ast_iax2_full_hdr::dcallno, chan_iax2_pvt::dcx, DEADLOCK_AVOIDANCE, decrypt_frame(), delayreject, iax_ies::devicetype, dp_lookup(), chan_iax2_pvt::dpentries, chan_iax2_pvt::eff_auth_method, chan_iax2_pvt::encmethods, iax_ies::encmethods, iax2_peer::endpoint, ast_var_t::entries, chan_iax2_pvt::error, exists(), chan_iax2_pvt::exten, iax_frame::final, find_callno(), chan_iax2_pvt::first_iax_message, iax2_dpcache::flags, iax_ies::format, ast_frame_subclass::format, ast_frame_subclass::frame_ending, frame_queue, chan_iax2_pvt::frames_received, ast_frame::frametype, iax_ies::fwdesc, globalflags, handle_call_token(), iax2_peer::historicms, chan_iax2_pvt::hold_signaling, iax2_ack_registry(), iax2_allow_new(), iax2_codec_choose(), iax2_codec_pref_best_bitfield2cap(), iax2_codec_pref_convert(), iax2_codec_pref_index(), iax2_codec_pref_string(), iax2_destroy(), iax2_dprequest(), iax2_format_compatibility_best(), iax2_format_compatibility_cap2bitfield(), iax2_getformatname(), iax2_getformatname_multiple(), iax2_is_control_frame_allowed(), iax2_lock_owner(), iax2_poke_peer_s(), iax2_publish_registry(), iax2_queue_frame(), iax2_queue_hold(), iax2_queue_unhold(), iax2_sched_add(), iax2_send(), iax2_variable_datastore_info, iax2_vnak(), IAX_ALLOWFWDOWNLOAD, IAX_ALREADYGONE, IAX_AUTH_MD5, IAX_AUTH_RSA, IAX_CALLENCRYPTED, IAX_CODEC_NOCAP, IAX_CODEC_NOPREFS, IAX_CODEC_USER_FIRST, IAX_COMMAND_ACCEPT, IAX_COMMAND_ACK, IAX_COMMAND_AUTHREP, IAX_COMMAND_AUTHREQ, IAX_COMMAND_CALLTOKEN, IAX_COMMAND_DIAL, IAX_COMMAND_DPREP, IAX_COMMAND_DPREQ, IAX_COMMAND_FWDATA, IAX_COMMAND_FWDOWNL, IAX_COMMAND_HANGUP, IAX_COMMAND_INVAL, IAX_COMMAND_LAGRP, IAX_COMMAND_LAGRQ, IAX_COMMAND_NEW, IAX_COMMAND_PING, IAX_COMMAND_POKE, IAX_COMMAND_PONG, IAX_COMMAND_QUELCH, IAX_COMMAND_REGACK, IAX_COMMAND_REGAUTH, IAX_COMMAND_REGREJ, IAX_COMMAND_REGREL, IAX_COMMAND_REGREQ, IAX_COMMAND_REJECT, IAX_COMMAND_RTKEY, IAX_COMMAND_TRANSFER, IAX_COMMAND_TXACC, IAX_COMMAND_TXCNT, IAX_COMMAND_TXMEDIA, IAX_COMMAND_TXREADY, IAX_COMMAND_TXREJ, IAX_COMMAND_TXREL, IAX_COMMAND_TXREQ, IAX_COMMAND_UNQUELCH, IAX_COMMAND_UNSUPPORT, IAX_COMMAND_VNAK, IAX_DEBUGDIGEST, IAX_DELAYPBXSTART, IAX_ENCRYPTED, iax_firmware_append(), IAX_FLAG_FULL, IAX_FLAG_RETRANS, IAX_FORCE_ENCRYPT, iax_frame_subclass2str(), iax_frame_wrap(), iax_ie_append_byte(), iax_ie_append_int(), iax_ie_append_short(), iax_ie_append_str(), iax_ie_append_versioned_uint64(), IAX_IE_CALLNO, IAX_IE_CAUSE, IAX_IE_CAUSECODE, IAX_IE_FORMAT, IAX_IE_FORMAT2, IAX_IE_IAX_UNKNOWN, IAX_IMMEDIATE, iax_outputframe(), iax_parse_ies(), IAX_PROVISION, iax_pvt_callid_get(), iax_pvt_callid_new(), IAX_QUELCH, IAX_RECVCONNECTEDLINE, IAX_STATE_AUTHENTICATED, IAX_STATE_STARTED, IAX_STATE_TBD, IAX_TRUNK, iax_ies::iax_unknown, iaxcompat, iaxdebug, iaxfrdup2(), iaxs, iaxsl, chan_iax2_pvt::iaxvars, ast_party_caller::id, ast_datastore::inheritance, chan_iax2_pvt::initid, chan_iax2_pvt::inkeys, ast_frame_subclass::integer, chan_iax2_pvt::iseqno, ast_iax2_full_hdr::iseqno, iax_frame::iseqno, chan_iax2_pvt::lag, chan_iax2_pvt::last, chan_iax2_pvt::last_iax_message, iax2_peer::lastms, ast_frame::len, LOG_ERROR, log_jitterstats(), LOG_NOTICE, LOG_WARNING, make_trunk(), ast_frame::mallocd, iax2_peer::maxms, merge_encryption(), env::meta, chan_iax2_pvt::mohsuggest, iax_ies::musiconhold, iax2_peer::name, ast_party_id::name, NEW_ALLOW, NEW_ALLOW_CALLTOKEN_VALIDATED, NEW_PREVENT, NULL, ast_party_id::number, ast_frame::offset, chan_iax2_pvt::oseqno, ast_iax2_full_hdr::oseqno, iax_frame::oseqno, chan_iax2_pvt::outkey, iax_frame::outoforder, chan_iax2_pvt::owner, peer_ref(), peer_unref(), chan_iax2_pvt::peercallno, chan_iax2_pvt::peercapability, chan_iax2_pvt::peerformat, chan_iax2_pvt::peerpoke, chan_iax2_pvt::pingtime, iax2_peer::pokeexpire, iax2_peer::pokefreqnotok, iax2_peer::pokefreqok, iax_ie_data::pos, chan_iax2_pvt::prefs, ast_party_name::presentation, ast_party_number::presentation, iax_ies::provver, iax_ies::provverpres, ast_frame::ptr, RAII_VAR, raw_hangup(), iax_ies::refresh, chan_iax2_pvt::reg, REG_STATE_REJECTED, register_verify(), registry_authrequest(), registry_rerequest(), iax2_registry::regstate, remove_by_peercallno(), resend_with_token(), iax_frame::retries, chan_iax2_pvt::rprefs, chan_iax2_pvt::rseqno, S_COR, S_OR, ast_frame::samples, save_osptoken(), save_rr(), ast_iax2_full_hdr::scallno, schedule_delivery(), chan_iax2_pvt::secret, send_apathetic_reply(), send_command(), send_command_final(), send_command_immediate(), send_command_transfer(), send_signaling(), iax_ies::serviceident, set_hangup_source_and_cause(), iax2_peer::smoothing, socket_process_meta(), spawn_dp_lookup(), ast_frame::src, chan_iax2_pvt::state, stop_stuff(), store_by_peercallno(), ast_frame::subclass, thread, chan_iax2_pvt::transfer, iax_frame::transfer, TRANSFER_BEGIN, TRANSFER_MBEGIN, TRANSFER_MEDIA, TRANSFER_MEDIAPASS, TRANSFER_MREADY, TRANSFER_NONE, TRANSFER_READY, TRANSFER_RELEASED, chan_iax2_pvt::transferring, try_transfer(), ast_iax2_full_hdr::ts, iax_frame::ts, ast_iax2_full_hdr::type, uncompress_subclass(), update_registry(), iax2_registry::username, chan_iax2_pvt::username, iax_ies::username, var, iax_ies::vars, VERBOSE_PREFIX_4, chan_iax2_pvt::videoformat, vnak_retransmit(), and chan_iax2_pvt::voiceformat.

Referenced by socket_process().

socket_process_meta()

static int socket_process_meta ( int  packet_len, struct ast_iax2_meta_hdr *  meta, struct ast_sockaddr *  addr, int  sockfd, struct iax_frame *  fr  )

static

Definition at line 10033 of file chan_iax2.c.

{
    unsigned char metatype;
    struct ast_iax2_meta_trunk_mini *mtm;
    struct ast_iax2_meta_trunk_hdr *mth;
    struct ast_iax2_meta_trunk_entry *mte;
    struct iax2_trunk_peer *tpeer;
    unsigned int ts;
    void *ptr;
    struct timeval rxtrunktime;
    struct ast_frame f = { 0, };
 
    if (packet_len < sizeof(*meta)) {
        ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a meta frame but is too short\n",
                ast_sockaddr_stringify(addr));
        return 1;
    }
 
    if (meta->metacmd != IAX_META_TRUNK)
        return 1;
 
    if (packet_len < (sizeof(*meta) + sizeof(*mth))) {
        ast_log(LOG_WARNING, "midget meta trunk packet received (%d of %d min)\n", packet_len,
            (int) (sizeof(*meta) + sizeof(*mth)));
        return 1;
    }
    mth = (struct ast_iax2_meta_trunk_hdr *)(meta->data);
    ts = ntohl(mth->ts);
    metatype = meta->cmddata;
    packet_len -= (sizeof(*meta) + sizeof(*mth));
    ptr = mth->data;
    tpeer = find_tpeer(addr, sockfd);
    if (!tpeer) {
        ast_log(LOG_WARNING, "Unable to accept trunked packet from '%s': No matching peer\n",
                ast_sockaddr_stringify(addr));
        return 1;
    }
    tpeer->trunkact = ast_tvnow();
    if (!ts || ast_tvzero(tpeer->rxtrunktime))
        tpeer->rxtrunktime = tpeer->trunkact;
    rxtrunktime = tpeer->rxtrunktime;
    ast_mutex_unlock(&tpeer->lock);
    while (packet_len >= sizeof(*mte)) {
        /* Process channels */
        unsigned short callno, trunked_ts, len;
 
        if (metatype == IAX_META_TRUNK_MINI) {
            mtm = (struct ast_iax2_meta_trunk_mini *) ptr;
            ptr += sizeof(*mtm);
            packet_len -= sizeof(*mtm);
            len = ntohs(mtm->len);
            callno = ntohs(mtm->mini.callno);
            trunked_ts = ntohs(mtm->mini.ts);
        } else if (metatype == IAX_META_TRUNK_SUPERMINI) {
            mte = (struct ast_iax2_meta_trunk_entry *)ptr;
            ptr += sizeof(*mte);
            packet_len -= sizeof(*mte);
            len = ntohs(mte->len);
            callno = ntohs(mte->callno);
            trunked_ts = 0;
        } else {
            ast_log(LOG_WARNING, "Unknown meta trunk cmd from '%s': dropping\n", ast_sockaddr_stringify(addr));
            break;
        }
        /* Stop if we don't have enough data */
        if (len > packet_len)
            break;
        fr->callno = find_callno_locked(callno & ~IAX_FLAG_FULL, 0, addr, NEW_PREVENT, sockfd, 0);
        if (!fr->callno)
            continue;
 
        /* If it's a valid call, deliver the contents.  If not, we
           drop it, since we don't have a scallno to use for an INVAL */
        /* Process as a mini frame */
        memset(&f, 0, sizeof(f));
        f.frametype = AST_FRAME_VOICE;
        if (!iaxs[fr->callno]) {
            /* drop it */
        } else if (iaxs[fr->callno]->voiceformat == 0) {
            ast_log(LOG_WARNING, "Received trunked frame before first full voice frame\n");
            iax2_vnak(fr->callno);
        } else if ((f.subclass.format = ast_format_compatibility_bitfield2format(
                        iaxs[fr->callno]->voiceformat))) {
            f.datalen = len;
            if (f.datalen >= 0) {
                if (f.datalen)
                    f.data.ptr = ptr;
                else
                    f.data.ptr = NULL;
                if (trunked_ts)
                    fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
                else
                    fr->ts = fix_peerts(&rxtrunktime, fr->callno, ts);
                /* Don't pass any packets until we're started */
                if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
                    struct iax_frame *duped_fr;
 
                    /* Common things */
                    f.src = "IAX2";
                    f.mallocd = 0;
                    f.offset = 0;
                    if (f.datalen && (f.frametype == AST_FRAME_VOICE))
                        f.samples = ast_codec_samples_count(&f);
                    else
                        f.samples = 0;
                    fr->outoforder = 0;
                    iax_frame_wrap(fr, &f);
                    duped_fr = iaxfrdup2(fr);
                    if (duped_fr)
                        schedule_delivery(duped_fr, 1, 1, &fr->ts);
                    if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts)
                        iaxs[fr->callno]->last = fr->ts;
                }
            } else {
                ast_log(LOG_WARNING, "Datalen < 0?\n");
            }
        }
        ast_mutex_unlock(&iaxsl[fr->callno]);
        ptr += len;
        packet_len -= len;
    }
 
    return 1;
}

References ast_codec_samples_count(), ast_format_compatibility_bitfield2format(), AST_FRAME_VOICE, ast_log, ast_mutex_unlock, ast_sockaddr_stringify(), ast_test_flag, ast_tvnow(), ast_tvzero(), ast_iax2_mini_hdr::callno, ast_iax2_meta_trunk_entry::callno, iax_frame::callno, ast_iax2_meta_trunk_hdr::data, ast_frame::data, ast_frame::datalen, find_callno_locked(), find_tpeer(), fix_peerts(), ast_frame_subclass::format, ast_frame::frametype, iax2_vnak(), IAX_FLAG_FULL, iax_frame_wrap(), IAX_META_TRUNK, IAX_META_TRUNK_MINI, IAX_META_TRUNK_SUPERMINI, IAX_STATE_STARTED, iaxfrdup2(), iaxs, iaxsl, chan_iax2_pvt::last, ast_iax2_meta_trunk_entry::len, ast_iax2_meta_trunk_mini::len, len(), iax2_trunk_peer::lock, LOG_WARNING, ast_frame::mallocd, env::meta, ast_iax2_meta_trunk_mini::mini, NEW_PREVENT, NULL, ast_frame::offset, iax_frame::outoforder, ast_frame::ptr, iax2_trunk_peer::rxtrunktime, ast_frame::samples, schedule_delivery(), ast_frame::src, chan_iax2_pvt::state, ast_frame::subclass, iax2_trunk_peer::trunkact, ast_iax2_mini_hdr::ts, ast_iax2_meta_trunk_hdr::ts, iax_frame::ts, and chan_iax2_pvt::voiceformat.

Referenced by socket_process_helper().

socket_read()

static int socket_read ( int *  id, int  fd, short  events, void *  cbdata  )

static

Definition at line 9955 of file chan_iax2.c.

{
    struct iax2_thread *thread;
    time_t t;
    static time_t last_errtime = 0;
    struct ast_iax2_full_hdr *fh;
 
    if (!(thread = find_idle_thread())) {
        time(&t);
        if (t != last_errtime) {
            last_errtime = t;
            ast_debug(1, "Out of idle IAX2 threads for I/O, pausing!\n");
        }
        usleep(1);
        return 1;
    }
 
    thread->iofd = fd;
    thread->buf_len = ast_recvfrom(fd, thread->readbuf, sizeof(thread->readbuf), 0, &thread->ioaddr);
    thread->buf_size = sizeof(thread->readbuf);
    thread->buf = thread->readbuf;
    if (thread->buf_len < 0) {
        if (errno != ECONNREFUSED && errno != EAGAIN)
            ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
        handle_error();
        thread->iostate = IAX_IOSTATE_IDLE;
        signal_condition(&thread->lock, &thread->cond);
        return 1;
    }
    if (test_losspct && ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_losspct)) { /* simulate random loss condition */
        thread->iostate = IAX_IOSTATE_IDLE;
        signal_condition(&thread->lock, &thread->cond);
        return 1;
    }
 
    /* Determine if this frame is a full frame; if so, and any thread is currently
       processing a full frame for the same callno from this peer, then drop this
       frame (and the peer will retransmit it) */
    fh = (struct ast_iax2_full_hdr *) thread->buf;
    if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
        struct iax2_thread *cur = NULL;
        uint16_t callno = ntohs(fh->scallno) & ~IAX_FLAG_FULL;
 
        AST_LIST_LOCK(&active_list);
        AST_LIST_TRAVERSE(&active_list, cur, list) {
            if ((cur->ffinfo.callno == callno) &&
                !ast_sockaddr_cmp_addr(&cur->ffinfo.addr, &thread->ioaddr))
                break;
        }
        if (cur) {
            /* we found another thread processing a full frame for this call,
               so queue it up for processing later. */
            defer_full_frame(thread, cur);
            AST_LIST_UNLOCK(&active_list);
            thread->iostate = IAX_IOSTATE_IDLE;
            signal_condition(&thread->lock, &thread->cond);
            return 1;
        } else {
            /* this thread is going to process this frame, so mark it */
            thread->ffinfo.callno = callno;
            ast_sockaddr_copy(&thread->ffinfo.addr, &thread->ioaddr);
            thread->ffinfo.type = fh->type;
            thread->ffinfo.csub = fh->csub;
            AST_LIST_INSERT_HEAD(&active_list, thread, list);
        }
        AST_LIST_UNLOCK(&active_list);
    }
 
    /* Mark as ready and send on its way */
    thread->iostate = IAX_IOSTATE_READY;
#ifdef DEBUG_SCHED_MULTITHREAD
    ast_copy_string(thread->curfunc, "socket_process", sizeof(thread->curfunc));
#endif
    signal_condition(&thread->lock, &thread->cond);
 
    return 1;
}

References iax2_thread::addr, ast_copy_string(), ast_debug, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_random(), ast_recvfrom(), ast_sockaddr_cmp_addr(), ast_sockaddr_copy(), iax2_thread::callno, ast_iax2_full_hdr::csub, defer_full_frame(), errno, iax2_thread::ffinfo, find_idle_thread(), handle_error(), IAX_FLAG_FULL, IAX_IOSTATE_IDLE, IAX_IOSTATE_READY, if(), iax2_thread::list, LOG_WARNING, NULL, ast_iax2_full_hdr::scallno, signal_condition(), test_losspct, thread, and ast_iax2_full_hdr::type.

Referenced by peer_set_srcaddr(), and set_config().

spawn_dp_lookup()

static void spawn_dp_lookup ( int  callno, const char *  context, const char *  callednum, const char *  callerid  )

static

Definition at line 9763 of file chan_iax2.c.

{
    pthread_t newthread;
    struct dpreq_data *dpr;
 
    if (!(dpr = ast_calloc(1, sizeof(*dpr))))
        return;
 
    dpr->callno = callno;
    ast_copy_string(dpr->context, context, sizeof(dpr->context));
    ast_copy_string(dpr->callednum, callednum, sizeof(dpr->callednum));
    if (callerid)
        dpr->callerid = ast_strdup(callerid);
    if (ast_pthread_create_detached(&newthread, NULL, dp_lookup_thread, dpr)) {
        ast_log(LOG_WARNING, "Unable to start lookup thread!\n");
    }
}

References ast_calloc, ast_copy_string(), ast_log, ast_pthread_create_detached, ast_strdup, dpreq_data::callednum, dpreq_data::callerid, dpreq_data::callno, dpreq_data::context, voicemailpwcheck::context, dp_lookup_thread(), LOG_WARNING, and NULL.

Referenced by socket_process_helper().

start_network_thread()

static int start_network_thread ( void  )

static

Definition at line 12818 of file chan_iax2.c.

{
    struct iax2_thread *thread;
    int threadcount = 0;
    int x;
    for (x = 0; x < iaxthreadcount; x++) {
        thread = ast_calloc(1, sizeof(*thread));
        if (thread) {
            thread->type = IAX_THREAD_TYPE_POOL;
            thread->threadnum = ++threadcount;
            ast_mutex_init(&thread->lock);
            ast_cond_init(&thread->cond, NULL);
            ast_mutex_init(&thread->init_lock);
            ast_cond_init(&thread->init_cond, NULL);
 
            ast_mutex_lock(&thread->init_lock);
 
            if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
                ast_log(LOG_WARNING, "Failed to create new thread!\n");
                ast_mutex_destroy(&thread->lock);
                ast_cond_destroy(&thread->cond);
                ast_mutex_unlock(&thread->init_lock);
                ast_mutex_destroy(&thread->init_lock);
                ast_cond_destroy(&thread->init_cond);
                ast_free(thread);
                thread = NULL;
                continue;
            }
            /* Wait for the thread to be ready */
            ast_cond_wait(&thread->init_cond, &thread->init_lock);
 
            /* Done with init_lock */
            ast_mutex_unlock(&thread->init_lock);
 
            AST_LIST_LOCK(&idle_list);
            AST_LIST_INSERT_TAIL(&idle_list, thread, list);
            AST_LIST_UNLOCK(&idle_list);
        }
    }
    if (ast_pthread_create_background(&netthreadid, NULL, network_thread, NULL)) {
        ast_log(LOG_ERROR, "Failed to create new thread!\n");
        return -1;
    }
    ast_verb(2, "%d helper threads started\n", threadcount);
    return 0;
}

References ast_calloc, ast_cond_destroy, ast_cond_init, ast_cond_wait, ast_free, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_background, ast_verb, iax2_process_thread(), IAX_THREAD_TYPE_POOL, iaxthreadcount, iax2_thread::list, LOG_ERROR, LOG_WARNING, netthreadid, network_thread(), NULL, and thread.

Referenced by load_module().

stop_stuff()

static void stop_stuff ( int  callno )

static

Definition at line 9459 of file chan_iax2.c.

{
    iax2_destroy_helper(iaxs[callno]);
}

References iax2_destroy_helper(), and iaxs.

Referenced by socket_process_helper().

store_by_peercallno()

static void store_by_peercallno ( struct chan_iax2_pvt *  pvt )

static

Definition at line 2491 of file chan_iax2.c.

{
    if (!pvt->peercallno) {
        ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
        return;
    }
 
    ao2_link(iax_peercallno_pvts, pvt);
}

References ao2_link, ast_log, iax_peercallno_pvts, LOG_ERROR, and chan_iax2_pvt::peercallno.

Referenced by __find_callno(), complete_transfer(), and socket_process_helper().

store_by_transfercallno()

static void store_by_transfercallno ( struct chan_iax2_pvt *  pvt )

static

Definition at line 2472 of file chan_iax2.c.

{
    if (!pvt->transfercallno) {
        ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
        return;
    }
 
    ao2_link(iax_transfercallno_pvts, pvt);
}

References ao2_link, ast_log, iax_transfercallno_pvts, LOG_ERROR, and chan_iax2_pvt::transfercallno.

Referenced by try_transfer().

timing_read()

static int timing_read ( int *  id, int  fd, short  events, void *  cbdata  )

static

Definition at line 9642 of file chan_iax2.c.

{
    int res, processed = 0, totalcalls = 0;
    struct iax2_trunk_peer *tpeer = NULL, *drop = NULL;
    struct timeval now = ast_tvnow();
 
    if (iaxtrunkdebug) {
        ast_verbose("Beginning trunk processing. Trunk queue ceiling is %d bytes per host\n", trunkmaxsize);
    }
 
    if (timer) {
        if (ast_timer_ack(timer, 1) < 0) {
            ast_log(LOG_ERROR, "Timer failed acknowledge\n");
            return 0;
        }
    }
 
    /* For each peer that supports trunking... */
    AST_LIST_LOCK(&tpeers);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&tpeers, tpeer, list) {
        processed++;
        res = 0;
        ast_mutex_lock(&tpeer->lock);
        /* We can drop a single tpeer per pass.  That makes all this logic
           substantially easier */
        if (!drop && iax2_trunk_expired(tpeer, &now)) {
            /* Take it out of the list, but don't free it yet, because it
               could be in use */
            AST_LIST_REMOVE_CURRENT(list);
            drop = tpeer;
        } else {
            res = send_trunk(tpeer, &now);
            trunk_timed++;
            if (iaxtrunkdebug) {
                ast_verbose(" - Trunk peer (%s) has %d call chunk%s in transit, %u bytes backlogged and has hit a high water mark of %u bytes\n",
                            ast_sockaddr_stringify(&tpeer->addr),
                            res,
                            (res != 1) ? "s" : "",
                            tpeer->trunkdatalen,
                            tpeer->trunkdataalloc);
            }
        }
        totalcalls += res;
        res = 0;
        ast_mutex_unlock(&tpeer->lock);
    }
    AST_LIST_TRAVERSE_SAFE_END;
    AST_LIST_UNLOCK(&tpeers);
 
    if (drop) {
        ast_mutex_lock(&drop->lock);
        /*  Once we have this lock, we're sure nobody else is using it or could use it once we release it,
            because by the time they could get tpeerlock, we've already grabbed it */
        ast_debug(1, "Dropping unused iax2 trunk peer '%s'\n", ast_sockaddr_stringify(&drop->addr));
        if (drop->trunkdata) {
            ast_free(drop->trunkdata);
            drop->trunkdata = NULL;
        }
        ast_mutex_unlock(&drop->lock);
        ast_mutex_destroy(&drop->lock);
        ast_free(drop);
    }
 
    if (iaxtrunkdebug) {
        ast_verbose("Ending trunk processing with %d peers and %d call chunks processed\n", processed, totalcalls);
    }
    iaxtrunkdebug = 0;
 
    return 1;
}

References iax2_trunk_peer::addr, ast_debug, ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_stringify(), ast_timer_ack(), ast_tvnow(), ast_verbose(), iax2_trunk_expired(), iaxtrunkdebug, iax2_trunk_peer::lock, LOG_ERROR, NULL, send_trunk(), timer, totalcalls, trunk_timed, iax2_trunk_peer::trunkdataalloc, iax2_trunk_peer::trunkdatalen, and trunkmaxsize.

Referenced by network_thread().

transfercallno_pvt_cmp_cb()

static int transfercallno_pvt_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 14936 of file chan_iax2.c.

{
    struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
 
    /* The frames_received field is used to hold whether we're matching
     * against a full frame or not ... */
 
    return match(&pvt2->transfer, pvt2->transfercallno, pvt2->callno, pvt,
        pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, chan_iax2_pvt::frames_received, and match().

Referenced by load_objects().

transfercallno_pvt_hash_cb()

static int transfercallno_pvt_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 14929 of file chan_iax2.c.

{
    const struct chan_iax2_pvt *pvt = obj;
 
    return pvt->transfercallno;
}

References chan_iax2_pvt::transfercallno.

Referenced by load_objects().

transmit_frame()

static int transmit_frame ( void *  data )

static

Definition at line 4380 of file chan_iax2.c.

{
    struct iax_frame *fr = data;
 
    ast_mutex_lock(&iaxsl[fr->callno]);
 
    fr->sentyet = 1;
 
    if (iaxs[fr->callno]) {
        send_packet(fr);
    }
 
    if (fr->retries < 0) {
        ast_mutex_unlock(&iaxsl[fr->callno]);
        /* No retransmit requested */
        iax_frame_free(fr);
    } else {
        /* We need reliable delivery.  Schedule a retransmission */
        AST_LIST_INSERT_TAIL(&frame_queue[fr->callno], fr, list);
        fr->retries++;
        fr->retrans = iax2_sched_add(sched, fr->retrytime, attempt_transmit, fr);
        ast_mutex_unlock(&iaxsl[fr->callno]);
    }
 
    return 0;
}

References AST_LIST_INSERT_TAIL, ast_mutex_lock, ast_mutex_unlock, attempt_transmit(), iax_frame::callno, iax_frame::data, frame_queue, iax2_sched_add(), iax_frame_free(), iaxs, iaxsl, iax_frame::list, iax_frame::retrans, iax_frame::retries, iax_frame::retrytime, send_packet(), and iax_frame::sentyet.

Referenced by iax2_transmit().

transmit_trunk()

static int transmit_trunk ( struct iax_frame *  f, struct ast_sockaddr *  addr, int  sockfd  )

static

Definition at line 3462 of file chan_iax2.c.

{
    int res;
    res = ast_sendto(sockfd, f->data, f->datalen, 0, addr);
 
    if (res < 0) {
        ast_debug(1, "Received error: %s\n", strerror(errno));
        handle_error();
    } else
        res = 0;
    return res;
}

References ast_debug, ast_sendto(), iax_frame::data, iax_frame::datalen, errno, and handle_error().

Referenced by send_trunk().

try_transfer()

static int try_transfer ( struct chan_iax2_pvt *  pvt, struct iax_ies *  ies  )

static

Definition at line 8750 of file chan_iax2.c.

{
    int newcall = 0;
    struct iax_ie_data ied;
    struct ast_sockaddr new = { {0,} };
 
    memset(&ied, 0, sizeof(ied));
    if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
        ast_sockaddr_copy(&new, &ies->apparent_addr);
    }
    if (ies->callno) {
        newcall = ies->callno;
    }
    if (!newcall || ast_sockaddr_isnull(&new)) {
        ast_log(LOG_WARNING, "Invalid transfer request\n");
        return -1;
    }
    pvt->transfercallno = newcall;
    ast_sockaddr_copy(&pvt->transfer, &new);
    pvt->transferid = ies->transferid;
    /* only store by transfercallno if this is a new transfer,
     * just in case we get a duplicate TXREQ */
    if (pvt->transferring == TRANSFER_NONE) {
        store_by_transfercallno(pvt);
    }
    pvt->transferring = TRANSFER_BEGIN;
 
    if (ies->transferid) {
        iax_ie_append_int(&ied, IAX_IE_TRANSFERID, ies->transferid);
    }
    send_command_transfer(pvt, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos);
    return 0;
}

References iax_ies::apparent_addr, AST_FRAME_IAX, ast_log, ast_sockaddr_copy(), ast_sockaddr_isnull(), iax_ie_data::buf, iax_ies::callno, IAX_COMMAND_TXCNT, iax_ie_append_int(), IAX_IE_TRANSFERID, LOG_WARNING, iax_ie_data::pos, send_command_transfer(), store_by_transfercallno(), chan_iax2_pvt::transfer, TRANSFER_BEGIN, TRANSFER_NONE, chan_iax2_pvt::transfercallno, chan_iax2_pvt::transferid, iax_ies::transferid, and chan_iax2_pvt::transferring.

Referenced by socket_process_helper().

uncompress_subclass()

static iax2_format uncompress_subclass ( unsigned char  csub )

static

Definition at line 1906 of file chan_iax2.c.

{
    /* If the SC_LOG flag is set, return 2^csub otherwise csub */
    if (csub & IAX_FLAG_SC_LOG) {
        /* special case for 'compressed' -1 */
        if (csub == 0xff)
            return -1;
        else
            return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
    }
    else
        return csub;
}

References iax2_thread::csub, IAX_FLAG_SC_LOG, and IAX_MAX_SHIFT.

Referenced by decode_frame(), handle_call_token(), and socket_process_helper().

unlink_peer()

static void unlink_peer ( struct iax2_peer *  peer )

static

Definition at line 9061 of file chan_iax2.c.

{
    if (peer->expire > -1) {
        if (!AST_SCHED_DEL(sched, peer->expire)) {
            peer->expire = -1;
            peer_unref(peer);
        }
    }
 
    if (peer->pokeexpire > -1) {
        if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
            peer->pokeexpire = -1;
            peer_unref(peer);
        }
    }
 
    ao2_unlink(peers, peer);
}

References ao2_unlink, AST_SCHED_DEL, iax2_peer::expire, peer_unref(), and iax2_peer::pokeexpire.

Referenced by __expire_registry(), build_peer(), and prune_peers().

unload_module()

static int unload_module ( void  )

static

Definition at line 14894 of file chan_iax2.c.

{
    ast_custom_function_unregister(&iaxpeer_function);
    ast_custom_function_unregister(&iaxvar_function);
    return __unload_module();
}

References __unload_module(), ast_custom_function_unregister(), iaxpeer_function, and iaxvar_function.

unwrap_timestamp()

static void unwrap_timestamp ( struct iax_frame *  fr )

static

Definition at line 4146 of file chan_iax2.c.

{
    /* Video mini frames only encode the lower 15 bits of the session
     * timestamp, but other frame types (e.g. audio) encode 16 bits. */
    const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
    const int lower_mask = (1 << ts_shift) - 1;
    const int upper_mask = ~lower_mask;
    const int last_upper = iaxs[fr->callno]->last & upper_mask;
 
    if ( (fr->ts & upper_mask) == last_upper ) {
        const int x = fr->ts - iaxs[fr->callno]->last;
        const int threshold = (ts_shift == 15) ? 25000 : 50000;
 
        if (x < -threshold) {
            /* Sudden big jump backwards in timestamp:
               What likely happened here is that miniframe timestamp has circled but we haven't
               gotten the update from the main packet.  We'll just pretend that we did, and
               update the timestamp appropriately. */
            fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
            if (iaxdebug)
                ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
        } else if (x > threshold) {
            /* Sudden apparent big jump forwards in timestamp:
               What's likely happened is this is an old miniframe belonging to the previous
               top 15 or 16-bit timestamp that has turned up out of order.
               Adjust the timestamp appropriately. */
            fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
            if (iaxdebug)
                ast_debug(1, "schedule_delivery: pushed back timestamp\n");
        }
    }
}

References iax_frame::af, ast_debug, AST_FRAME_VIDEO, iax_frame::callno, ast_frame::frametype, iaxdebug, iaxs, chan_iax2_pvt::last, and iax_frame::ts.

Referenced by schedule_delivery().

update_jbsched()

static void update_jbsched ( struct chan_iax2_pvt *  pvt )

static

Definition at line 4181 of file chan_iax2.c.

{
    int when;
 
    when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
 
    when = jb_next(pvt->jb) - when;
 
    if (when <= 0) {
        /* XXX should really just empty until when > 0.. */
        when = 1;
    }
 
    pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb,
        CALLNO_TO_PTR(pvt->callno));
}

References ast_tvdiff_ms(), ast_tvnow(), chan_iax2_pvt::callno, CALLNO_TO_PTR, get_from_jb(), iax2_sched_replace(), chan_iax2_pvt::jb, jb_next(), chan_iax2_pvt::jbid, and chan_iax2_pvt::rxcore.

Referenced by __get_from_jb(), and schedule_delivery().

update_packet()

static int update_packet ( struct iax_frame *  f )

static

Definition at line 3594 of file chan_iax2.c.

{
    /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
    struct ast_iax2_full_hdr *fh = f->data;
    struct ast_frame af;
 
    /* if frame is encrypted. decrypt before updating it. */
    if (f->encmethods) {
        decode_frame(&f->mydcx, fh, &af, &f->datalen);
    }
    /* Mark this as a retransmission */
    fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
    /* Update iseqno */
    f->iseqno = iaxs[f->callno]->iseqno;
    fh->iseqno = f->iseqno;
 
    /* Now re-encrypt the frame */
    if (f->encmethods) {
    /* since this is a retransmit frame, create a new random padding
     * before re-encrypting. */
        build_rand_pad(f->semirand, sizeof(f->semirand));
        encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
    }
    return 0;
}

References build_rand_pad(), iax_frame::callno, iax_frame::data, iax_frame::datalen, ast_iax2_full_hdr::dcallno, iax_frame::dcallno, decode_frame(), iax_frame::ecx, iax_frame::encmethods, encrypt_frame(), IAX_FLAG_RETRANS, iaxs, chan_iax2_pvt::iseqno, ast_iax2_full_hdr::iseqno, iax_frame::iseqno, iax_frame::mydcx, and iax_frame::semirand.

Referenced by __attempt_transmit().

update_registry()

static int update_registry ( struct ast_sockaddr *  addr, int  callno, char *  devtype, int  fd, unsigned short  refresh  )

static

Precondition

iaxsl[callno] is locked

Note

Since this function calls send_command_final(), the pvt struct for the given call number may disappear while executing this function.

Definition at line 9184 of file chan_iax2.c.

{
 
    /* Called from IAX thread only, with proper iaxsl lock */
    struct iax_ie_data ied = {
        .pos = 0,
    };
    struct iax2_peer *p;
    int msgcount;
    char data[80];
    uint16_t version;
    const char *peer_name;
    int res = -1;
    char *str_addr;
 
    peer_name = ast_strdupa(iaxs[callno]->peer);
 
    /* SLD: Another find_peer call during registration - this time when we are really updating our registration */
    ast_mutex_unlock(&iaxsl[callno]);
    if (!(p = find_peer(peer_name, 1))) {
        ast_mutex_lock(&iaxsl[callno]);
        ast_log(LOG_WARNING, "No such peer '%s'\n", peer_name);
        return -1;
    }
    ast_mutex_lock(&iaxsl[callno]);
    if (!iaxs[callno])
        goto return_unref;
 
    if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(p, IAX_TEMPONLY|IAX_RTCACHEFRIENDS))) {
        if (!ast_sockaddr_isnull(addr)) {
            time_t nowtime;
            time(&nowtime);
            realtime_update_peer(peer_name, addr, nowtime);
        } else {
            realtime_update_peer(peer_name, addr, 0);
        }
    }
 
    /* treat an unspecified refresh interval as the minimum */
    if (!refresh) {
        refresh = min_reg_expire;
    }
    if (refresh > max_reg_expire) {
        ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
            p->name, max_reg_expire, refresh);
        p->expiry = max_reg_expire;
    } else if (refresh < min_reg_expire) {
        ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
            p->name, min_reg_expire, refresh);
        p->expiry = min_reg_expire;
    } else {
        p->expiry = refresh;
    }
 
    if (ast_sockaddr_cmp(&p->addr, addr)) {
        RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
        if (iax2_regfunk) {
            iax2_regfunk(p->name, 1);
        }
 
        /* modify entry in peercnts table as _not_ registered */
        peercnt_modify((unsigned char) 0, 0, &p->addr);
 
        /* Stash the IP address from which they registered */
        ast_sockaddr_copy(&p->addr, addr);
 
        str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
 
        snprintf(data, sizeof(data), "%s:%d", ast_sockaddr_stringify(addr), p->expiry);
 
        if (!ast_test_flag64(p, IAX_TEMPONLY) && !ast_sockaddr_isnull(addr)) {
            ast_db_put("IAX/Registry", p->name, data);
            ast_verb(3, "Registered IAX2 '%s' (%s) at %s\n",
                        p->name,
                        ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED",
                        ast_sockaddr_stringify(addr));
            ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_ONLINE);
            blob = ast_json_pack("{s: s, s: s, s: i}",
                "peer_status", "Registered",
                "address", str_addr,
                "port", ast_sockaddr_port(addr));
            register_peer_exten(p, 1);
            ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
        } else if (!ast_test_flag64(p, IAX_TEMPONLY)) {
            ast_verb(3, "Unregistered IAX2 '%s' (%s)\n",
                        p->name,
                        ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED");
            ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_OFFLINE);
            blob = ast_json_pack("{s: s}",
                "peer_status", "Unregistered");
            register_peer_exten(p, 0);
            ast_db_del("IAX/Registry", p->name);
            ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
        }
 
        ast_endpoint_blob_publish(p->endpoint, ast_endpoint_state_type(), blob);
 
        /* Update the host */
        /* Verify that the host is really there */
        iax2_poke_peer(p, callno);
    }
 
    /* modify entry in peercnts table as registered */
    if (p->maxcallno) {
        peercnt_modify((unsigned char) 1, p->maxcallno, &p->addr);
    }
 
    /* Make sure our call still exists, an INVAL at the right point may make it go away */
    if (!iaxs[callno]) {
        res = -1;
        goto return_unref;
    }
 
    /* Store socket fd */
    p->sockfd = fd;
    /* Setup the expiry */
    if (p->expire > -1) {
        if (!AST_SCHED_DEL(sched, p->expire)) {
            p->expire = -1;
            peer_unref(p);
        }
    }
 
    if (p->expiry && !ast_sockaddr_isnull(addr)) {
        p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
        if (p->expire == -1)
            peer_unref(p);
    }
    iax_ie_append_str(&ied, IAX_IE_USERNAME, p->name);
    iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(p->zonetag));
    if (!ast_sockaddr_isnull(addr)) {
        struct ast_sockaddr peer_addr;
 
        ast_sockaddr_copy(&peer_addr, &p->addr);
 
        iax_ie_append_short(&ied, IAX_IE_REFRESH, p->expiry);
        iax_ie_append_addr(&ied, IAX_IE_APPARENT_ADDR, &peer_addr);
        if (!ast_strlen_zero(p->mailbox)) {
            int new, old;
            RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
            msg = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), p->mailbox);
            if (msg) {
                struct ast_mwi_state *mwi_state = stasis_message_data(msg);
                new = mwi_state->new_msgs;
                old = mwi_state->old_msgs;
            } else { /* Fall back on checking the mailbox directly */
                ast_app_inboxcount(p->mailbox, &new, &old);
            }
 
            if (new > 255) {
                new = 255;
            }
            if (old > 255) {
                old = 255;
            }
            msgcount = (old << 8) | new;
 
            iax_ie_append_short(&ied, IAX_IE_MSGCOUNT, msgcount);
        }
        if (ast_test_flag64(p, IAX_HASCALLERID)) {
            iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, p->cid_num);
            iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, p->cid_name);
        }
    }
    if (iax_firmware_get_version(devtype, &version)) {
        iax_ie_append_short(&ied, IAX_IE_FIRMWAREVER, version);
    }
 
    res = 0;
 
return_unref:
    peer_unref(p);
 
    return res ? res : send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGACK, 0, ied.buf, ied.pos, -1);
}

References iax2_peer::addr, ao2_cleanup, ast_app_inboxcount(), ast_db_del(), ast_db_put(), AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_endpoint_blob_publish(), AST_ENDPOINT_OFFLINE, AST_ENDPOINT_ONLINE, ast_endpoint_set_state(), ast_endpoint_state_type(), AST_FRAME_IAX, ast_json_pack(), ast_json_unref(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_mwi_state_cache(), ast_mwi_state_type(), AST_SCHED_DEL, ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_port, ast_sockaddr_stringify(), ast_sockaddr_stringify_addr(), ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_test_flag64, ast_verb, iax_ie_data::buf, iax2_peer::callno, iax2_peer::cid_name, iax2_peer::cid_num, iax2_peer::endpoint, iax2_peer::expire, expire_registry(), iax2_peer::expiry, find_peer(), globalflags, iax2_datetime(), iax2_poke_peer(), iax2_regfunk, iax2_sched_add(), IAX_COMMAND_REGACK, iax_firmware_get_version(), IAX_HASCALLERID, IAX_IE_APPARENT_ADDR, iax_ie_append_addr(), iax_ie_append_int(), iax_ie_append_short(), iax_ie_append_str(), IAX_IE_CALLING_NAME, IAX_IE_CALLING_NUMBER, IAX_IE_DATETIME, IAX_IE_FIRMWAREVER, IAX_IE_MSGCOUNT, IAX_IE_REFRESH, IAX_IE_USERNAME, IAX_RTCACHEFRIENDS, IAX_RTUPDATE, IAX_STATE_AUTHENTICATED, IAX_TEMPONLY, iaxs, iaxsl, LOG_NOTICE, LOG_WARNING, iax2_peer::mailbox, max_reg_expire, iax2_peer::maxcallno, min_reg_expire, iax2_peer::name, ast_mwi_state::new_msgs, NULL, ast_mwi_state::old_msgs, peer_ref(), peer_unref(), peercnt_modify(), iax_ie_data::pos, RAII_VAR, realtime_update_peer(), refresh, register_peer_exten(), send_command_final(), iax2_peer::sockfd, stasis_cache_get(), stasis_message_data(), version, and iax2_peer::zonetag.

Referenced by socket_process_helper().

user_cmp_cb()

static int user_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Note

The only member of the user passed here guaranteed to be set is the name field

Definition at line 2069 of file chan_iax2.c.

{
    struct iax2_user *user = obj, *user2 = arg;
    const char *name = arg;
 
    return !strcmp(user->name, flags & OBJ_KEY ? name : user2->name) ?
            CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, iax2_user::flags, name, and OBJ_KEY.

Referenced by load_objects().

user_delme_cb()

static int user_delme_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 13610 of file chan_iax2.c.

{
    struct iax2_user *user = obj;
 
    ast_set_flag64(user, IAX_DELME);
 
    return 0;
}

References ast_set_flag64, and IAX_DELME.

Referenced by delete_users().

user_destructor()

static void user_destructor ( void *  obj )

static

Definition at line 13325 of file chan_iax2.c.

{
    struct iax2_user *user = obj;
 
    ast_free_acl_list(user->acl);
    free_context(user->contexts);
    if(user->vars) {
        ast_variables_destroy(user->vars);
        user->vars = NULL;
    }
    ast_string_field_free_memory(user);
}

References ast_free_acl_list(), ast_string_field_free_memory, ast_variables_destroy(), free_context(), and NULL.

Referenced by build_user().

user_hash_cb()

static int user_hash_cb ( const void *  obj, const int  flags  )

static

Note

The only member of the user passed here guaranteed to be set is the name field

Definition at line 2058 of file chan_iax2.c.

{
    const struct iax2_user *user = obj;
    const char *name = obj;
 
    return ast_str_hash(flags & OBJ_KEY ? name : user->name);
}

References ast_str_hash(), iax2_user::flags, name, and OBJ_KEY.

Referenced by load_objects().

user_unref()

static struct iax2_user * user_unref ( struct iax2_user *  user )

inlinestatic

Definition at line 2112 of file chan_iax2.c.

{
    ao2_ref(user, -1);
    return NULL;
}

References ao2_ref, and NULL.

Referenced by authenticate_request(), authenticate_verify(), build_user(), calltoken_required(), check_access(), handle_cli_iax2_prune_realtime(), handle_cli_iax2_show_users(), iax2_destroy_helper(), prune_users(), requirecalltoken_mark_auto(), and set_config().

vnak_retransmit()

static void vnak_retransmit ( int  callno, int  last  )

static

Definition at line 9560 of file chan_iax2.c.

{
    struct iax_frame *f;
 
    AST_LIST_TRAVERSE(&frame_queue[callno], f, list) {
        /* Send a copy immediately */
        if (((unsigned char) (f->oseqno - last) < 128) &&
                (f->retries >= 0)) {
            send_packet(f);
        }
    }
}

References AST_LIST_TRAVERSE, iax_frame::callno, frame_queue, last, iax_frame::list, iax_frame::oseqno, iax_frame::retries, and send_packet().

Referenced by socket_process_helper().

wait_for_peercallno()

static int wait_for_peercallno ( struct chan_iax2_pvt *  pvt )

static

Note

expects the pvt to be locked

Definition at line 5465 of file chan_iax2.c.

{
    unsigned short callno = pvt->callno;
 
    if (!pvt->peercallno) {
        /* We don't know the remote side's call number, yet.  :( */
        int count = 10;
        while (count-- && pvt && !pvt->peercallno) {
            DEADLOCK_AVOIDANCE(&iaxsl[callno]);
            pvt = iaxs[callno];
        }
        if (!pvt || !pvt->peercallno) {
            return -1;
        }
    }
 
    return 0;
}

References chan_iax2_pvt::callno, DEADLOCK_AVOIDANCE, iaxs, iaxsl, and chan_iax2_pvt::peercallno.

Referenced by iax2_indicate(), and iax2_setoption().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Inter Asterisk eXchange (Ver 2)" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .requires = "dnsmgr", .optional_modules = "res_crypto", }

static

Definition at line 15186 of file chan_iax2.c.

accountcode

char accountcode[AST_MAX_ACCOUNT_CODE]

static

Definition at line 497 of file chan_iax2.c.

Referenced by __find_callno(), ast_channel_yank(), ast_res_pjsip_initialize_configuration(), build_user(), channel_snapshot_base_create(), check_access(), func_channel_write_real(), load_module(), set_config(), set_config_destroy(), tds_log(), and verify_mock_cdr_record().

acl_change_sub

struct stasis_subscription* acl_change_sub

static

subscription id for ACL change events

Definition at line 352 of file chan_iax2.c.

Referenced by acl_change_stasis_subscribe(), acl_change_stasis_unsubscribe(), rtp_reload(), and unload_module().

active_list

struct active_list active_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

adsi

int adsi = 0

static

Definition at line 501 of file chan_iax2.c.

Referenced by build_peer(), build_user(), and set_config().

amaflags

int amaflags = 0

static

Definition at line 500 of file chan_iax2.c.

Referenced by __find_callno(), build_radius_record(), cdr_read_callback(), cdr_write(), func_channel_write_real(), set_config(), set_config_destroy(), and verify_mock_cdr_record().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 15186 of file chan_iax2.c.

auth_method_labels

const char* auth_method_labels[]

static

Name of effective auth method.

Definition at line 423 of file chan_iax2.c.

Referenced by socket_process_helper().

authdebug

int authdebug = 0

static

Definition at line 369 of file chan_iax2.c.

Referenced by authenticate_verify(), register_verify(), set_config(), and socket_process_helper().

autokill

int autokill = 0

static

Definition at line 370 of file chan_iax2.c.

Referenced by iax2_call(), and set_config().

callno_limits

struct ao2_container* callno_limits

static

Table containing custom callno limit rules for a range of ip addresses.

Definition at line 1034 of file chan_iax2.c.

Referenced by __unload_module(), build_callno_limits(), load_objects(), reload_config(), set_config_destroy(), and set_peercnt_limit().

callno_pool

struct call_number_pool callno_pool

static

table of available call numbers

Definition at line 991 of file chan_iax2.c.

Referenced by create_callno_pools(), get_unused_callno(), handle_cli_iax2_show_callno_limits(), and replace_callno().

callno_pool_lock

ast_mutex_t callno_pool_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 988 of file chan_iax2.c.

Referenced by get_unused_callno(), and replace_callno().

callno_pool_trunk

struct call_number_pool callno_pool_trunk

static

table of available trunk call numbers

Definition at line 994 of file chan_iax2.c.

Referenced by create_callno_pools(), get_unused_callno(), handle_cli_iax2_show_callno_limits(), and replace_callno().

calltoken_ignores

struct ao2_container* calltoken_ignores

static

Table containing ip addresses not requiring calltoken validation

Definition at line 1037 of file chan_iax2.c.

Referenced by __unload_module(), add_calltoken_ignore(), calltoken_required(), load_objects(), reload_config(), and set_config_destroy().

cli_iax2

struct ast_cli_entry cli_iax2[]

static

Definition at line 14765 of file chan_iax2.c.

Referenced by __unload_module(), and load_module().

cos

unsigned int cos

Definition at line 380 of file chan_iax2.c.

Referenced by a2lsf(), ast_netsock_bind(), ast_netsock_bindaddr(), ast_netsock_set_qos(), ast_playtones_start(), ast_rtp_instance_set_qos(), ast_rtp_qos_set(), ast_set_qos(), ast_sip_initialize_sorcery_transport(), ast_str2cos(), ast_udptl_setqos(), callerid_init(), goertzel_init(), lsf2a(), smath(), smb_fft(), smb_pitch_shift(), tdd_init(), and tonepair_alloc().

debugaddr

struct ast_sockaddr debugaddr

static

Definition at line 1250 of file chan_iax2.c.

Referenced by handle_cli_iax2_set_debug(), iax_outputframe(), and reload_config().

DEFAULT_MAXCALLNO_LIMIT

uint16_t DEFAULT_MAXCALLNO_LIMIT = 2048

static

Definition at line 1039 of file chan_iax2.c.

Referenced by set_config().

DEFAULT_MAXCALLNO_LIMIT_NONVAL

uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192

static

Definition at line 1041 of file chan_iax2.c.

Referenced by set_config().

default_parkinglot

char default_parkinglot[AST_MAX_CONTEXT]

static

Definition at line 346 of file chan_iax2.c.

Referenced by __find_callno(), and set_config().

defaultsockfd

int defaultsockfd = -1

static

Definition at line 392 of file chan_iax2.c.

Referenced by build_peer(), create_addr(), iax2_do_register(), peer_set_sock_cb(), peer_set_srcaddr(), and set_config().

delayreject

int delayreject = 0

static

Definition at line 502 of file chan_iax2.c.

Referenced by auth_fail(), set_config(), set_config_destroy(), and socket_process_helper().

dpcache

struct dpcache dpcache = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

dynamic_list

struct dynamic_list dynamic_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

first

struct iax_frame* first

Definition at line 1005 of file chan_iax2.c.

struct { ... } frame_queue[IAX_MAX_CALLS]

a list of frames that may need to be retransmitted

Note

The contents of this list do not need to be explicitly destroyed on module unload. This is because all active calls are destroyed, and all frames in this queue will get destroyed as a part of that process.

Contents protected by the iaxsl[] locks

Referenced by __attempt_transmit(), complete_transfer(), handle_cli_iax2_show_stats(), pvt_destructor(), resend_with_token(), socket_process_helper(), transmit_frame(), and vnak_retransmit().

global_max_trunk_mtu

int global_max_trunk_mtu

static

Maximum MTU, 0 if not used

Definition at line 341 of file chan_iax2.c.

Referenced by handle_cli_iax2_set_mtu(), handle_cli_iax2_show_stats(), iax2_trunk_queue(), and set_config().

global_maxcallno

uint16_t global_maxcallno

static

Definition at line 1043 of file chan_iax2.c.

Referenced by set_config(), and set_peercnt_limit().

global_maxcallno_nonval

uint16_t global_maxcallno_nonval

static

Total num of call numbers allowed to be allocated without calltoken validation

Definition at line 1046 of file chan_iax2.c.

Referenced by get_unused_callno(), handle_cli_iax2_show_callno_limits(), and set_config().

global_rtautoclear

int global_rtautoclear = 120

static

Definition at line 553 of file chan_iax2.c.

Referenced by realtime_peer(), and set_config().

globalflags

struct ast_flags64 globalflags = { 0 }

static

Definition at line 506 of file chan_iax2.c.

Referenced by __expire_registry(), __find_callno(), build_peer(), build_user(), check_access(), iax2_request(), iax2_trunk_queue(), realtime_peer(), realtime_update_peer(), realtime_user(), send_trunk(), set_config(), set_config_destroy(), socket_process_helper(), and update_registry().

iax2_authmethods

int iax2_authmethods = 0

static

Definition at line 504 of file chan_iax2.c.

Referenced by build_peer(), build_user(), iax2_call(), and set_config().

iax2_capability

iax2_format iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH

static

Definition at line 483 of file chan_iax2.c.

Referenced by build_peer(), build_user(), iax2_request(), and set_config().

iax2_encryption

int iax2_encryption = 0

static

Definition at line 503 of file chan_iax2.c.

Referenced by build_peer(), build_user(), iax2_call(), and set_config().

iax2_regfunk

int(* iax2_regfunk) (const char *username, int onoff) ( const char *  username, int  onoff  ) = NULL

static

Definition at line 394 of file chan_iax2.c.

Referenced by __expire_registry(), reg_source_db(), and update_registry().

iax2_switch

struct ast_switch iax2_switch

static

Definition at line 14755 of file chan_iax2.c.

Referenced by __unload_module(), and load_module().

iax2_tech

struct ast_channel_tech iax2_tech

static

Definition at line 1366 of file chan_iax2.c.

Referenced by __unload_module(), acf_channel_read(), ast_iax2_new(), function_iaxpeer(), iax2_prov_app(), and load_module().

iax2_variable_datastore_info

const struct ast_datastore_info iax2_variable_datastore_info

static

Initial value:

= {
    .type = "IAX2_VARIABLE",
    .duplicate = iax2_dup_variable_datastore,
    .destroy = iax2_free_variable_datastore,
}

Definition at line 1595 of file chan_iax2.c.

Referenced by acf_iaxvar_read(), acf_iaxvar_write(), ast_iax2_new(), authenticate_reply(), iax2_call(), and socket_process_helper().

iax_peercallno_pvts

struct ao2_container* iax_peercallno_pvts

static

Another container of iax2_pvt structures.

Active IAX2 pvt structs are also stored in this container, if they are a part of an active call where we know the remote side's call number. The reason for this is that incoming media frames do not contain our call number. So, instead of having to iterate the entire iaxs array, we use this container to look up calls where the remote side is using a given call number.

Definition at line 1227 of file chan_iax2.c.

Referenced by __find_callno(), __unload_module(), load_objects(), remove_by_peercallno(), and store_by_peercallno().

iax_transfercallno_pvts

struct ao2_container* iax_transfercallno_pvts

static

Another container of iax2_pvt structures.

Active IAX2 pvt structs used during transferring a call are stored here.

Definition at line 1243 of file chan_iax2.c.

Referenced by __find_callno(), __unload_module(), load_objects(), remove_by_transfercallno(), and store_by_transfercallno().

iaxactivethreadcount

int iaxactivethreadcount = 0

static

Definition at line 748 of file chan_iax2.c.

Referenced by iax2_process_thread(), and iax2_process_thread_cleanup().

iaxcompat

int iaxcompat = 0

static

Definition at line 371 of file chan_iax2.c.

Referenced by set_config(), and socket_process_helper().

iaxdebug

int iaxdebug = 0

static

Definition at line 485 of file chan_iax2.c.

Referenced by __find_callno(), calc_rxstamp(), calc_timestamp(), decode_frame(), encrypt_frame(), handle_cli_iax2_set_debug(), iax2_call(), iax2_do_register(), iax2_indicate(), iax_debug_output(), iax_outputframe(), send_packet(), socket_process_helper(), and unwrap_timestamp().

iaxdefaultdpcache

int iaxdefaultdpcache =10 * 60

static

Definition at line 374 of file chan_iax2.c.

Referenced by complete_dpreply(), dp_lookup(), and find_cache().

iaxdefaulttimeout

int iaxdefaulttimeout = 5

static

Definition at line 376 of file chan_iax2.c.

Referenced by find_cache().

iaxdynamicthreadcount

int iaxdynamicthreadcount = 0

static

Definition at line 746 of file chan_iax2.c.

Referenced by find_idle_thread(), and iax2_process_thread().

iaxdynamicthreadnum

int iaxdynamicthreadnum = 0

static

Definition at line 747 of file chan_iax2.c.

Referenced by find_idle_thread().

iaxmaxthreadcount

int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT

static

Definition at line 745 of file chan_iax2.c.

Referenced by find_idle_thread(), and set_config().

iaxpeer_function

struct ast_custom_function iaxpeer_function

static

Initial value:

= {
    .name = "IAXPEER",
    .read = function_iaxpeer,
}

Definition at line 14674 of file chan_iax2.c.

Referenced by load_module(), and unload_module().

iaxs

struct chan_iax2_pvt* iaxs[IAX_MAX_CALLS]

static

an array of iax2 pvt structures

The container for active chan_iax2_pvt structures is implemented as an array for extremely quick direct access to the correct pvt structure based on the local call number. The local call number is used as the index into the array where the associated pvt structure is stored.

Definition at line 1198 of file chan_iax2.c.

Referenced by __attempt_transmit(), __auth_reject(), __auto_congest(), __auto_hangup(), __do_deliver(), __find_callno(), __get_from_jb(), __send_lagrq(), __send_ping(), __unload_module(), acf_channel_read(), ast_cli_netstats(), ast_iax2_new(), auth_fail(), auth_reject(), authenticate_reply(), authenticate_request(), auto_hangup(), cache_get_callno_locked(), calc_timestamp(), check_access(), complete_transfer(), decrypt_frame(), delete_users(), dp_lookup(), find_cache(), fix_peerts(), function_iaxpeer(), handle_cli_iax2_show_channels(), iax2_ack_registry(), iax2_call(), iax2_destroy(), iax2_do_register(), iax2_dprequest(), iax2_fixup(), iax2_hangup(), iax2_indicate(), iax2_lock_callno_unless_destroyed(), iax2_lock_owner(), iax2_poke_peer(), iax2_predestroy(), iax2_prov_app(), iax2_provision(), iax2_queryoption(), iax2_queue_frame(), iax2_queue_hangup(), iax2_queue_hold(), iax2_queue_unhold(), iax2_request(), iax2_setoption(), iax2_vnak(), iax2_write(), iax_pvt_callid_get(), iax_pvt_callid_set(), load_module(), log_jitterstats(), make_trunk(), register_verify(), registry_authrequest(), registry_rerequest(), resend_with_token(), save_osptoken(), save_rr(), schedule_delivery(), scheduled_destroy(), send_command_final(), send_command_locked(), send_packet(), set_hangup_source_and_cause(), socket_process_helper(), socket_process_meta(), stop_stuff(), transmit_frame(), unwrap_timestamp(), update_packet(), update_registry(), and wait_for_peercallno().

iaxsl

ast_mutex_t iaxsl[ARRAY_LEN(iaxs)]

static

chan_iax2_pvt structure locks

These locks are used when accessing a pvt structure in the iaxs array. The index used here is the same as used in the iaxs array. It is the local call number for the associated pvt struct.

Definition at line 1236 of file chan_iax2.c.

Referenced by __attempt_transmit(), __auth_reject(), __auto_congest(), __auto_hangup(), __find_callno(), __get_from_jb(), __iax2_poke_noanswer(), __send_lagrq(), __send_ping(), __unload_module(), acf_channel_read(), ast_cli_netstats(), ast_iax2_new(), auth_reject(), authenticate_reply(), auto_hangup(), cache_get_callno_locked(), delete_users(), dp_lookup(), find_cache(), handle_cli_iax2_show_channels(), handle_cli_iax2_show_stats(), iax2_call(), iax2_destroy(), iax2_do_register(), iax2_fixup(), iax2_hangup(), iax2_indicate(), iax2_key_rotate(), iax2_lock_callno_unless_destroyed(), iax2_lock_owner(), iax2_poke_peer(), iax2_provision(), iax2_queryoption(), iax2_request(), iax2_setoption(), iax2_write(), load_module(), log_jitterstats(), make_trunk(), peer_destructor(), pvt_destructor(), register_verify(), registry_authrequest(), scheduled_destroy(), send_command_locked(), set_hangup_source_and_cause(), socket_process_helper(), socket_process_meta(), transmit_frame(), update_registry(), and wait_for_peercallno().

iaxthreadcount

int iaxthreadcount = DEFAULT_THREAD_COUNT

static

Definition at line 744 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_threads(), set_config(), and start_network_thread().

iaxtrunkdebug

int iaxtrunkdebug = 0

static

Definition at line 487 of file chan_iax2.c.

Referenced by handle_cli_iax2_set_debug_trunk(), and timing_read().

iaxvar_function

struct ast_custom_function iaxvar_function

static

Initial value:

= {
    .name = "IAXVAR",
    .read = acf_iaxvar_read,
    .write = acf_iaxvar_write,
}

Definition at line 10238 of file chan_iax2.c.

Referenced by load_module(), and unload_module().

idle_list

struct idle_list idle_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

io

struct io_context* io

static

Definition at line 480 of file chan_iax2.c.

Referenced by load_module(), network_thread(), peer_set_srcaddr(), and set_config().

jittertargetextra

int jittertargetextra = 40

static

Definition at line 362 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

lagrq_time

int lagrq_time = 10

static

Definition at line 358 of file chan_iax2.c.

Referenced by __find_callno(), __send_lagrq(), make_trunk(), and set_config().

language

char language[MAX_LANGUAGE] = ""

static

Definition at line 348 of file chan_iax2.c.

Referenced by add_format_information_cb(), ari_bridges_play_helper(), ari_channels_handle_play(), ast_res_pjsip_initialize_configuration(), ast_say_enumeration(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_enumeration_full_en(), ast_say_enumeration_full_he(), ast_say_enumeration_full_is(), ast_say_enumeration_full_vi(), ast_say_number(), ast_say_number_full_cs(), ast_say_number_full_da(), ast_say_number_full_de(), ast_say_number_full_en(), ast_say_number_full_en_GB(), ast_say_number_full_es(), ast_say_number_full_fr(), ast_say_number_full_gr(), ast_say_number_full_he(), ast_say_number_full_hu(), ast_say_number_full_is(), ast_say_number_full_it(), ast_say_number_full_ja(), ast_say_number_full_ka(), ast_say_number_full_nl(), ast_say_number_full_no(), ast_say_number_full_pl(), ast_say_number_full_pt(), ast_say_number_full_ru(), ast_say_number_full_se(), ast_say_number_full_th(), ast_say_number_full_ur(), ast_say_number_full_vi(), ast_say_number_full_zh(), ast_say_ordinal(), build_user(), channel_snapshot_base_create(), check_access(), conf_load_config(), func_channel_write_real(), load_module(), pl_odtworz_plik(), powiedz(), say_and_wait(), say_enumeration_full(), say_number_full(), say_ordinal_full(), set_config(), set_config_destroy(), set_pvt_defaults(), show_sound_info_cb(), stasis_app_control_play_uri(), store_config_core(), tds_load_module(), and xmldoc_get_node().

last

struct iax_frame* last

Definition at line 1005 of file chan_iax2.c.

Referenced by vnak_retransmit().

last_authmethod

int last_authmethod = 0

static

Definition at line 372 of file chan_iax2.c.

Referenced by check_access(), register_verify(), and registry_authrequest().

max_calltoken_delay

time_t max_calltoken_delay = 10

static

Definition at line 1011 of file chan_iax2.c.

Referenced by handle_call_token(), and set_config().

max_reg_expire

int max_reg_expire

static

Definition at line 384 of file chan_iax2.c.

Referenced by set_config(), and update_registry().

max_retries

int max_retries = 4

static

Definition at line 356 of file chan_iax2.c.

Referenced by __attempt_transmit(), and load_module().

maxauthreq

int maxauthreq = 3

static

Definition at line 355 of file chan_iax2.c.

Referenced by build_user(), and set_config().

maxjitterbuffer

int maxjitterbuffer =1000

static

Definition at line 359 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

maxjitterinterps

int maxjitterinterps =10

static

Definition at line 361 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

min_reg_expire

int min_reg_expire

static

Definition at line 383 of file chan_iax2.c.

Referenced by __expire_registry(), __find_callno(), build_peer(), set_config(), and update_registry().

mohinterpret

char mohinterpret[MAX_MUSICCLASS]

static

Definition at line 498 of file chan_iax2.c.

Referenced by __find_callno(), build_peer(), build_user(), check_access(), iax2_call(), set_config(), set_config_destroy(), set_pvt_defaults(), and store_config_core().

mohsuggest

char mohsuggest[MAX_MUSICCLASS]

static

Definition at line 499 of file chan_iax2.c.

Referenced by __find_callno(), ast_res_pjsip_initialize_configuration(), build_peer(), build_user(), check_access(), iax2_call(), set_config(), and set_config_destroy().

netsock

struct ast_netsock_list* netsock

static

Definition at line 390 of file chan_iax2.c.

Referenced by __unload_module(), ast_netsock_destroy(), load_module(), peer_set_srcaddr(), and set_config().

netthreadid

pthread_t netthreadid = AST_PTHREADT_NULL

static

Definition at line 508 of file chan_iax2.c.

Referenced by __unload_module(), and start_network_thread().

network_change_sched_id

int network_change_sched_id = -1

static

Definition at line 353 of file chan_iax2.c.

Referenced by network_change_sched_cb(), and network_change_stasis_cb().

network_change_sub

struct stasis_subscription* network_change_sub

static

subscription id for network change events

Definition at line 351 of file chan_iax2.c.

Referenced by network_change_stasis_subscribe(), and network_change_stasis_unsubscribe().

outsock

struct ast_netsock_list* outsock

static

used if sourceaddress specified and bindaddr == INADDR_ANY

Definition at line 391 of file chan_iax2.c.

Referenced by __unload_module(), load_module(), peer_set_srcaddr(), and set_config().

papp

char* papp = "IAX2Provision"

static

Definition at line 12462 of file chan_iax2.c.

Referenced by __unload_module(), and load_module().

peercnts

struct ao2_container* peercnts

static

Table containing peercnt objects for every ip address consuming a callno

Definition at line 1031 of file chan_iax2.c.

Referenced by __unload_module(), handle_cli_iax2_show_callno_limits(), load_objects(), peercnt_add(), peercnt_modify(), peercnt_remove(), peercnt_remove_by_addr(), reload_config(), and sched_delay_remove().

peers

struct ao2_container* peers

static

Definition at line 1025 of file chan_iax2.c.

ping_time

int ping_time = 21

static

Definition at line 357 of file chan_iax2.c.

Referenced by __find_callno(), __send_ping(), make_trunk(), and set_config().

prefs_global

struct iax2_codec_pref prefs_global

static

Definition at line 332 of file chan_iax2.c.

Referenced by build_peer(), build_user(), create_addr(), new_iax(), and set_config().

struct { ... } qos

Referenced by peer_set_srcaddr(), set_config(), and set_qos().

randomcalltokendata

int randomcalltokendata

static

Definition at line 1009 of file chan_iax2.c.

Referenced by handle_call_token(), and load_module().

regcontext

char regcontext[AST_MAX_CONTEXT] = ""

static

Definition at line 349 of file chan_iax2.c.

Referenced by __unload_module(), add_to_regcontext(), ast_sip_initialize_sorcery_global(), ast_sip_persistent_endpoint_add_to_regcontext(), ast_sip_persistent_endpoint_update_state(), conf_load_config(), register_peer_exten(), and set_config().

registrations

struct registrations registrations = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

Referenced by cli_complete_registration(), and get_registrations().

resyncthreshold

int resyncthreshold =1000

static

Definition at line 360 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

sched

struct ast_sched_context* sched

static

Definition at line 481 of file chan_iax2.c.

srvlookup

int srvlookup = 0

static

Definition at line 386 of file chan_iax2.c.

Referenced by __iax2_do_register_s(), build_peer(), create_addr(), iax2_append_register(), and set_config().

tdesc

const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)"

static

Definition at line 334 of file chan_iax2.c.

test_losspct

int test_losspct = 0

static

Definition at line 489 of file chan_iax2.c.

Referenced by handle_cli_iax2_test_losspct(), and socket_read().

timer

struct ast_timer* timer

static

Definition at line 388 of file chan_iax2.c.

Referenced by __ast_channel_alloc_ap(), __unload_module(), ack_ticks(), ast_bridge_features_init(), ast_sip_session_create_outgoing(), build_peer(), build_user(), check_timer(), dahdi_timer_ack(), dahdi_timer_close(), dahdi_timer_disable_continuous(), dahdi_timer_enable_continuous(), dahdi_timer_fd(), dahdi_timer_get_event(), dahdi_timer_open(), dahdi_timer_set_rate(), kqueue_timer_ack(), kqueue_timer_close(), kqueue_timer_disable_continuous(), kqueue_timer_disable_continuous_event(), kqueue_timer_enable_continuous(), kqueue_timer_enable_continuous_event(), kqueue_timer_fd(), kqueue_timer_fini_continuous_event(), kqueue_timer_get_event(), kqueue_timer_init_continuous_event(), kqueue_timer_open(), kqueue_timer_set_rate(), load_module(), network_thread(), new_invite(), process_dahdi(), pthread_timer_ack(), pthread_timer_close(), pthread_timer_destructor(), pthread_timer_disable_continuous(), pthread_timer_enable_continuous(), pthread_timer_fd(), pthread_timer_get_event(), pthread_timer_hash(), pthread_timer_open(), pthread_timer_set_rate(), run_timer(), set_config(), signal_pipe(), softmix_mixing_loop(), timer_destroy(), timerfd_timer_ack(), timerfd_timer_disable_continuous(), timerfd_timer_enable_continuous(), timerfd_timer_fd(), timerfd_timer_get_event(), timerfd_timer_open(), timerfd_timer_set_rate(), timing_read(), timing_test(), and unsignal_pipe().

tos

unsigned int tos

Definition at line 379 of file chan_iax2.c.

Referenced by ast_netsock_bind(), ast_netsock_bindaddr(), ast_netsock_set_qos(), ast_rtp_instance_set_qos(), ast_rtp_qos_set(), ast_set_qos(), ast_str2tos(), ast_tos2str(), and ast_udptl_setqos().

total_nonval_callno_used

uint16_t total_nonval_callno_used = 0

static

Definition at line 1048 of file chan_iax2.c.

Referenced by get_unused_callno(), handle_cli_iax2_show_callno_limits(), and replace_callno().

tpeers

struct tpeers tpeers = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

transmit_processor

struct ast_taskprocessor* transmit_processor

static

Definition at line 1007 of file chan_iax2.c.

Referenced by __unload_module(), iax2_transmit(), and load_objects().

trunk_maxmtu

int trunk_maxmtu

static

Definition at line 342 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_stats(), iax2_trunk_queue(), and reload_config().

trunk_nmaxmtu

int trunk_nmaxmtu

static

Trunk MTU statistics

Definition at line 342 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_stats(), and reload_config().

trunk_timed

int trunk_timed

static

Definition at line 342 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_stats(), reload_config(), and timing_read().

trunk_untimed

int trunk_untimed

static

Definition at line 342 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_stats(), iax2_trunk_queue(), and reload_config().

trunkfreq

int trunkfreq = 20

static

Definition at line 366 of file chan_iax2.c.

Referenced by load_module(), send_trunk(), and set_config().

trunkmaxsize

int trunkmaxsize = MAX_TRUNKDATA

static

Definition at line 367 of file chan_iax2.c.

Referenced by iax2_trunk_queue(), set_config(), set_config_destroy(), and timing_read().

users

struct ao2_container* users

static

Definition at line 1028 of file chan_iax2.c.