Asterisk - The Open Source Telephony Project GIT-master-6144b6b
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
chan_iax2.c File Reference
Module: Asterisk Channel Drivers

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.
 
#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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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
 
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 —.
 
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.
 
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.
 
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
 
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.
 
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.
 
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.
 
static int iax2_queue_hangup (int callno)
 Queue a hangup frame on the ast_channel owner.
 
static int iax2_queue_hold (int callno, const char *musicclass)
 Queue a hold frame on the ast_channel owner.
 
static int iax2_queue_unhold (int callno)
 Queue an unhold frame on the ast_channel owner.
 
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.
 
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
 
static int manager_iax2_show_peers (struct mansession *s, const struct message *m)
 callback to display iax peers in manager
 
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.
 
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.
 
static int peer_status (struct iax2_peer *peer, char *status, int statuslen)
 peer_status: Report Peer status in character string
 
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.
 
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.
 
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.
 
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.
 
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 = ASTERISK_GPL_KEY , .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 = AST_LIST_HEAD_INIT_VALUE
 
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.
 
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 = AST_MUTEX_INIT_VALUE
 
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 = AST_LIST_HEAD_INIT_VALUE
 
static struct dynamic_list dynamic_list = AST_LIST_HEAD_INIT_VALUE
 
struct { 
 
   struct iax_frame *   first 
 
   struct iax_frame *   last 
 
} frame_queue [IAX_MAX_CALLS] 
 a list of frames that may need to be retransmitted
 
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.
 
static struct ao2_container * iax_transfercallno_pvts
 Another container of iax2_pvt structures.
 
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
 
static ast_mutex_t iaxsl [ARRAY_LEN(iaxs)]
 chan_iax2_pvt structure locks
 
static int iaxthreadcount = DEFAULT_THREAD_COUNT
 
static int iaxtrunkdebug = 0
 
static struct ast_custom_function iaxvar_function
 
static struct idle_list idle_list = AST_LIST_HEAD_INIT_VALUE
 
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 = AST_LIST_HEAD_INIT_VALUE
 
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 = AST_LIST_HEAD_INIT_VALUE
 
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 444 of file chan_iax2.c.

◆ CALLNO_ENTRY_GET_CALLNO

#define CALLNO_ENTRY_GET_CALLNO (   a)    ((a) & 0x7FFF)

Definition at line 993 of file chan_iax2.c.

◆ CALLNO_ENTRY_IS_VALIDATED

#define CALLNO_ENTRY_IS_VALIDATED (   a)    ((a) & 0x8000)

Definition at line 992 of file chan_iax2.c.

◆ CALLNO_ENTRY_SET_VALIDATED

#define CALLNO_ENTRY_SET_VALIDATED (   a)    ((a) |= 0x8000)

Definition at line 991 of file chan_iax2.c.

◆ CALLNO_ENTRY_TO_PTR

#define CALLNO_ENTRY_TO_PTR (   a)    ((void *)(unsigned long)(a))

Definition at line 989 of file chan_iax2.c.

◆ CALLNO_TO_PTR

#define CALLNO_TO_PTR (   a)    ((void *)(unsigned long)(a))

Definition at line 330 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 322 of file chan_iax2.c.

◆ DEBUG_SUPPORT

#define DEBUG_SUPPORT

Definition at line 338 of file chan_iax2.c.

◆ DEFAULT_CONTEXT

#define DEFAULT_CONTEXT   "default"

Definition at line 357 of file chan_iax2.c.

◆ DEFAULT_DROP

#define DEFAULT_DROP   3

Definition at line 336 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 433 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 432 of file chan_iax2.c.

◆ DEFAULT_MAX_THREAD_COUNT

#define DEFAULT_MAX_THREAD_COUNT   100

Definition at line 333 of file chan_iax2.c.

◆ DEFAULT_MAXMS

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

Definition at line 431 of file chan_iax2.c.

◆ DEFAULT_RETRY_TIME

#define DEFAULT_RETRY_TIME   1000

Definition at line 334 of file chan_iax2.c.

◆ DEFAULT_THREAD_COUNT

#define DEFAULT_THREAD_COUNT   10

Definition at line 332 of file chan_iax2.c.

◆ DEFAULT_TRUNKDATA

#define DEFAULT_TRUNKDATA   640 * 10

40ms, uncompressed linear * 10 channels

Definition at line 747 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 343 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 675 of file chan_iax2.c.

◆ IAX_ALLOWFWDOWNLOAD

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

Allow the FWDOWNL command?

Definition at line 560 of file chan_iax2.c.

◆ IAX_ALREADYGONE

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

Already disconnected

Definition at line 544 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 477 of file chan_iax2.c.

479 { \
480 int idx; \
481 char digest[33] = ""; \
482 \
483 if (!iaxdebug) \
484 break; \
485 \
486 for (idx = 0; idx < 16; idx++) \
487 sprintf(digest + (idx << 1), "%02hhx", (unsigned char) key[idx]); \
488 \
489 ast_log(LOG_NOTICE, msg " IAX_COMMAND_RTKEY to rotate key to '%s'\n", digest); \
490 } while(0)
491
492static struct io_context *io;
493static struct ast_sched_context *sched;
494
495static iax2_format iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
496
497static int iaxdebug = 0;
498
499static int iaxtrunkdebug = 0;
500
501static int test_losspct = 0;
502#ifdef IAXTESTS
503static int test_late = 0;
504static int test_resync = 0;
505static int test_jit = 0;
506static int test_jitpct = 0;
507#endif /* IAXTESTS */
508
509static char accountcode[AST_MAX_ACCOUNT_CODE];
510static char mohinterpret[MAX_MUSICCLASS];
511static char mohsuggest[MAX_MUSICCLASS];
512static int amaflags = 0;
513static int adsi = 0;
514static int delayreject = 0;
515static int iax2_encryption = 0;
516static int iax2_authmethods = 0;
517
518static struct ast_flags64 globalflags = { 0 };
519
520static pthread_t netthreadid = AST_PTHREADT_NULL;
521
522enum iax2_state {
523 IAX_STATE_STARTED = (1 << 0),
524 IAX_STATE_AUTHENTICATED = (1 << 1),
525 IAX_STATE_TBD = (1 << 2),
526};
527
528struct iax2_context {
529 char context[AST_MAX_CONTEXT];
530 struct iax2_context *next;
531};
532
533
534#define IAX_HASCALLERID (uint64_t)(1LLU << 0) /*!< CallerID has been specified */
535#define IAX_DELME (uint64_t)(1LLU << 1) /*!< Needs to be deleted */
536#define IAX_TEMPONLY (uint64_t)(1LLU << 2) /*!< Temporary (realtime) */
537#define IAX_TRUNK (uint64_t)(1LLU << 3) /*!< Treat as a trunk */
538#define IAX_NOTRANSFER (uint64_t)(1LLU << 4) /*!< Don't native bridge */
539#define IAX_USEJITTERBUF (uint64_t)(1LLU << 5) /*!< Use jitter buffer */
540#define IAX_DYNAMIC (uint64_t)(1LLU << 6) /*!< dynamic peer */
541#define IAX_SENDANI (uint64_t)(1LLU << 7) /*!< Send ANI along with CallerID */
542#define IAX_RTSAVE_SYSNAME (uint64_t)(1LLU << 8) /*!< Save Systname on Realtime Updates */
543#define IAX_ALREADYGONE (uint64_t)(1LLU << 9) /*!< Already disconnected */
544#define IAX_PROVISION (uint64_t)(1LLU << 10) /*!< This is a provisioning request */
545#define IAX_QUELCH (uint64_t)(1LLU << 11) /*!< Whether or not we quelch audio */
546#define IAX_ENCRYPTED (uint64_t)(1LLU << 12) /*!< Whether we should assume encrypted tx/rx */
547#define IAX_KEYPOPULATED (uint64_t)(1LLU << 13) /*!< Whether we have a key populated */
548#define IAX_CODEC_USER_FIRST (uint64_t)(1LLU << 14) /*!< are we willing to let the other guy choose the codec? */
549#define IAX_CODEC_NOPREFS (uint64_t)(1LLU << 15) /*!< Force old behaviour by turning off prefs */
550#define IAX_CODEC_NOCAP (uint64_t)(1LLU << 16) /*!< only consider requested format and ignore capabilities*/
551#define IAX_RTCACHEFRIENDS (uint64_t)(1LLU << 17) /*!< let realtime stay till your reload */
552#define IAX_RTUPDATE (uint64_t)(1LLU << 18) /*!< Send a realtime update */
553#define IAX_RTAUTOCLEAR (uint64_t)(1LLU << 19) /*!< erase me on expire */
554#define IAX_RTIGNOREREGEXPIRE (uint64_t)(1LLU << 21) /*!< When using realtime, ignore registration expiration */
555#define IAX_TRUNKTIMESTAMPS (uint64_t)(1LLU << 22) /*!< Send trunk timestamps */
556#define IAX_TRANSFERMEDIA (uint64_t)(1LLU << 23) /*!< When doing IAX2 transfers, transfer media only */
557#define IAX_MAXAUTHREQ (uint64_t)(1LLU << 24) /*!< Maximum outstanding AUTHREQ restriction is in place */
558#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 */
559#define IAX_ALLOWFWDOWNLOAD (uint64_t)(1LLU << 26) /*!< Allow the FWDOWNL command? */
560#define IAX_IMMEDIATE (uint64_t)(1LLU << 27) /*!< Allow immediate off-hook to extension s */
561#define IAX_SENDCONNECTEDLINE (uint64_t)(1LLU << 28) /*!< Allow sending of connected line updates */
562#define IAX_RECVCONNECTEDLINE (uint64_t)(1LLU << 29) /*!< Allow receiving of connected line updates */
563#define IAX_FORCE_ENCRYPT (uint64_t)(1LLU << 30) /*!< Forces call encryption, if encryption not possible hangup */
564#define IAX_SHRINKCALLERID (uint64_t)(1LLU << 31) /*!< Turn on and off caller id shrinking */
565static int global_rtautoclear = 120;
566
567static int reload_config(int forced_reload);
568
569/*!
570 * \brief Call token validation settings.
571 */
572enum calltoken_peer_enum {
573 /*! \brief Default calltoken required unless the ip is in the ignorelist */
574 CALLTOKEN_DEFAULT = 0,
575 /*! \brief Require call token validation. */
576 CALLTOKEN_YES = 1,
577 /*! \brief Require call token validation after a successful registration
578 * using call token validation occurs. */
579 CALLTOKEN_AUTO = 2,
580 /*! \brief Do not require call token validation. */
581 CALLTOKEN_NO = 3,
582};
583
584struct iax2_user {
585 AST_DECLARE_STRING_FIELDS(
586 AST_STRING_FIELD(name);
587 AST_STRING_FIELD(secret);
588 AST_STRING_FIELD(dbsecret);
589 AST_STRING_FIELD(accountcode);
590 AST_STRING_FIELD(mohinterpret);
591 AST_STRING_FIELD(mohsuggest);
592 AST_STRING_FIELD(inkeys); /*!< Key(s) this user can use to authenticate to us */
593 AST_STRING_FIELD(language);
594 AST_STRING_FIELD(cid_num);
595 AST_STRING_FIELD(cid_name);
596 AST_STRING_FIELD(parkinglot); /*!< Default parkinglot for device */
597 );
598
599 int authmethods;
600 int encmethods;
601 int amaflags;
602 int adsi;
603 uint64_t flags;
604 iax2_format capability;
605 int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
606 int curauthreq; /*!< Current number of outstanding AUTHREQs */
607 struct iax2_codec_pref prefs;
608 struct ast_acl_list *acl;
609 struct iax2_context *contexts;
610 struct ast_variable *vars;
611 enum calltoken_peer_enum calltoken_required; /*!< Is calltoken validation required or not, can be YES, NO, or AUTO */
612};
613
614struct iax2_peer {
615 AST_DECLARE_STRING_FIELDS(
616 AST_STRING_FIELD(name);
617 AST_STRING_FIELD(username);
618 AST_STRING_FIELD(description); /*!< Description of the peer */
619 AST_STRING_FIELD(secret);
620 AST_STRING_FIELD(dbsecret);
621 AST_STRING_FIELD(outkey); /*!< What key we use to talk to this peer */
622
623 AST_STRING_FIELD(regexten); /*!< Extension to register (if regcontext is used) */
624 AST_STRING_FIELD(context); /*!< For transfers only */
625 AST_STRING_FIELD(peercontext); /*!< Context to pass to peer */
626 AST_STRING_FIELD(mailbox); /*!< Mailbox */
627 AST_STRING_FIELD(mohinterpret);
628 AST_STRING_FIELD(mohsuggest);
629 AST_STRING_FIELD(inkeys); /*!< Key(s) this peer can use to authenticate to us */
630 /* Suggested caller id if registering */
631 AST_STRING_FIELD(cid_num); /*!< Default context (for transfer really) */
632 AST_STRING_FIELD(cid_name); /*!< Default context (for transfer really) */
633 AST_STRING_FIELD(zonetag); /*!< Time Zone */
634 AST_STRING_FIELD(parkinglot); /*!< Default parkinglot for device */
635 );
636 struct iax2_codec_pref prefs;
637 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
638 struct ast_sockaddr addr;
639 int formats;
640 int sockfd; /*!< Socket to use for transmission */
641 struct ast_sockaddr mask;
642 int adsi;
643 uint64_t flags;
644
645 /* Dynamic Registration fields */
646 struct ast_sockaddr defaddr; /*!< Default address if there is one */
647 int authmethods; /*!< Authentication methods (IAX_AUTH_*) */
648 int encmethods; /*!< Encryption methods (IAX_ENCRYPT_*) */
649
650 int expire; /*!< Schedule entry for expiry */
651 int expiry; /*!< How soon to expire */
652 iax2_format capability; /*!< Capability */
653
654 /* Qualification */
655 int callno; /*!< Call number of POKE request */
656 int pokeexpire; /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
657 int lastms; /*!< How long last response took (in ms), or -1 for no response */
658 int maxms; /*!< Max ms we will accept for the host to be up, 0 to not monitor */
659
660 int pokefreqok; /*!< How often to check if the host is up */
661 int pokefreqnotok; /*!< How often to check when the host has been determined to be down */
662 int historicms; /*!< How long recent average responses took */
663 int smoothing; /*!< Sample over how many units to determine historic ms */
664 uint16_t maxcallno; /*!< Max call number limit for this peer. Set on registration */
665
666 struct ast_mwi_subscriber *mwi_event_sub; /*!< This subscription lets pollmailboxes know which mailboxes need to be polled */
667
668 struct ast_acl_list *acl;
669 enum calltoken_peer_enum calltoken_required; /*!< Is calltoken validation required or not, can be YES, NO, or AUTO */
670
671 struct ast_endpoint *endpoint; /*!< Endpoint structure for this peer */
672};
673
674#define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
675
676struct iax2_trunk_peer {
677 ast_mutex_t lock;
678 int sockfd;
679 struct ast_sockaddr addr;
680 struct timeval txtrunktime; /*!< Transmit trunktime */
681 struct timeval rxtrunktime; /*!< Receive trunktime */
682 struct timeval lasttxtime; /*!< Last transmitted trunktime */
683 struct timeval trunkact; /*!< Last trunk activity */
684 unsigned int lastsent; /*!< Last sent time */
685 /* Trunk data and length */
686 unsigned char *trunkdata;
687 unsigned int trunkdatalen;
688 unsigned int trunkdataalloc;
689 int trunkmaxmtu;
690 int trunkerror;
691 int calls;
692 AST_LIST_ENTRY(iax2_trunk_peer) list;
693};
694
695static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
696
697enum iax_reg_state {
698 REG_STATE_UNREGISTERED = 0,
699 REG_STATE_REGSENT,
700 REG_STATE_AUTHSENT,
701 REG_STATE_REGISTERED,
702 REG_STATE_REJECTED,
703 REG_STATE_TIMEOUT,
704 REG_STATE_NOAUTH
705};
706
707enum iax_transfer_state {
708 TRANSFER_NONE = 0,
709 TRANSFER_BEGIN,
710 TRANSFER_READY,
711 TRANSFER_RELEASED,
712 TRANSFER_PASSTHROUGH,
713 TRANSFER_MBEGIN,
714 TRANSFER_MREADY,
715 TRANSFER_MRELEASED,
716 TRANSFER_MPASSTHROUGH,
717 TRANSFER_MEDIA,
718 TRANSFER_MEDIAPASS
719};
720
721struct iax2_registry {
722 struct ast_sockaddr addr; /*!< Who we connect to for registration purposes */
723 char username[80];
724 char secret[80]; /*!< Password or key name in []'s */
725 int expire; /*!< Sched ID of expiration */
726 int refresh; /*!< How often to refresh */
727 enum iax_reg_state regstate;
728 int messages; /*!< Message count, low 8 bits = new, high 8 bits = old */
729 int callno; /*!< Associated call number if applicable */
730 struct ast_sockaddr us; /*!< Who the server thinks we are */
731 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
732 AST_LIST_ENTRY(iax2_registry) entry;
733 int port;
734 char hostname[];
735};
736
737static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
738
739/* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
740#define MIN_RETRY_TIME 100
741#define MAX_RETRY_TIME 10000
742
743#define MAX_JITTER_BUFFER 50
744#define MIN_JITTER_BUFFER 10
745
746#define DEFAULT_TRUNKDATA 640 * 10 /*!< 40ms, uncompressed linear * 10 channels */
747
748#define MAX_TIMESTAMP_SKEW 160 /*!< maximum difference between actual and predicted ts for sending */
749
750/* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
751#define TS_GAP_FOR_JB_RESYNC 5000
752
753/* used for first_iax_message and last_iax_message. If this bit is set it was TX, else RX */
754#define MARK_IAX_SUBCLASS_TX 0x8000
755
756static int iaxthreadcount = DEFAULT_THREAD_COUNT;
757static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
758static int iaxdynamicthreadcount = 0;
759static int iaxdynamicthreadnum = 0;
760static int iaxactivethreadcount = 0;
761
762struct iax_rr {
763 int jitter;
764 int losspct;
765 int losscnt;
766 int packets;
767 int delay;
768 int dropped;
769 int ooo;
770};
771
772struct iax2_pvt_ref;
773
774/* We use the high order bit as the validated flag, and the lower 15 as the
775 * actual call number */
776typedef uint16_t callno_entry;
777
778struct chan_iax2_pvt {
779 /*! Socket to send/receive on for this call */
780 int sockfd;
781 /*! ast_callid bound to dialog */
782 ast_callid callid;
783 /*! Last received voice format */
784 iax2_format voiceformat;
785 /*! Last received video format */
786 iax2_format videoformat;
787 /*! Last sent voice format */
788 iax2_format svoiceformat;
789 /*! Last sent video format */
790 iax2_format svideoformat;
791 /*! What we are capable of sending */
792 iax2_format capability;
793 /*! Last received timestamp */
794 unsigned int last;
795 /*! Last sent timestamp - never send the same timestamp twice in a single call */
796 unsigned int lastsent;
797 /*! Timestamp of the last video frame sent */
798 unsigned int lastvsent;
799 /*! Next outgoing timestamp if everything is good */
800 unsigned int nextpred;
801 /*! iax frame subclass that began iax2_pvt entry. 0x8000 bit is set on TX */
802 int first_iax_message;
803 /*! Last iax frame subclass sent or received for a iax2_pvt. 0x8000 bit is set on TX */
804 int last_iax_message;
805 /*! True if the last voice we transmitted was not silence/CNG */
806 unsigned int notsilenttx:1;
807 /*! Ping time */
808 unsigned int pingtime;
809 /*! Max time for initial response */
810 int maxtime;
811 /*! Peer Address */
812 struct ast_sockaddr addr;
813 /*! Actual used codec preferences */
814 struct iax2_codec_pref prefs;
815 /*! Requested codec preferences */
816 struct iax2_codec_pref rprefs;
817 /*! Our call number */
818 unsigned short callno;
819 /*! Our callno_entry entry */
820 callno_entry callno_entry;
821 /*! Peer callno */
822 unsigned short peercallno;
823 /*! Negotiated format, this is only used to remember what format was
824 chosen for an unauthenticated call so that the channel can get
825 created later using the right format. We also use it for
826 authenticated calls to check the format from __get_from_jb. */
827 iax2_format chosenformat;
828 /*! Peer selected format */
829 iax2_format peerformat;
830 /*! Peer capability */
831 iax2_format peercapability;
832 /*! timeval that we base our transmission on */
833 struct timeval offset;
834 /*! timeval that we base our delivery on */
835 struct timeval rxcore;
836 /*! The jitterbuffer */
837 jitterbuf *jb;
838 /*! active jb read scheduler id */
839 int jbid;
840 /*! LAG */
841 int lag;
842 /*! Error, as discovered by the manager */
843 int error;
844 /*! Owner if we have one */
845 struct ast_channel *owner;
846 /*! What's our state? */
847 struct ast_flags state;
848 /*! Expiry (optional) */
849 int expiry;
850 /*! Next outgoing sequence number */
851 unsigned char oseqno;
852 /*! Next sequence number they have not yet acknowledged */
853 unsigned char rseqno;
854 /*! Next incoming sequence number */
855 unsigned char iseqno;
856 /*! Last incoming sequence number we have acknowledged */
857 unsigned char aseqno;
858
859 AST_DECLARE_STRING_FIELDS(
860 /*! Peer name */
861 AST_STRING_FIELD(peer);
862 /*! Default Context */
863 AST_STRING_FIELD(context);
864 /*! Caller ID if available */
865 AST_STRING_FIELD(cid_num);
866 AST_STRING_FIELD(cid_name);
867 /*! Hidden Caller ID (i.e. ANI) if appropriate */
868 AST_STRING_FIELD(ani);
869 /*! DNID */
870 AST_STRING_FIELD(dnid);
871 /*! RDNIS */
872 AST_STRING_FIELD(rdnis);
873 /*! Requested Extension */
874 AST_STRING_FIELD(exten);
875 /*! Expected Username */
876 AST_STRING_FIELD(username);
877 /*! Expected Secret */
878 AST_STRING_FIELD(secret);
879 /*! MD5 challenge */
880 AST_STRING_FIELD(challenge);
881 /*! Public keys permitted keys for incoming authentication */
882 AST_STRING_FIELD(inkeys);
883 /*! Private key for outgoing authentication */
884 AST_STRING_FIELD(outkey);
885 /*! Preferred language */
886 AST_STRING_FIELD(language);
887 /*! Hostname/peername for naming purposes */
888 AST_STRING_FIELD(host);
889
890 AST_STRING_FIELD(dproot);
891 AST_STRING_FIELD(accountcode);
892 AST_STRING_FIELD(mohinterpret);
893 AST_STRING_FIELD(mohsuggest);
894 /*! received OSP token */
895 AST_STRING_FIELD(osptoken);
896 /*! Default parkinglot */
897 AST_STRING_FIELD(parkinglot);
898 );
899 /*! AUTHREJ all AUTHREP frames */
900 int authrej;
901 /*! permitted authentication methods */
902 int authmethods;
903 /*! effective authentication method */
904 int eff_auth_method;
905 /*! permitted encryption methods */
906 int encmethods;
907 /*! Encryption AES-128 Key */
908 ast_aes_encrypt_key ecx;
909 /*! Decryption AES-128 Key corresponding to ecx */
910 ast_aes_decrypt_key mydcx;
911 /*! Decryption AES-128 Key used to decrypt peer frames */
912 ast_aes_decrypt_key dcx;
913 /*! scheduler id associated with iax_key_rotate
914 * for encrypted calls*/
915 int keyrotateid;
916 /*! 32 bytes of semi-random data */
917 unsigned char semirand[32];
918 /*! Associated registry */
919 struct iax2_registry *reg;
920 /*! Associated peer for poking */
921 struct iax2_peer *peerpoke;
922 /*! IAX_ flags */
923 uint64_t flags;
924 int adsi;
925
926 /*! Transferring status */
927 enum iax_transfer_state transferring;
928 /*! Transfer identifier */
929 int transferid;
930 /*! Who we are IAX transferring to */
931 struct ast_sockaddr transfer;
932 /*! What's the new call number for the transfer */
933 unsigned short transfercallno;
934 /*! Transfer encrypt AES-128 Key */
935 ast_aes_encrypt_key tdcx;
936
937 /*! Status of knowledge of peer ADSI capability */
938 int peeradsicpe;
939
940 /*! Callno of native bridge peer. (Valid if nonzero) */
941 unsigned short bridgecallno;
942
943 int pingid; /*!< Transmit PING request */
944 int lagid; /*!< Retransmit lag request */
945 int autoid; /*!< Auto hangup for Dialplan requestor */
946 int authid; /*!< Authentication rejection ID */
947 int authfail; /*!< Reason to report failure */
948 int initid; /*!< Initial peer auto-congest ID (based on qualified peers) */
949 int calling_ton;
950 int calling_tns;
951 int calling_pres;
952 int calling_ani2;
953 int amaflags;
954 AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
955 /*! variables inherited from the user definition */
956 struct ast_variable *vars;
957 /*! variables transmitted in a NEW packet */
958 struct ast_variable *iaxvars;
959 /*! last received remote rr */
960 struct iax_rr remote_rr;
961 /*! Current base time: (just for stats) */
962 int min;
963 /*! Dropped frame count: (just for stats) */
964 int frames_dropped;
965 /*! received frame count: (just for stats) */
966 int frames_received;
967 /*! Destroying this call initiated. */
968 int destroy_initiated;
969 /*! num bytes used for calltoken ie, even an empty ie should contain 2 */
970 unsigned char calltoken_ie_len;
971 /*! hold all signaling frames from the pbx thread until we have a destination callno */
972 char hold_signaling;
973 /*! frame queue for signaling frames from pbx thread waiting for destination callno */
974 AST_LIST_HEAD_NOLOCK(signaling_queue, signaling_queue_entry) signaling_queue;
975};
976
977struct signaling_queue_entry {
978 struct ast_frame f;
979 AST_LIST_ENTRY(signaling_queue_entry) next;
980};
981
982enum callno_type {
983 CALLNO_TYPE_NORMAL,
984 CALLNO_TYPE_TRUNK,
985};
986
987#define PTR_TO_CALLNO_ENTRY(a) ((uint16_t)(unsigned long)(a))
988#define CALLNO_ENTRY_TO_PTR(a) ((void *)(unsigned long)(a))
989
990#define CALLNO_ENTRY_SET_VALIDATED(a) ((a) |= 0x8000)
991#define CALLNO_ENTRY_IS_VALIDATED(a) ((a) & 0x8000)
992#define CALLNO_ENTRY_GET_CALLNO(a) ((a) & 0x7FFF)
993
994struct call_number_pool {
995 size_t capacity;
996 size_t available;
997 callno_entry numbers[IAX_MAX_CALLS / 2 + 1];
998};
999
1000AST_MUTEX_DEFINE_STATIC(callno_pool_lock);
1001
1002/*! table of available call numbers */
1003static struct call_number_pool callno_pool;
1004
1005/*! table of available trunk call numbers */
1006static struct call_number_pool callno_pool_trunk;
1007
1008/*!
1009 * \brief a list of frames that may need to be retransmitted
1010 *
1011 * \note The contents of this list do not need to be explicitly destroyed
1012 * on module unload. This is because all active calls are destroyed, and
1013 * all frames in this queue will get destroyed as a part of that process.
1014 *
1015 * \note Contents protected by the iaxsl[] locks
1016 */
1017static AST_LIST_HEAD_NOLOCK(, iax_frame) frame_queue[IAX_MAX_CALLS];
1018
1019static struct ast_taskprocessor *transmit_processor;
1020
1021static int randomcalltokendata;
1022
1023static time_t max_calltoken_delay = 10;
1024
1025/*!
1026 * This module will get much higher performance when doing a lot of
1027 * user and peer lookups if the number of buckets is increased from 1.
1028 * However, to maintain old behavior for Asterisk 1.4, these are set to
1029 * 1 by default. When using multiple buckets, search order through these
1030 * containers is considered random, so you will not be able to depend on
1031 * the order the entries are specified in iax.conf for matching order. */
1032#ifdef LOW_MEMORY
1033#define MAX_PEER_BUCKETS 17
1034#else
1035#define MAX_PEER_BUCKETS 563
1036#endif
1037static struct ao2_container *peers;
1038
1039#define MAX_USER_BUCKETS MAX_PEER_BUCKETS
1040static struct ao2_container *users;
1041
1042/*! Table containing peercnt objects for every ip address consuming a callno */
1043static struct ao2_container *peercnts;
1044
1045/*! Table containing custom callno limit rules for a range of ip addresses. */
1046static struct ao2_container *callno_limits;
1047
1048/*! Table containing ip addresses not requiring calltoken validation */
1049static struct ao2_container *calltoken_ignores;
1050
1051static uint16_t DEFAULT_MAXCALLNO_LIMIT = 2048;
1052
1053static uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192;
1054
1055static uint16_t global_maxcallno;
1056
1057/*! Total num of call numbers allowed to be allocated without calltoken validation */
1058static uint16_t global_maxcallno_nonval;
1059
1060static uint16_t total_nonval_callno_used = 0;
1061
1062/*! peer connection private, keeps track of all the call numbers
1063 * consumed by a single ip address */
1064struct peercnt {
1065 /*! ip address consuming call numbers */
1066 struct ast_sockaddr addr;
1067 /*! Number of call numbers currently used by this ip address */
1068 uint16_t cur;
1069 /*! Max call numbers allowed for this ip address */
1070 uint16_t limit;
1071 /*! Specifies whether limit is set by a registration or not, if so normal
1072 * limit setting rules do not apply to this address. */
1073 unsigned char reg;
1074};
1075
1076/*! used by both callno_limits and calltoken_ignores containers */
1077struct addr_range {
1078 /*! ip address range for custom callno limit rule */
1079 struct ast_ha ha;
1080 /*! callno limit for this ip address range, only used in callno_limits container */
1081 uint16_t limit;
1082 /*! delete me marker for reloads */
1083 unsigned char delme;
1084};
1085
1086enum {
1087 /*! Extension exists */
1088 CACHE_FLAG_EXISTS = (1 << 0),
1089 /*! Extension is nonexistent */
1090 CACHE_FLAG_NONEXISTENT = (1 << 1),
1091 /*! Extension can exist */
1092 CACHE_FLAG_CANEXIST = (1 << 2),
1093 /*! Waiting to hear back response */
1094 CACHE_FLAG_PENDING = (1 << 3),
1095 /*! Timed out */
1096 CACHE_FLAG_TIMEOUT = (1 << 4),
1097 /*! Request transmitted */
1098 CACHE_FLAG_TRANSMITTED = (1 << 5),
1099 /*! Timeout */
1100 CACHE_FLAG_UNKNOWN = (1 << 6),
1101 /*! Matchmore */
1102 CACHE_FLAG_MATCHMORE = (1 << 7),
1103};
1104
1105struct iax2_dpcache {
1106 char peercontext[AST_MAX_CONTEXT];
1107 char exten[AST_MAX_EXTENSION];
1108 struct timeval orig;
1109 struct timeval expiry;
1110 int flags;
1111 unsigned short callno;
1112 int waiters[256];
1113 AST_LIST_ENTRY(iax2_dpcache) cache_list;
1114 AST_LIST_ENTRY(iax2_dpcache) peer_list;
1115};
1116
1117static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
1118
1119static void reg_source_db(struct iax2_peer *p);
1120static struct iax2_peer *realtime_peer(const char *peername, struct ast_sockaddr *addr);
1121static struct iax2_user *realtime_user(const char *username, struct ast_sockaddr *addr);
1122
1123static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
1124static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags);
1125static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
1126
1127enum iax2_thread_iostate {
1128 IAX_IOSTATE_IDLE,
1129 IAX_IOSTATE_READY,
1130 IAX_IOSTATE_PROCESSING,
1131 IAX_IOSTATE_SCHEDREADY,
1132};
1133
1134enum iax2_thread_type {
1135 IAX_THREAD_TYPE_POOL,
1136 IAX_THREAD_TYPE_DYNAMIC,
1137};
1138
1139struct iax2_pkt_buf {
1140 AST_LIST_ENTRY(iax2_pkt_buf) entry;
1141 size_t len;
1142 unsigned char buf[1];
1143};
1144
1145struct iax2_thread {
1146 AST_LIST_ENTRY(iax2_thread) list;
1147 enum iax2_thread_type type;
1148 enum iax2_thread_iostate iostate;
1149#ifdef SCHED_MULTITHREADED
1150 void (*schedfunc)(const void *);
1151 const void *scheddata;
1152#endif
1153#ifdef DEBUG_SCHED_MULTITHREAD
1154 char curfunc[80];
1155#endif
1156 int actions;
1157 pthread_t threadid;
1158 int threadnum;
1159 struct ast_sockaddr ioaddr;
1160 unsigned char readbuf[4096];
1161 unsigned char *buf;
1162 ssize_t buf_len;
1163 size_t buf_size;
1164 int iofd;
1165 time_t checktime;
1166 ast_mutex_t lock;
1167 ast_cond_t cond;
1168 ast_mutex_t init_lock;
1169 ast_cond_t init_cond;
1170 /*! if this thread is processing a full frame,
1171 some information about that frame will be stored
1172 here, so we can avoid dispatching any more full
1173 frames for that callno to other threads */
1174 struct {
1175 unsigned short callno;
1176 struct ast_sockaddr addr;
1177 unsigned char type;
1178 unsigned char csub;
1179 } ffinfo;
1180 /*! Queued up full frames for processing. If more full frames arrive for
1181 * a call which this thread is already processing a full frame for, they
1182 * are queued up here. */
1183 AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
1184 unsigned char stop;
1185};
1186
1187/* Thread lists */
1188static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
1189static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
1190static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
1191
1192static void *iax2_process_thread(void *data);
1193static void iax2_destroy(int callno);
1194
1195static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
1196{
1197 ast_mutex_lock(lock);
1198 ast_cond_signal(cond);
1199 ast_mutex_unlock(lock);
1200}
1201
1202/*!
1203 * \brief an array of iax2 pvt structures
1204 *
1205 * The container for active chan_iax2_pvt structures is implemented as an
1206 * array for extremely quick direct access to the correct pvt structure
1207 * based on the local call number. The local call number is used as the
1208 * index into the array where the associated pvt structure is stored.
1209 */
1210static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
1211
1212static ast_callid iax_pvt_callid_get(int callno)
1213{
1214 return iaxs[callno]->callid;
1215}
1216
1217static void iax_pvt_callid_set(int callno, ast_callid callid)
1218{
1219 iaxs[callno]->callid = callid;
1220}
1221
1222static void iax_pvt_callid_new(int callno)
1223{
1224 ast_callid callid = ast_create_callid();
1225 char buffer[AST_CALLID_BUFFER_LENGTH];
1226 ast_callid_strnprint(buffer, sizeof(buffer), callid);
1227 iax_pvt_callid_set(callno, callid);
1228}
1229
1230/*!
1231 * \brief Another container of iax2_pvt structures
1232 *
1233 * Active IAX2 pvt structs are also stored in this container, if they are a part
1234 * of an active call where we know the remote side's call number. The reason
1235 * for this is that incoming media frames do not contain our call number. So,
1236 * instead of having to iterate the entire iaxs array, we use this container to
1237 * look up calls where the remote side is using a given call number.
1238 */
1239static struct ao2_container *iax_peercallno_pvts;
1240
1241/*!
1242 * \brief chan_iax2_pvt structure locks
1243 *
1244 * These locks are used when accessing a pvt structure in the iaxs array.
1245 * The index used here is the same as used in the iaxs array. It is the
1246 * local call number for the associated pvt struct.
1247 */
1248static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)];
1249
1250/*!
1251 * \brief Another container of iax2_pvt structures
1252 *
1253 * Active IAX2 pvt structs used during transferring a call are stored here.
1254 */
1255static struct ao2_container *iax_transfercallno_pvts;
1256
1257/* Flag to use with trunk calls, keeping these calls high up. It halves our effective use
1258 but keeps the division between trunked and non-trunked better. */
1259#define TRUNK_CALL_START (IAX_MAX_CALLS / 2)
1260
1261/* Debug routines... */
1262static struct ast_sockaddr debugaddr;
1263
1264static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct ast_sockaddr *addr, int datalen)
1265{
1266 if (iaxdebug ||
1267 (addr && !ast_sockaddr_isnull(&debugaddr) &&
1268 (!ast_sockaddr_port(&debugaddr) ||
1269 ast_sockaddr_port(&debugaddr) == ast_sockaddr_port(addr)) &&
1270 !ast_sockaddr_cmp_addr(&debugaddr, addr))) {
1271
1272 if (iaxdebug) {
1273 iax_showframe(f, fhi, rx, addr, datalen);
1274 } else {
1275 iaxdebug = 1;
1276 iax_showframe(f, fhi, rx, addr, datalen);
1277 iaxdebug = 0;
1278 }
1279 }
1280}
1281
1282static void iax_debug_output(const char *data)
1283{
1284 if (iaxdebug)
1285 ast_verbose("%s", data);
1286}
1287
1288static void iax_error_output(const char *data)
1289{
1290 ast_log(LOG_WARNING, "%s", data);
1291}
1292
1293static void __attribute__((format(printf, 1, 2))) jb_error_output(const char *fmt, ...)
1294{
1295 va_list args;
1296 char buf[1024];
1297
1298 va_start(args, fmt);
1299 vsnprintf(buf, sizeof(buf), fmt, args);
1300 va_end(args);
1301
1302 ast_log(LOG_ERROR, "%s", buf);
1303}
1304
1305static void __attribute__((format(printf, 1, 2))) jb_warning_output(const char *fmt, ...)
1306{
1307 va_list args;
1308 char buf[1024];
1309
1310 va_start(args, fmt);
1311 vsnprintf(buf, sizeof(buf), fmt, args);
1312 va_end(args);
1313
1314 ast_log(LOG_WARNING, "%s", buf);
1315}
1316
1317static void __attribute__((format(printf, 1, 2))) jb_debug_output(const char *fmt, ...)
1318{
1319 va_list args;
1320 char buf[1024];
1321
1322 va_start(args, fmt);
1323 vsnprintf(buf, sizeof(buf), fmt, args);
1324 va_end(args);
1325
1326 ast_verbose("%s", buf);
1327}
1328
1329static int expire_registry(const void *data);
1330static int iax2_answer(struct ast_channel *c);
1331static int iax2_call(struct ast_channel *c, const char *dest, int timeout);
1332static int iax2_devicestate(const char *data);
1333static int iax2_digit_begin(struct ast_channel *c, char digit);
1334static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
1335static int iax2_do_register(struct iax2_registry *reg);
1336static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
1337static int iax2_hangup(struct ast_channel *c);
1338static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
1339static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
1340static int iax2_provision(struct ast_sockaddr *end, int sockfd, const char *dest, const char *template, int force);
1341static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1342static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
1343static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
1344static int iax2_sendtext(struct ast_channel *c, const char *text);
1345static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
1346static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen);
1347static int iax2_transfer(struct ast_channel *c, const char *dest);
1348static int iax2_write(struct ast_channel *c, struct ast_frame *f);
1349static int iax2_sched_add(struct ast_sched_context *sched, int when, ast_sched_cb callback, const void *data);
1350
1351static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
1352static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1353static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1354static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1355static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
1356static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
1357static 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);
1358static struct ast_frame *iax2_read(struct ast_channel *c);
1359static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1360static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1361static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime);
1362static void *iax2_dup_variable_datastore(void *);
1363static void prune_peers(void);
1364static void prune_users(void);
1365static void iax2_free_variable_datastore(void *);
1366
1367static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
1368static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen);
1369static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen);
1370static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt);
1371static void build_rand_pad(unsigned char *buf, ssize_t len);
1372static int get_unused_callno(enum callno_type type, int validated, callno_entry *entry);
1373static int replace_callno(const void *obj);
1374static void sched_delay_remove(struct ast_sockaddr *addr, callno_entry entry);
1375static void network_change_stasis_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message);
1376static void acl_change_stasis_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message);
1377
1378static struct ast_channel_tech iax2_tech = {
1379 .type = "IAX2",
1380 .description = tdesc,
1381 .properties = AST_CHAN_TP_WANTSJITTER,
1382 .requester = iax2_request,
1383 .devicestate = iax2_devicestate,
1384 .send_digit_begin = iax2_digit_begin,
1385 .send_digit_end = iax2_digit_end,
1386 .send_text = iax2_sendtext,
1387 .send_image = iax2_sendimage,
1388 .send_html = iax2_sendhtml,
1389 .call = iax2_call,
1390 .hangup = iax2_hangup,
1391 .answer = iax2_answer,
1392 .read = iax2_read,
1393 .write = iax2_write,
1394 .write_video = iax2_write,
1395 .indicate = iax2_indicate,
1396 .setoption = iax2_setoption,
1397 .queryoption = iax2_queryoption,
1398 .transfer = iax2_transfer,
1399 .fixup = iax2_fixup,
1400 .func_channel_read = acf_channel_read,
1401};
1402
1403/*!
1404 * \internal
1405 * \brief Obtain the owner channel lock if the owner exists.
1406 *
1407 * \param callno IAX2 call id.
1408 *
1409 * \note Assumes the iaxsl[callno] lock is already obtained.
1410 *
1411 * \note
1412 * IMPORTANT NOTE!!! Any time this function is used, even if
1413 * iaxs[callno] was valid before calling it, it may no longer be
1414 * valid after calling it. This function may unlock and lock
1415 * the mutex associated with this callno, meaning that another
1416 * thread may grab it and destroy the call.
1417 */
1418static void iax2_lock_owner(int callno)
1419{
1420 for (;;) {
1421 if (!iaxs[callno] || !iaxs[callno]->owner) {
1422 /* There is no owner lock to get. */
1423 break;
1424 }
1425 if (!ast_channel_trylock(iaxs[callno]->owner)) {
1426 /* We got the lock */
1427 break;
1428 }
1429 /* Avoid deadlock by pausing and trying again */
1430 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1431 }
1432}
1433
1434/*!
1435 * \internal
1436 * \brief Check if a control subtype is allowed on the wire.
1437 *
1438 * \param subtype Control frame subtype to check if allowed to/from the wire.
1439 *
1440 * \retval non-zero if allowed.
1441 */
1442static int iax2_is_control_frame_allowed(int subtype)
1443{
1444 enum ast_control_frame_type control = subtype;
1445 int is_allowed;
1446
1447 /*
1448 * Note: If we compare the enumeration type, which does not have any
1449 * negative constants, the compiler may optimize this code away.
1450 * Therefore, we must perform an integer comparison here.
1451 */
1452 if (subtype == -1) {
1453 return -1;
1454 }
1455
1456 /* Default to not allowing control frames to pass. */
1457 is_allowed = 0;
1458
1459 /*
1460 * The switch default is not present in order to take advantage
1461 * of the compiler complaining of a missing enum case.
1462 */
1463 switch (control) {
1464 /*
1465 * These control frames make sense to send/receive across the link.
1466 */
1467 case AST_CONTROL_HANGUP:
1468 case AST_CONTROL_RING:
1469 case AST_CONTROL_RINGING:
1470 case AST_CONTROL_ANSWER:
1471 case AST_CONTROL_BUSY:
1472 case AST_CONTROL_TAKEOFFHOOK:
1473 case AST_CONTROL_OFFHOOK:
1474 case AST_CONTROL_CONGESTION:
1475 case AST_CONTROL_FLASH:
1476 case AST_CONTROL_WINK:
1477 case AST_CONTROL_OPTION:
1478 case AST_CONTROL_RADIO_KEY:
1479 case AST_CONTROL_RADIO_UNKEY:
1480 case AST_CONTROL_PROGRESS:
1481 case AST_CONTROL_PROCEEDING:
1482 case AST_CONTROL_HOLD:
1483 case AST_CONTROL_UNHOLD:
1484 case AST_CONTROL_VIDUPDATE:
1485 case AST_CONTROL_CONNECTED_LINE:
1486 case AST_CONTROL_REDIRECTING:
1487 case AST_CONTROL_T38_PARAMETERS:
1488 case AST_CONTROL_AOC:
1489 case AST_CONTROL_INCOMPLETE:
1490 case AST_CONTROL_MCID:
1491 is_allowed = -1;
1492 break;
1493
1494 /*
1495 * These control frames do not make sense to send/receive across the link.
1496 */
1497 case _XXX_AST_CONTROL_T38:
1498 /* The control value is deprecated in favor of AST_CONTROL_T38_PARAMETERS. */
1499 case AST_CONTROL_SRCUPDATE:
1500 /* Across an IAX link the source is still the same. */
1501 case AST_CONTROL_TRANSFER:
1502 /* A success/fail status report from calling ast_transfer() on this machine. */
1503 case AST_CONTROL_CC:
1504 /* The payload contains pointers that are valid for the sending machine only. */
1505 case AST_CONTROL_SRCCHANGE:
1506 /* Across an IAX link the source is still the same. */
1507 case AST_CONTROL_READ_ACTION:
1508 /* The action can only be done by the sending machine. */
1509 case AST_CONTROL_END_OF_Q:
1510 /* This frame would cause the call to unexpectedly hangup. */
1511 case AST_CONTROL_UPDATE_RTP_PEER:
1512 /* Only meaningful across a bridge on this machine for direct-media exchange. */
1513 case AST_CONTROL_PVT_CAUSE_CODE:
1514 /* Intended only for the sending machine's local channel structure. */
1515 case AST_CONTROL_MASQUERADE_NOTIFY:
1516 /* Intended only for masquerades when calling ast_indicate_data(). */
1517 case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
1518 /* Intended only for internal stream topology manipulation. */
1519 case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
1520 /* Intended only for internal stream topology change notification. */
1521 case AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED:
1522 case AST_CONTROL_STREAM_STOP:
1523 case AST_CONTROL_STREAM_SUSPEND:
1524 case AST_CONTROL_STREAM_RESTART:
1525 case AST_CONTROL_STREAM_REVERSE:
1526 case AST_CONTROL_STREAM_FORWARD:
1527 case AST_CONTROL_PLAYBACK_BEGIN: /* Only supported by app_dial currently */
1528 /* None of these playback stream control frames should go across the link. */
1529 case AST_CONTROL_RECORD_CANCEL:
1530 case AST_CONTROL_RECORD_STOP:
1531 case AST_CONTROL_RECORD_SUSPEND:
1532 case AST_CONTROL_RECORD_MUTE:
1533 /* None of these media recording control frames should go across the link. */
1534 break;
1535 }
1536 return is_allowed;
1537}
1538
1539static void network_change_stasis_subscribe(void)
1540{
1541 if (!network_change_sub) {
1542 network_change_sub = stasis_subscribe(ast_system_topic(),
1543 network_change_stasis_cb, NULL);
1544 stasis_subscription_accept_message_type(network_change_sub, ast_network_change_type());
1545 stasis_subscription_set_filter(network_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
1546 }
1547}
1548
1549static void network_change_stasis_unsubscribe(void)
1550{
1551 network_change_sub = stasis_unsubscribe_and_join(network_change_sub);
1552}
1553
1554static void acl_change_stasis_subscribe(void)
1555{
1556 if (!acl_change_sub) {
1557 acl_change_sub = stasis_subscribe(ast_security_topic(),
1558 acl_change_stasis_cb, NULL);
1559 stasis_subscription_accept_message_type(acl_change_sub, ast_named_acl_change_type());
1560 stasis_subscription_set_filter(acl_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
1561 }
1562}
1563
1564static void acl_change_stasis_unsubscribe(void)
1565{
1566 acl_change_sub = stasis_unsubscribe_and_join(acl_change_sub);
1567}
1568
1569static int network_change_sched_cb(const void *data)
1570{
1571 struct iax2_registry *reg;
1572 network_change_sched_id = -1;
1573 AST_LIST_LOCK(&registrations);
1574 AST_LIST_TRAVERSE(&registrations, reg, entry) {
1575 iax2_do_register(reg);
1576 }
1577 AST_LIST_UNLOCK(&registrations);
1578
1579 return 0;
1580}
1581
1582static void network_change_stasis_cb(void *data, struct stasis_subscription *sub,
1583 struct stasis_message *message)
1584{
1585 /* This callback is only concerned with network change messages from the system topic. */
1586 if (stasis_message_type(message) != ast_network_change_type()) {
1587 return;
1588 }
1589
1590 ast_verb(1, "IAX, got a network change message, renewing all IAX registrations.\n");
1591 if (network_change_sched_id == -1) {
1592 network_change_sched_id = iax2_sched_add(sched, 1000, network_change_sched_cb, NULL);
1593 }
1594}
1595
1596static void acl_change_stasis_cb(void *data, struct stasis_subscription *sub,
1597 struct stasis_message *message)
1598{
1599 if (stasis_message_type(message) != ast_named_acl_change_type()) {
1600 return;
1601 }
1602
1603 ast_log(LOG_NOTICE, "Reloading chan_iax2 in response to ACL change event.\n");
1604 reload_config(1);
1605}
1606
1607static const struct ast_datastore_info iax2_variable_datastore_info = {
1608 .type = "IAX2_VARIABLE",
1609 .duplicate = iax2_dup_variable_datastore,
1610 .destroy = iax2_free_variable_datastore,
1611};
1612
1613static void *iax2_dup_variable_datastore(void *old)
1614{
1615 AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1616 struct ast_var_t *oldvar, *newvar;
1617
1618 newlist = ast_calloc(sizeof(*newlist), 1);
1619 if (!newlist) {
1620 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1621 return NULL;
1622 }
1623
1624 AST_LIST_HEAD_INIT(newlist);
1625 AST_LIST_LOCK(oldlist);
1626 AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1627 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1628 if (newvar)
1629 AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1630 else
1631 ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1632 }
1633 AST_LIST_UNLOCK(oldlist);
1634 return newlist;
1635}
1636
1637static void iax2_free_variable_datastore(void *old)
1638{
1639 AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1640 struct ast_var_t *oldvar;
1641
1642 AST_LIST_LOCK(oldlist);
1643 while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1644 ast_free(oldvar);
1645 }
1646 AST_LIST_UNLOCK(oldlist);
1647 AST_LIST_HEAD_DESTROY(oldlist);
1648 ast_free(oldlist);
1649}
1650
1651
1652/* WARNING: insert_idle_thread should only ever be called within the
1653 * context of an iax2_process_thread() thread.
1654 */
1655static void insert_idle_thread(struct iax2_thread *thread)
1656{
1657 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1658 AST_LIST_LOCK(&dynamic_list);
1659 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1660 AST_LIST_UNLOCK(&dynamic_list);
1661 } else {
1662 AST_LIST_LOCK(&idle_list);
1663 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1664 AST_LIST_UNLOCK(&idle_list);
1665 }
1666
1667 return;
1668}
1669
1670static struct iax2_thread *find_idle_thread(void)
1671{
1672 struct iax2_thread *thread = NULL;
1673
1674 /* Pop the head of the idle list off */
1675 AST_LIST_LOCK(&idle_list);
1676 thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1677 AST_LIST_UNLOCK(&idle_list);
1678
1679 /* If we popped a thread off the idle list, just return it */
1680 if (thread) {
1681 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1682 return thread;
1683 }
1684
1685 /* Pop the head of the dynamic list off */
1686 AST_LIST_LOCK(&dynamic_list);
1687 thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1688 AST_LIST_UNLOCK(&dynamic_list);
1689
1690 /* If we popped a thread off the dynamic list, just return it */
1691 if (thread) {
1692 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1693 return thread;
1694 }
1695
1696 /* If we can't create a new dynamic thread for any reason, return no thread at all */
1697 if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1698 return NULL;
1699
1700 /* Set default values */
1701 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1702 thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1703 thread->type = IAX_THREAD_TYPE_DYNAMIC;
1704
1705 /* Initialize lock and condition */
1706 ast_mutex_init(&thread->lock);
1707 ast_cond_init(&thread->cond, NULL);
1708 ast_mutex_init(&thread->init_lock);
1709 ast_cond_init(&thread->init_cond, NULL);
1710 ast_mutex_lock(&thread->init_lock);
1711
1712 /* Create thread and send it on it's way */
1713 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1714 ast_cond_destroy(&thread->cond);
1715 ast_mutex_destroy(&thread->lock);
1716 ast_mutex_unlock(&thread->init_lock);
1717 ast_cond_destroy(&thread->init_cond);
1718 ast_mutex_destroy(&thread->init_lock);
1719 ast_free(thread);
1720 return NULL;
1721 }
1722
1723 /* this thread is not processing a full frame (since it is idle),
1724 so ensure that the field for the full frame call number is empty */
1725 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1726
1727 /* Wait for the thread to be ready before returning it to the caller */
1728 ast_cond_wait(&thread->init_cond, &thread->init_lock);
1729
1730 /* Done with init_lock */
1731 ast_mutex_unlock(&thread->init_lock);
1732
1733 return thread;
1734}
1735
1736#ifdef SCHED_MULTITHREADED
1737static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1738{
1739 struct iax2_thread *thread;
1740 static time_t lasterror;
1741 time_t t;
1742
1743 thread = find_idle_thread();
1744 if (thread != NULL) {
1745 thread->schedfunc = func;
1746 thread->scheddata = data;
1747 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1748#ifdef DEBUG_SCHED_MULTITHREAD
1749 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1750#endif
1751 signal_condition(&thread->lock, &thread->cond);
1752 return 0;
1753 }
1754 time(&t);
1755 if (t != lasterror) {
1756 lasterror = t;
1757 ast_debug(1, "Out of idle IAX2 threads for scheduling! (%s)\n", funcname);
1758 }
1759
1760 return -1;
1761}
1762#define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1763#endif
1764
1765static int iax2_sched_replace(int id, struct ast_sched_context *con, int when,
1766 ast_sched_cb callback, const void *data)
1767{
1768 return ast_sched_replace(id, con, when, callback, data);
1769}
1770
1771static int iax2_sched_add(struct ast_sched_context *con, int when,
1772 ast_sched_cb callback, const void *data)
1773{
1774 return ast_sched_add(con, when, callback, data);
1775}
1776
1777/*!
1778 * \brief Acquire the iaxsl[callno] if call exists and not having ongoing hangup.
1779 * \param callno Call number to lock.
1780 * \retval 0 If call disappeared or has ongoing hangup procedure.
1781 * \retval 1 If call found and mutex is locked.
1782 */
1783static int iax2_lock_callno_unless_destroyed(int callno)
1784{
1785 ast_mutex_lock(&iaxsl[callno]);
1786
1787 /* We acquired the lock; but the call was already destroyed (we came after full hang up procedures)
1788 * or destroy initiated (in middle of hang up procedure. */
1789 if (!iaxs[callno] || iaxs[callno]->destroy_initiated) {
1790 ast_debug(3, "I wanted to lock callno %d, but it is dead or going to die.\n", callno);
1791 ast_mutex_unlock(&iaxsl[callno]);
1792 return 0;
1793 }
1794
1795 /* Lock acquired, and callno is alive and kicking. */
1796 return 1;
1797}
1798
1799static int send_ping(const void *data);
1800
1801static void __send_ping(const void *data)
1802{
1803 int callno = PTR_TO_CALLNO(data);
1804
1805 if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1806 ast_debug(3, "Hangup initiated on call %d, aborting __send_ping\n", callno);
1807 return;
1808 }
1809
1810 /* Mark pingid as invalid scheduler id. */
1811 iaxs[callno]->pingid = -1;
1812
1813 /* callno is now locked. */
1814 if (iaxs[callno]->peercallno) {
1815 /* Send PING packet. */
1816 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1817
1818 /* Schedule sending next ping. */
1819 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1820 }
1821
1822 ast_mutex_unlock(&iaxsl[callno]);
1823}
1824
1825static int send_ping(const void *data)
1826{
1827#ifdef SCHED_MULTITHREADED
1828 if (schedule_action(__send_ping, data))
1829#endif
1830 __send_ping(data);
1831
1832 return 0;
1833}
1834
1835static void encmethods_to_str(int e, struct ast_str **buf)
1836{
1837 ast_str_set(buf, 0, "(");
1838 if (e & IAX_ENCRYPT_AES128) {
1839 ast_str_append(buf, 0, "aes128");
1840 }
1841 if (e & IAX_ENCRYPT_KEYROTATE) {
1842 ast_str_append(buf, 0, ",keyrotate");
1843 }
1844 if (ast_str_strlen(*buf) > 1) {
1845 ast_str_append(buf, 0, ")");
1846 } else {
1847 ast_str_set(buf, 0, "No");
1848 }
1849}
1850
1851static int get_encrypt_methods(const char *s)
1852{
1853 int e;
1854 if (!strcasecmp(s, "aes128"))
1855 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1856 else if (ast_true(s))
1857 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1858 else
1859 e = 0;
1860 return e;
1861}
1862
1863static int send_lagrq(const void *data);
1864
1865static void __send_lagrq(const void *data)
1866{
1867 int callno = PTR_TO_CALLNO(data);
1868
1869 if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1870 ast_debug(3, "Hangup initiated on call %d, aborting __send_lagrq\n", callno);
1871 return;
1872 }
1873
1874 /* Mark lagid as invalid scheduler id. */
1875 iaxs[callno]->lagid = -1;
1876
1877 /* callno is now locked. */
1878 if (iaxs[callno]->peercallno) {
1879 /* Send LAGRQ packet. */
1880 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1881
1882 /* Schedule sending next lagrq. */
1883 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1884 }
1885
1886 ast_mutex_unlock(&iaxsl[callno]);
1887}
1888
1889static int send_lagrq(const void *data)
1890{
1891#ifdef SCHED_MULTITHREADED
1892 if (schedule_action(__send_lagrq, data))
1893#endif
1894 __send_lagrq(data);
1895 return 0;
1896}
1897
1898static unsigned char compress_subclass(iax2_format subclass)
1899{
1900 int x;
1901 int power=-1;
1902 /* If it's 64 or smaller, just return it */
1903 if (subclass < IAX_FLAG_SC_LOG)
1904 return subclass;
1905 /* Otherwise find its power */
1906 for (x = 0; x < IAX_MAX_SHIFT; x++) {
1907 if (subclass & (1LL << x)) {
1908 if (power > -1) {
1909 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
1910 return 0;
1911 } else
1912 power = x;
1913 }
1914 }
1915 return power | IAX_FLAG_SC_LOG;
1916}
1917
1918static iax2_format uncompress_subclass(unsigned char csub)
1919{
1920 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1921 if (csub & IAX_FLAG_SC_LOG) {
1922 /* special case for 'compressed' -1 */
1923 if (csub == 0xff)
1924 return -1;
1925 else
1926 return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1927 }
1928 else
1929 return csub;
1930}
1931
1932static struct ast_format *codec_choose_from_prefs(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
1933{
1934 int x;
1935 struct ast_format *found_format = NULL;
1936
1937 for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
1938 struct ast_format *pref_format;
1939 uint64_t pref_bitfield;
1940
1941 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
1942 if (!pref_bitfield) {
1943 break;
1944 }
1945
1946 pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
1947 if (!pref_format) {
1948 /* The bitfield is not associated with any format. */
1949 continue;
1950 }
1951 found_format = ast_format_cap_get_compatible_format(cap, pref_format);
1952 if (found_format) {
1953 break;
1954 }
1955 }
1956
1957 if (found_format && (ast_format_get_type(found_format) == AST_MEDIA_TYPE_AUDIO)) {
1958 return found_format;
1959 }
1960
1961 ast_debug(4, "Could not find preferred codec - Returning zero codec.\n");
1962 ao2_cleanup(found_format);
1963 return NULL;
1964}
1965
1966static iax2_format iax2_codec_choose(struct iax2_codec_pref *pref, iax2_format formats)
1967{
1968 struct ast_format_cap *cap;
1969 struct ast_format *tmpfmt;
1970 iax2_format format = 0;
1971
1972 if ((cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
1973 iax2_format_compatibility_bitfield2cap(formats, cap);
1974 tmpfmt = codec_choose_from_prefs(pref, cap);
1975 if (!tmpfmt) {
1976 ao2_ref(cap, -1);
1977 return 0;
1978 }
1979
1980 format = ast_format_compatibility_format2bitfield(tmpfmt);
1981 ao2_ref(tmpfmt, -1);
1982 ao2_ref(cap, -1);
1983 }
1984
1985 return format;
1986}
1987
1988const char *iax2_getformatname(iax2_format format)
1989{
1990 struct ast_format *tmpfmt;
1991
1992 tmpfmt = ast_format_compatibility_bitfield2format(format);
1993 if (!tmpfmt) {
1994 return "Unknown";
1995 }
1996
1997 return ast_format_get_name(tmpfmt);
1998}
1999
2000static const char *iax2_getformatname_multiple(iax2_format format, struct ast_str **codec_buf)
2001{
2002 struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
2003
2004 if (!cap) {
2005 return "(Nothing)";
2006 }
2007 iax2_format_compatibility_bitfield2cap(format, cap);
2008 ast_format_cap_get_names(cap, codec_buf);
2009 ao2_ref(cap, -1);
2010
2011 return ast_str_buffer(*codec_buf);
2012}
2013
2014static int iax2_parse_allow_disallow(struct iax2_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
2015{
2016 int res, i;
2017 struct ast_format_cap *cap;
2018
2019 /* We want to add the formats to the cap in the preferred order */
2020 cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
2021 if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
2022 ao2_cleanup(cap);
2023 return 1;
2024 }
2025
2026 res = ast_format_cap_update_by_allow_disallow(cap, list, allowing);
2027
2028 /* Adjust formats bitfield and pref list to match. */
2029 *formats = iax2_format_compatibility_cap2bitfield(cap);
2030 iax2_codec_pref_remove_missing(pref, *formats);
2031
2032 for (i = 0; i < ast_format_cap_count(cap); i++) {
2033 struct ast_format *fmt = ast_format_cap_get_format(cap, i);
2034
2035 iax2_codec_pref_append(pref, fmt, ast_format_cap_get_format_framing(cap, fmt));
2036 ao2_ref(fmt, -1);
2037 }
2038
2039 ao2_ref(cap, -1);
2040
2041 return res;
2042}
2043
2044/*!
2045 * \note The only member of the peer passed here guaranteed to be set is the name field
2046 */
2047static int peer_hash_cb(const void *obj, const int flags)
2048{
2049 const struct iax2_peer *peer = obj;
2050 const char *name = obj;
2051
2052 return ast_str_hash(flags & OBJ_KEY ? name : peer->name);
2053}
2054
2055/*!
2056 * \note The only member of the peer passed here guaranteed to be set is the name field
2057 */
2058static int peer_cmp_cb(void *obj, void *arg, int flags)
2059{
2060 struct iax2_peer *peer = obj, *peer2 = arg;
2061 const char *name = arg;
2062
2063 return !strcmp(peer->name, flags & OBJ_KEY ? name : peer2->name) ?
2064 CMP_MATCH | CMP_STOP : 0;
2065}
2066
2067/*!
2068 * \note The only member of the user passed here guaranteed to be set is the name field
2069 */
2070static int user_hash_cb(const void *obj, const int flags)
2071{
2072 const struct iax2_user *user = obj;
2073 const char *name = obj;
2074
2075 return ast_str_hash(flags & OBJ_KEY ? name : user->name);
2076}
2077
2078/*!
2079 * \note The only member of the user passed here guaranteed to be set is the name field
2080 */
2081static int user_cmp_cb(void *obj, void *arg, int flags)
2082{
2083 struct iax2_user *user = obj, *user2 = arg;
2084 const char *name = arg;
2085
2086 return !strcmp(user->name, flags & OBJ_KEY ? name : user2->name) ?
2087 CMP_MATCH | CMP_STOP : 0;
2088}
2089
2090/*!
2091 * \note This function calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
2092 * so do not call it with a pvt lock held.
2093 */
2094static struct iax2_peer *find_peer(const char *name, int realtime)
2095{
2096 struct iax2_peer *peer = NULL;
2097
2098 peer = ao2_find(peers, name, OBJ_KEY);
2099
2100 /* Now go for realtime if applicable */
2101 if (!peer && realtime) {
2102 peer = realtime_peer(name, NULL);
2103 }
2104 return peer;
2105}
2106
2107static struct iax2_peer *peer_ref(struct iax2_peer *peer)
2108{
2109 ao2_ref(peer, +1);
2110 return peer;
2111}
2112
2113static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
2114{
2115 ao2_ref(peer, -1);
2116 return NULL;
2117}
2118
2119static struct iax2_user *find_user(const char *name)
2120{
2121 return ao2_find(users, name, OBJ_KEY);
2122}
2123
2124static inline struct iax2_user *user_unref(struct iax2_user *user)
2125{
2126 ao2_ref(user, -1);
2127 return NULL;
2128}
2129
2130static int iax2_getpeername(struct ast_sockaddr addr, char *host, int len)
2131{
2132 struct iax2_peer *peer = NULL;
2133 int res = 0;
2134 struct ao2_iterator i;
2135
2136 i = ao2_iterator_init(peers, 0);
2137 while ((peer = ao2_iterator_next(&i))) {
2138
2139 if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
2140 ast_copy_string(host, peer->name, len);
2141 peer_unref(peer);
2142 res = 1;
2143 break;
2144 }
2145 peer_unref(peer);
2146 }
2147 ao2_iterator_destroy(&i);
2148
2149 if (!peer) {
2150 peer = realtime_peer(NULL, &addr);
2151 if (peer) {
2152 ast_copy_string(host, peer->name, len);
2153 peer_unref(peer);
2154 res = 1;
2155 }
2156 }
2157
2158 return res;
2159}
2160
2161/* Call AST_SCHED_DEL on a scheduled task if it is found in scheduler. */
2162static int iax2_delete_from_sched(const void* data)
2163{
2164 int sched_id = (int)(long)data;
2165
2166 AST_SCHED_DEL(sched, sched_id);
2167
2168 return 0;
2169}
2170
2171/*!\note Assumes the lock on the pvt is already held, when
2172 * iax2_destroy_helper() is called. */
2173static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
2174{
2175 /* Decrement AUTHREQ count if needed */
2176 if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
2177 struct iax2_user *user;
2178
2179 user = ao2_find(users, pvt->username, OBJ_KEY);
2180 if (user) {
2181 ast_atomic_fetchadd_int(&user->curauthreq, -1);
2182 user_unref(user);
2183 }
2184
2185 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
2186 }
2187
2188
2189 /* Mark call destroy initiated flag. */
2190 pvt->destroy_initiated = 1;
2191
2192 /*
2193 * Schedule deleting the scheduled (but didn't run yet) PINGs or LAGRQs.
2194 * Already running tasks will be terminated because of destroy_initiated.
2195 *
2196 * Don't call AST_SCHED_DEL from this thread for pingid and lagid because
2197 * it leads to a deadlock between the scheduler thread callback locking
2198 * the callno mutex and this thread which holds the callno mutex one or
2199 * more times. It is better to have another thread delete the scheduled
2200 * callbacks which doesn't lock the callno mutex.
2201 */
2202 iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->pingid);
2203 iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->lagid);
2204
2205 pvt->pingid = -1;
2206 pvt->lagid = -1;
2207
2208 AST_SCHED_DEL(sched, pvt->autoid);
2209 AST_SCHED_DEL(sched, pvt->authid);
2210 AST_SCHED_DEL(sched, pvt->initid);
2211 AST_SCHED_DEL(sched, pvt->jbid);
2212 AST_SCHED_DEL(sched, pvt->keyrotateid);
2213}
2214
2215static void iax2_frame_free(struct iax_frame *fr)
2216{
2217 AST_SCHED_DEL(sched, fr->retrans);
2218 iax_frame_free(fr);
2219}
2220
2221static int scheduled_destroy(const void *vid)
2222{
2223 unsigned short callno = PTR_TO_CALLNO(vid);
2224 ast_mutex_lock(&iaxsl[callno]);
2225 if (iaxs[callno]) {
2226 ast_debug(1, "Really destroying %d now...\n", callno);
2227 iax2_destroy(callno);
2228 }
2229 ast_mutex_unlock(&iaxsl[callno]);
2230 return 0;
2231}
2232
2233static void free_signaling_queue_entry(struct signaling_queue_entry *s)
2234{
2235 if (s->f.datalen) {
2236 ast_free(s->f.data.ptr);
2237 }
2238 ast_free(s);
2239}
2240
2241/*! \brief This function must be called once we are sure the other side has
2242 * given us a call number. All signaling is held here until that point. */
2243static void send_signaling(struct chan_iax2_pvt *pvt)
2244{
2245 struct signaling_queue_entry *s = NULL;
2246
2247 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2248 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
2249 free_signaling_queue_entry(s);
2250 }
2251 pvt->hold_signaling = 0;
2252}
2253
2254/*! \brief All frames other than that of type AST_FRAME_IAX must be held until
2255 * we have received a destination call number. */
2256static int queue_signalling(struct chan_iax2_pvt *pvt, struct ast_frame *f)
2257{
2258 struct signaling_queue_entry *qe;
2259
2260 if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
2261 return 1; /* do not queue this frame */
2262 } else if (!(qe = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
2263 return -1; /* out of memory */
2264 }
2265
2266 /* copy ast_frame into our queue entry */
2267 qe->f = *f;
2268 if (qe->f.datalen) {
2269 /* if there is data in this frame copy it over as well */
2270 if (!(qe->f.data.ptr = ast_malloc(qe->f.datalen))) {
2271 free_signaling_queue_entry(qe);
2272 return -1;
2273 }
2274 memcpy(qe->f.data.ptr, f->data.ptr, qe->f.datalen);
2275 }
2276 AST_LIST_INSERT_TAIL(&pvt->signaling_queue, qe, next);
2277
2278 return 0;
2279}
2280
2281static void pvt_destructor(void *obj)
2282{
2283 struct chan_iax2_pvt *pvt = obj;
2284 struct iax_frame *cur = NULL;
2285 struct signaling_queue_entry *s = NULL;
2286
2287 ast_mutex_lock(&iaxsl[pvt->callno]);
2288
2289 iax2_destroy_helper(pvt);
2290
2291 sched_delay_remove(&pvt->addr, pvt->callno_entry);
2292 pvt->callno_entry = 0;
2293
2294 /* Already gone */
2295 ast_set_flag64(pvt, IAX_ALREADYGONE);
2296
2297 AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
2298 /* Cancel any pending transmissions */
2299 cur->retries = -1;
2300 }
2301
2302 ast_mutex_unlock(&iaxsl[pvt->callno]);
2303
2304 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2305 free_signaling_queue_entry(s);
2306 }
2307
2308 if (pvt->reg) {
2309 pvt->reg->callno = 0;
2310 }
2311
2312 if (!pvt->owner) {
2313 jb_frame frame;
2314 if (pvt->vars) {
2315 ast_variables_destroy(pvt->vars);
2316 pvt->vars = NULL;
2317 }
2318
2319 while (jb_getall(pvt->jb, &frame) == JB_OK) {
2320 iax2_frame_free(frame.data);
2321 }
2322
2323 jb_destroy(pvt->jb);
2324 ast_string_field_free_memory(pvt);
2325 }
2326}
2327
2328static struct chan_iax2_pvt *new_iax(struct ast_sockaddr *addr, const char *host)
2329{
2330 struct chan_iax2_pvt *tmp;
2331 jb_conf jbconf;
2332
2333 if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
2334 return NULL;
2335 }
2336
2337 tmp->pingid = -1;
2338 tmp->lagid = -1;
2339 tmp->autoid = -1;
2340 tmp->authid = -1;
2341 tmp->initid = -1;
2342 tmp->keyrotateid = -1;
2343 tmp->jbid = -1;
2344
2345 if (ast_string_field_init(tmp, 32)) {
2346 ao2_ref(tmp, -1);
2347 tmp = NULL;
2348 return NULL;
2349 }
2350
2351 tmp->prefs = prefs_global;
2352
2353 ast_string_field_set(tmp,exten, "s");
2354 ast_string_field_set(tmp,host, host);
2355
2356 tmp->jb = jb_new();
2357 jbconf.max_jitterbuf = maxjitterbuffer;
2358 jbconf.resync_threshold = resyncthreshold;
2359 jbconf.max_contig_interp = maxjitterinterps;
2360 jbconf.target_extra = jittertargetextra;
2361 jb_setconf(tmp->jb,&jbconf);
2362
2363 AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
2364
2365 tmp->hold_signaling = 1;
2366 AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
2367
2368 return tmp;
2369}
2370
2371static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
2372{
2373 struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
2374 if (new) {
2375 size_t afdatalen = new->afdatalen;
2376 memcpy(new, fr, sizeof(*new));
2377 iax_frame_wrap(new, &fr->af);
2378 new->afdatalen = afdatalen;
2379 new->data = NULL;
2380 new->datalen = 0;
2381 new->direction = DIRECTION_INGRESS;
2382 new->retrans = -1;
2383 }
2384 return new;
2385}
2386/* keep these defined in this order. They are used in find_callno to
2387 * determine whether or not a new call number should be allowed. */
2388enum {
2389 /* do not allow a new call number, only search ones in use for match */
2390 NEW_PREVENT = 0,
2391 /* search for match first, then allow a new one to be allocated */
2392 NEW_ALLOW = 1,
2393 /* do not search for match, force a new call number */
2394 NEW_FORCE = 2,
2395 /* do not search for match, force a new call number. Signifies call number
2396 * has been calltoken validated */
2397 NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
2398};
2399
2400static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
2401{
2402 if (!ast_sockaddr_cmp(&cur->addr, addr)) {
2403 /* This is the main host */
2404 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
2405 (check_dcallno ? dcallno == cur->callno : 1) ) {
2406 /* That's us. Be sure we keep track of the peer call number */
2407 return 1;
2408 }
2409 }
2410 if (!ast_sockaddr_cmp(&cur->transfer, addr) && cur->transferring) {
2411 /* We're transferring */
2412 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
2413 return 1;
2414 }
2415 return 0;
2416}
2417
2418static int make_trunk(unsigned short callno, int locked)
2419{
2420 int x;
2421 int res= 0;
2422 callno_entry entry;
2423 if (iaxs[callno]->oseqno) {
2424 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
2425 return -1;
2426 }
2427 if (callno >= TRUNK_CALL_START) {
2428 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
2429 return -1;
2430 }
2431
2432 if (get_unused_callno(
2433 CALLNO_TYPE_TRUNK,
2434 CALLNO_ENTRY_IS_VALIDATED(iaxs[callno]->callno_entry),
2435 &entry)) {
2436 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
2437 return -1;
2438 }
2439
2440 x = CALLNO_ENTRY_GET_CALLNO(entry);
2441 ast_mutex_lock(&iaxsl[x]);
2442
2443 /*!
2444 * \note We delete these before switching the slot, because if
2445 * they fire in the meantime, they will generate a warning.
2446 */
2447 AST_SCHED_DEL(sched, iaxs[callno]->pingid);
2448 AST_SCHED_DEL(sched, iaxs[callno]->lagid);
2449 iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
2450 iaxs[x] = iaxs[callno];
2451 iaxs[x]->callno = x;
2452
2453 /* since we copied over the pvt from a different callno, make sure the old entry is replaced
2454 * before assigning the new one */
2455 if (iaxs[x]->callno_entry) {
2456 iax2_sched_add(
2457 sched,
2458 MIN_REUSE_TIME * 1000,
2459 replace_callno,
2460 CALLNO_ENTRY_TO_PTR(iaxs[x]->callno_entry));
2461
2462 }
2463 iaxs[x]->callno_entry = entry;
2464
2465 iaxs[callno] = NULL;
2466 /* Update the two timers that should have been started */
2467 iaxs[x]->pingid = iax2_sched_add(sched,
2468 ping_time * 1000, send_ping, (void *)(long)x);
2469 iaxs[x]->lagid = iax2_sched_add(sched,
2470 lagrq_time * 1000, send_lagrq, (void *)(long)x);
2471
2472 if (locked)
2473 ast_mutex_unlock(&iaxsl[callno]);
2474 res = x;
2475 if (!locked)
2476 ast_mutex_unlock(&iaxsl[x]);
2477
2478 /* We moved this call from a non-trunked to a trunked call */
2479 ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
2480
2481 return res;
2482}
2483
2484static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
2485{
2486 if (!pvt->transfercallno) {
2487 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2488 return;
2489 }
2490
2491 ao2_link(iax_transfercallno_pvts, pvt);
2492}
2493
2494static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
2495{
2496 if (!pvt->transfercallno) {
2497 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2498 return;
2499 }
2500
2501 ao2_unlink(iax_transfercallno_pvts, pvt);
2502}
2503static void store_by_peercallno(struct chan_iax2_pvt *pvt)
2504{
2505 if (!pvt->peercallno) {
2506 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2507 return;
2508 }
2509
2510 ao2_link(iax_peercallno_pvts, pvt);
2511}
2512
2513static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
2514{
2515 if (!pvt->peercallno) {
2516 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2517 return;
2518 }
2519
2520 ao2_unlink(iax_peercallno_pvts, pvt);
2521}
2522
2523static int addr_range_delme_cb(void *obj, void *arg, int flags)
2524{
2525 struct addr_range *lim = obj;
2526 lim->delme = 1;
2527 return 0;
2528}
2529
2530static int addr_range_hash_cb(const void *obj, const int flags)
2531{
2532 const struct addr_range *lim = obj;
2533 return abs(ast_sockaddr_hash(&lim->ha.addr));
2534}
2535
2536static int addr_range_cmp_cb(void *obj, void *arg, int flags)
2537{
2538 struct addr_range *lim1 = obj, *lim2 = arg;
2539 return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
2540 !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
2541 CMP_MATCH | CMP_STOP : 0;
2542}
2543
2544static int peercnt_hash_cb(const void *obj, const int flags)
2545{
2546 const struct peercnt *peercnt = obj;
2547
2548 if (ast_sockaddr_isnull(&peercnt->addr)) {
2549 return 0;
2550 }
2551 return ast_sockaddr_hash(&peercnt->addr);
2552}
2553
2554static int peercnt_cmp_cb(void *obj, void *arg, int flags)
2555{
2556 struct peercnt *peercnt1 = obj, *peercnt2 = arg;
2557 return !ast_sockaddr_cmp_addr(&peercnt1->addr, &peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
2558}
2559
2560static int addr_range_match_address_cb(void *obj, void *arg, int flags)
2561{
2562 struct addr_range *addr_range = obj;
2563 struct ast_sockaddr *addr = arg;
2564 struct ast_sockaddr tmp_addr;
2565
2566 ast_sockaddr_apply_netmask(addr, &addr_range->ha.netmask, &tmp_addr);
2567
2568 if (!ast_sockaddr_cmp_addr(&tmp_addr, &addr_range->ha.addr)) {
2569 return CMP_MATCH | CMP_STOP;
2570 }
2571 return 0;
2572}
2573
2574/*!
2575 * \internal
2576 *
2577 * \brief compares addr to calltoken_ignores table to determine if validation is required.
2578 */
2579static int calltoken_required(struct ast_sockaddr *addr, const char *name, int subclass)
2580{
2581 struct addr_range *addr_range;
2582 struct iax2_peer *peer = NULL;
2583 struct iax2_user *user = NULL;
2584 /* if no username is given, check for guest accounts */
2585 const char *find = S_OR(name, "guest");
2586 int res = 1; /* required by default */
2587 int optional = 0;
2588 enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2589 /* There are only two cases in which calltoken validation is not required.
2590 * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2591 * the peer definition has not set the requirecalltoken option.
2592 * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2593 */
2594
2595 /* ----- Case 1 ----- */
2596 if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, addr))) {
2597 ao2_ref(addr_range, -1);
2598 optional = 1;
2599 }
2600
2601 /* ----- Case 2 ----- */
2602 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2603 calltoken_required = user->calltoken_required;
2604 } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, addr))) {
2605 calltoken_required = user->calltoken_required;
2606 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2607 calltoken_required = peer->calltoken_required;
2608 } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, addr))) {
2609 calltoken_required = peer->calltoken_required;
2610 }
2611
2612 if (peer) {
2613 peer_unref(peer);
2614 }
2615 if (user) {
2616 user_unref(user);
2617 }
2618
2619 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);
2620 if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2621 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2622 res = 0;
2623 }
2624
2625 return res;
2626}
2627
2628/*!
2629 * \internal
2630 *
2631 * \brief set peercnt callno limit.
2632 *
2633 * \details
2634 * First looks in custom definitions. If not found, global limit
2635 * is used. Entries marked as reg already have
2636 * a custom limit set by a registration and are not modified.
2637 */
2638static void set_peercnt_limit(struct peercnt *peercnt)
2639{
2640 uint16_t limit = global_maxcallno;
2641 struct addr_range *addr_range;
2642 struct ast_sockaddr addr;
2643
2644 ast_sockaddr_copy(&addr, &peercnt->addr);
2645
2646 if (peercnt->reg && peercnt->limit) {
2647 return; /* this peercnt has a custom limit set by a registration */
2648 }
2649
2650 if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &addr))) {
2651 limit = addr_range->limit;
2652 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_sockaddr_stringify(&addr));
2653 ao2_ref(addr_range, -1);
2654 }
2655
2656 peercnt->limit = limit;
2657}
2658
2659/*!
2660 * \internal
2661 * \brief sets limits for all peercnts in table. done on reload to reflect changes in conf.
2662 */
2663static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
2664{
2665 struct peercnt *peercnt = obj;
2666
2667 set_peercnt_limit(peercnt);
2668 ast_debug(1, "Reset limits for peercnts table\n");
2669
2670 return 0;
2671}
2672
2673/*!
2674 * \internal
2675 * \brief returns match if delme is set.
2676 */
2677static int prune_addr_range_cb(void *obj, void *arg, int flags)
2678{
2679 struct addr_range *addr_range = obj;
2680
2681 return addr_range->delme ? CMP_MATCH : 0;
2682}
2683
2684/*!
2685 * \internal
2686 * \brief modifies peercnt entry in peercnts table. Used to set custom limit or mark a registered ip
2687 */
2688static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
2689{
2690 /* this function turns off and on custom callno limits set by peer registration */
2691 struct peercnt *peercnt;
2692 struct peercnt tmp;
2693
2694 ast_sockaddr_copy(&tmp.addr, sockaddr);
2695
2696 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2697 peercnt->reg = reg;
2698 if (limit) {
2699 peercnt->limit = limit;
2700 } else {
2701 set_peercnt_limit(peercnt);
2702 }
2703 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_sockaddr_stringify_addr(sockaddr), peercnt->limit, peercnt->reg);
2704 ao2_ref(peercnt, -1); /* decrement ref from find */
2705 }
2706}
2707
2708/*!
2709 * \internal
2710 * \brief adds an ip to the peercnts table, increments connection count if it already exists
2711 *
2712 * \details First searches for the address in the peercnts table. If found
2713 * the current count is incremented. If not found a new peercnt is allocated
2714 * and linked into the peercnts table with a call number count of 1.
2715 */
2716static int peercnt_add(struct ast_sockaddr *addr)
2717{
2718 struct peercnt *peercnt;
2719 int res = 0;
2720 struct peercnt tmp;
2721
2722 ast_sockaddr_copy(&tmp.addr, addr);
2723
2724 /* Reasoning for peercnts container lock: Two identical ip addresses
2725 * could be added by different threads at the "same time". Without the container
2726 * lock, both threads could alloc space for the same object and attempt
2727 * to link to table. With the lock, one would create the object and link
2728 * to table while the other would find the already created peercnt object
2729 * rather than creating a new one. */
2730 ao2_lock(peercnts);
2731 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2732 ao2_lock(peercnt);
2733 } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2734 ao2_lock(peercnt);
2735 /* create and set defaults */
2736 ast_sockaddr_copy(&peercnt->addr, addr);
2737 set_peercnt_limit(peercnt);
2738 /* guarantees it does not go away after unlocking table
2739 * ao2_find automatically adds this */
2740 ao2_link(peercnts, peercnt);
2741 } else {
2742 ao2_unlock(peercnts);
2743 return -1;
2744 }
2745
2746 /* check to see if the address has hit its callno limit. If not increment cur. */
2747 if (peercnt->limit > peercnt->cur) {
2748 peercnt->cur++;
2749 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(addr));
2750 } else { /* max num call numbers for this peer has been reached! */
2751 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_sockaddr_stringify_addr(addr));
2752 res = -1;
2753 }
2754
2755 /* clean up locks and ref count */
2756 ao2_unlock(peercnt);
2757 ao2_unlock(peercnts);
2758 ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2759
2760 return res;
2761}
2762
2763/*!
2764 * \internal
2765 * \brief decrements a peercnts table entry
2766 */
2767static void peercnt_remove(struct peercnt *peercnt)
2768{
2769 struct ast_sockaddr addr;
2770
2771 ast_sockaddr_copy(&addr, &peercnt->addr);
2772
2773 /*
2774 * Container locked here since peercnt may be unlinked from
2775 * list. If left unlocked, peercnt_add could try and grab this
2776 * entry from the table and modify it at the "same time" this
2777 * thread attempts to unlink it.
2778 */
2779 ao2_lock(peercnts);
2780 peercnt->cur--;
2781 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(&addr));
2782 /* if this was the last connection from the peer remove it from table */
2783 if (peercnt->cur == 0) {
2784 ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2785 }
2786 ao2_unlock(peercnts);
2787}
2788
2789/*!
2790 * \internal
2791 * \brief called by scheduler to decrement object
2792 */
2793static int peercnt_remove_cb(const void *obj)
2794{
2795 struct peercnt *peercnt = (struct peercnt *) obj;
2796
2797 peercnt_remove(peercnt);
2798 ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2799
2800 return 0;
2801}
2802
2803/*!
2804 * \internal
2805 * \brief decrements peercnts connection count, finds by addr
2806 */
2807static int peercnt_remove_by_addr(struct ast_sockaddr *addr)
2808{
2809 struct peercnt *peercnt;
2810 struct peercnt tmp;
2811
2812 ast_sockaddr_copy(&tmp.addr, addr);
2813
2814 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2815 peercnt_remove(peercnt);
2816 ao2_ref(peercnt, -1); /* decrement ref from find */
2817 }
2818 return 0;
2819}
2820
2821/*!
2822 * \internal
2823 * \brief Create callno_limit entry based on configuration
2824 */
2825static void build_callno_limits(struct ast_variable *v)
2826{
2827 struct addr_range *addr_range = NULL;
2828 struct addr_range tmp;
2829 struct ast_ha *ha;
2830 int limit;
2831 int error;
2832 int found;
2833
2834 for (; v; v = v->next) {
2835 limit = -1;
2836 error = 0;
2837 found = 0;
2838 ha = ast_append_ha("permit", v->name, NULL, &error);
2839
2840 /* check for valid config information */
2841 if (error) {
2842 ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2843 continue;
2844 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2845 ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2846 ast_free_ha(ha);
2847 continue;
2848 }
2849
2850 ast_copy_ha(ha, &tmp.ha);
2851 /* find or create the addr_range */
2852 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2853 ao2_lock(addr_range);
2854 found = 1;
2855 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2856 ast_free_ha(ha);
2857 return; /* out of memory */
2858 }
2859
2860 /* copy over config data into addr_range object */
2861 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2862 ast_free_ha(ha); /* cleanup the tmp ha */
2863 addr_range->limit = limit;
2864 addr_range->delme = 0;
2865
2866 /* cleanup */
2867 if (found) {
2868 ao2_unlock(addr_range);
2869 } else {
2870 ao2_link(callno_limits, addr_range);
2871 }
2872 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2873 }
2874}
2875
2876/*!
2877 * \internal
2878 * \brief Create calltoken_ignores entry based on configuration
2879 */
2880static int add_calltoken_ignore(const char *addr)
2881{
2882 struct addr_range tmp;
2883 struct addr_range *addr_range = NULL;
2884 struct ast_ha *ha = NULL;
2885 int error = 0;
2886
2887 if (ast_strlen_zero(addr)) {
2888 ast_log(LOG_WARNING, "invalid calltokenoptional (null)\n");
2889 return -1;
2890 }
2891
2892 ha = ast_append_ha("permit", addr, NULL, &error);
2893
2894 /* check for valid config information */
2895 if (error) {
2896 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2897 return -1;
2898 }
2899
2900 ast_copy_ha(ha, &tmp.ha);
2901 /* find or create the addr_range */
2902 if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2903 ao2_lock(addr_range);
2904 addr_range->delme = 0;
2905 ao2_unlock(addr_range);
2906 } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2907 /* copy over config data into addr_range object */
2908 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2909 ao2_link(calltoken_ignores, addr_range);
2910 } else {
2911 ast_free_ha(ha);
2912 return -1;
2913 }
2914
2915 ast_free_ha(ha);
2916 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2917
2918 return 0;
2919}
2920
2921static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2922{
2923 struct ao2_iterator i;
2924 struct peercnt *peercnt;
2925 struct ast_sockaddr addr;
2926 int found = 0;
2927
2928 switch (cmd) {
2929 case CLI_INIT:
2930 e->command = "iax2 show callnumber usage";
2931 e->usage =
2932 "Usage: iax2 show callnumber usage [IP address]\n"
2933 " Shows current IP addresses which are consuming iax2 call numbers\n";
2934 return NULL;
2935 case CLI_GENERATE:
2936 return NULL;
2937 case CLI_HANDLER:
2938 if (a->argc < 4 || a->argc > 5)
2939 return CLI_SHOWUSAGE;
2940
2941 if (a->argc == 4) {
2942 ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2943 }
2944
2945 i = ao2_iterator_init(peercnts, 0);
2946 while ((peercnt = ao2_iterator_next(&i))) {
2947 ast_sockaddr_copy(&addr, &peercnt->addr);
2948
2949 if (a->argc == 5) {
2950 if (!strcasecmp(a->argv[4], ast_sockaddr_stringify(&addr))) {
2951 ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2952 ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2953 ao2_ref(peercnt, -1);
2954 found = 1;
2955 break;
2956 }
2957 } else {
2958 ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2959 }
2960 ao2_ref(peercnt, -1);
2961 }
2962 ao2_iterator_destroy(&i);
2963
2964 if (a->argc == 4) {
2965 size_t pool_avail = callno_pool.available;
2966 size_t trunk_pool_avail = callno_pool_trunk.available;
2967
2968 ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
2969 "Non-CallToken Validated Callno Used: %d\n",
2970 global_maxcallno_nonval,
2971 total_nonval_callno_used);
2972
2973 ast_cli(a->fd, "Total Available Callno: %zu\n"
2974 "Regular Callno Available: %zu\n"
2975 "Trunk Callno Available: %zu\n",
2976 pool_avail + trunk_pool_avail,
2977 pool_avail,
2978 trunk_pool_avail);
2979 } else if (a->argc == 5 && !found) {
2980 ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
2981 }
2982
2983
2984 return CLI_SUCCESS;
2985 default:
2986 return NULL;
2987 }
2988}
2989
2990static int get_unused_callno(enum callno_type type, int validated, callno_entry *entry)
2991{
2992 struct call_number_pool *pool = NULL;
2993 callno_entry swap;
2994 size_t choice;
2995
2996 switch (type) {
2997 case CALLNO_TYPE_NORMAL:
2998 pool = &callno_pool;
2999 break;
3000 case CALLNO_TYPE_TRUNK:
3001 pool = &callno_pool_trunk;
3002 break;
3003 default:
3004 ast_assert(0);
3005 break;
3006 }
3007
3008 /* If we fail, make sure this has a defined value */
3009 *entry = 0;
3010
3011 /* We lock here primarily to ensure thread safety of the
3012 * total_nonval_callno_used check and increment */
3013 ast_mutex_lock(&callno_pool_lock);
3014
3015 /* Bail out if we don't have any available call numbers */
3016 if (!pool->available) {
3017 ast_log(LOG_WARNING, "Out of call numbers\n");
3018 ast_mutex_unlock(&callno_pool_lock);
3019 return 1;
3020 }
3021
3022 /* Only a certain number of non-validated call numbers should be allocated.
3023 * If there ever is an attack, this separates the calltoken validating users
3024 * from the non-calltoken validating users. */
3025 if (!validated && total_nonval_callno_used >= global_maxcallno_nonval) {
3026 ast_log(LOG_WARNING,
3027 "NON-CallToken callnumber limit is reached. Current: %d Max: %d\n",
3028 total_nonval_callno_used,
3029 global_maxcallno_nonval);
3030 ast_mutex_unlock(&callno_pool_lock);
3031 return 1;
3032 }
3033
3034 /* We use a modified Fisher-Yates-Durstenfeld Shuffle to maintain a list of
3035 * available call numbers. The array of call numbers begins as an ordered
3036 * list from 1 -> n, and we keep a running tally of how many remain unclaimed
3037 * - let's call that x. When a call number is needed we pick a random index
3038 * into the array between 0 and x and use that as our call number. In a
3039 * typical FYD shuffle, we would swap the value that we are extracting with
3040 * the number at x, but in our case we swap and don't touch the value at x
3041 * because it is effectively invisible. We rely on the rest of the IAX2 core
3042 * to return the number to us at some point. Finally, we decrement x by 1
3043 * which establishes our new unused range.
3044 *
3045 * When numbers are returned to the pool, we put them just past x and bump x
3046 * by 1 so that this number is now available for re-use. */
3047
3048 choice = ast_random() % pool->available;
3049
3050 *entry = pool->numbers[choice];
3051 swap = pool->numbers[pool->available - 1];
3052
3053 pool->numbers[choice] = swap;
3054 pool->available--;
3055
3056 if (validated) {
3057 CALLNO_ENTRY_SET_VALIDATED(*entry);
3058 } else {
3059 total_nonval_callno_used++;
3060 }
3061
3062 ast_mutex_unlock(&callno_pool_lock);
3063
3064 return 0;
3065}
3066
3067static int replace_callno(const void *obj)
3068{
3069 callno_entry entry = PTR_TO_CALLNO_ENTRY(obj);
3070 struct call_number_pool *pool;
3071
3072 /* We lock here primarily to ensure thread safety of the
3073 * total_nonval_callno_used check and decrement */
3074 ast_mutex_lock(&callno_pool_lock);
3075
3076 if (!CALLNO_ENTRY_IS_VALIDATED(entry)) {
3077 if (total_nonval_callno_used) {
3078 total_nonval_callno_used--;
3079 } else {
3080 ast_log(LOG_ERROR,
3081 "Attempted to decrement total non calltoken validated "
3082 "callnumbers below zero. Callno is: %d\n",
3083 CALLNO_ENTRY_GET_CALLNO(entry));
3084 }
3085 }
3086
3087 if (CALLNO_ENTRY_GET_CALLNO(entry) < TRUNK_CALL_START) {
3088 pool = &callno_pool;
3089 } else {
3090 pool = &callno_pool_trunk;
3091 }
3092
3093 ast_assert(pool->capacity > pool->available);
3094
3095 /* This clears the validated flag */
3096 entry = CALLNO_ENTRY_GET_CALLNO(entry);
3097
3098 pool->numbers[pool->available] = entry;
3099 pool->available++;
3100
3101 ast_mutex_unlock(&callno_pool_lock);
3102
3103 return 0;
3104}
3105
3106static int create_callno_pools(void)
3107{
3108 uint16_t i;
3109
3110 callno_pool.available = callno_pool_trunk.available = 0;
3111
3112 /* We start at 2. 0 and 1 are reserved. */
3113 for (i = 2; i < TRUNK_CALL_START; i++) {
3114 callno_pool.numbers[callno_pool.available] = i;
3115 callno_pool.available++;
3116 }
3117
3118 for (i = TRUNK_CALL_START; i < IAX_MAX_CALLS; i++) {
3119 callno_pool_trunk.numbers[callno_pool_trunk.available] = i;
3120 callno_pool_trunk.available++;
3121 }
3122
3123 callno_pool.capacity = callno_pool.available;
3124 callno_pool_trunk.capacity = callno_pool_trunk.available;
3125
3126 ast_assert(callno_pool.capacity && callno_pool_trunk.capacity);
3127
3128 return 0;
3129}
3130
3131/*!
3132 * \internal
3133 * \brief Schedules delayed removal of iax2_pvt call number data
3134 *
3135 * \note After MIN_REUSE_TIME has passed for a destroyed iax2_pvt, the callno is
3136 * available again, and the address from the previous connection must be decremented
3137 * from the peercnts table. This function schedules these operations to take place.
3138 */
3139static void sched_delay_remove(struct ast_sockaddr *addr, callno_entry entry)
3140{
3141 int i;
3142 struct peercnt *peercnt;
3143 struct peercnt tmp;
3144
3145 ast_sockaddr_copy(&tmp.addr, addr);
3146
3147 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
3148 /* refcount is incremented with ao2_find. keep that ref for the scheduler */
3149 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_sockaddr_stringify_addr(addr), MIN_REUSE_TIME);
3150 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
3151 if (i == -1) {
3152 ao2_ref(peercnt, -1);
3153 }
3154 }
3155
3156 iax2_sched_add(
3157 sched,
3158 MIN_REUSE_TIME * 1000,
3159 replace_callno,
3160 CALLNO_ENTRY_TO_PTR(entry));
3161}
3162
3163/*!
3164 * \internal
3165 * \brief returns whether or not a frame is capable of starting a new IAX2 dialog.
3166 *
3167 * \note For this implementation, inbound pokes should _NOT_ be capable of allocating
3168 * a new callno.
3169 */
3170static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
3171{
3172 if (frametype != AST_FRAME_IAX) {
3173 return 0;
3174 }
3175 switch (subclass) {
3176 case IAX_COMMAND_NEW:
3177 case IAX_COMMAND_REGREQ:
3178 case IAX_COMMAND_FWDOWNL:
3179 case IAX_COMMAND_REGREL:
3180 return 1;
3181 case IAX_COMMAND_POKE:
3182 if (!inbound) {
3183 return 1;
3184 }
3185 break;
3186 }
3187 return 0;
3188}
3189
3190/*!
3191 * \note Calling this function while holding another pvt lock can cause a deadlock.
3192 */
3193static int __find_callno(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int return_locked, int check_dcallno)
3194{
3195 int res = 0;
3196 int x;
3197 /* this call is calltoken validated as long as it is either NEW_FORCE
3198 * or NEW_ALLOW_CALLTOKEN_VALIDATED */
3199 int validated = (new > NEW_ALLOW) ? 1 : 0;
3200 char host[80];
3201
3202 if (new <= NEW_ALLOW) {
3203 if (callno) {
3204 struct chan_iax2_pvt *pvt;
3205 struct chan_iax2_pvt tmp_pvt = {
3206 .callno = dcallno,
3207 .peercallno = callno,
3208 .transfercallno = callno,
3209 /* hack!! */
3210 .frames_received = check_dcallno,
3211 };
3212
3213 ast_sockaddr_copy(&tmp_pvt.addr, addr);
3214 /* this works for finding normal call numbers not involving transferring */
3215 if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3216 if (return_locked) {
3217 ast_mutex_lock(&iaxsl[pvt->callno]);
3218 }
3219 res = pvt->callno;
3220 ao2_ref(pvt, -1);
3221 pvt = NULL;
3222 return res;
3223 }
3224 /* this searches for transfer call numbers that might not get caught otherwise */
3225 memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
3226 ast_sockaddr_copy(&tmp_pvt.transfer, addr);
3227 if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3228 if (return_locked) {
3229 ast_mutex_lock(&iaxsl[pvt->callno]);
3230 }
3231 res = pvt->callno;
3232 ao2_ref(pvt, -1);
3233 pvt = NULL;
3234 return res;
3235 }
3236 }
3237 /* This will occur on the first response to a message that we initiated,
3238 * such as a PING. */
3239 if (dcallno) {
3240 ast_mutex_lock(&iaxsl[dcallno]);
3241 }
3242 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(addr, callno, dcallno, iaxs[dcallno], check_dcallno)) {
3243 iaxs[dcallno]->peercallno = callno;
3244 res = dcallno;
3245 store_by_peercallno(iaxs[dcallno]);
3246 if (!res || !return_locked) {
3247 ast_mutex_unlock(&iaxsl[dcallno]);
3248 }
3249 return res;
3250 }
3251 if (dcallno) {
3252 ast_mutex_unlock(&iaxsl[dcallno]);
3253 }
3254 }
3255 if (!res && (new >= NEW_ALLOW)) {
3256 callno_entry entry;
3257
3258 /* It may seem odd that we look through the peer list for a name for
3259 * this *incoming* call. Well, it is weird. However, users don't
3260 * have an IP address/port number that we can match against. So,
3261 * this is just checking for a peer that has that IP/port and
3262 * assuming that we have a user of the same name. This isn't always
3263 * correct, but it will be changed if needed after authentication. */
3264 if (!iax2_getpeername(*addr, host, sizeof(host)))
3265 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(addr));
3266
3267 if (peercnt_add(addr)) {
3268 /* This address has hit its callnumber limit. When the limit
3269 * is reached, the connection is not added to the peercnts table.*/
3270 return 0;
3271 }
3272
3273 if (get_unused_callno(CALLNO_TYPE_NORMAL, validated, &entry)) {
3274 /* since we ran out of space, remove the peercnt
3275 * entry we added earlier */
3276 peercnt_remove_by_addr(addr);
3277 ast_log(LOG_WARNING, "No more space\n");
3278 return 0;
3279 }
3280 x = CALLNO_ENTRY_GET_CALLNO(entry);
3281 ast_mutex_lock(&iaxsl[x]);
3282
3283 iaxs[x] = new_iax(addr, host);
3284 if (iaxs[x]) {
3285 if (iaxdebug)
3286 ast_debug(1, "Creating new call structure %d\n", x);
3287 iaxs[x]->callno_entry = entry;
3288 iaxs[x]->sockfd = sockfd;
3289 ast_sockaddr_copy(&iaxs[x]->addr, addr);
3290 iaxs[x]->peercallno = callno;
3291 iaxs[x]->callno = x;
3292 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
3293 iaxs[x]->expiry = min_reg_expire;
3294 iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
3295 iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
3296 iaxs[x]->amaflags = amaflags;
3297 ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
3298 ast_string_field_set(iaxs[x], accountcode, accountcode);
3299 ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
3300 ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
3301 ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
3302
3303 if (iaxs[x]->peercallno) {
3304 store_by_peercallno(iaxs[x]);
3305 }
3306 } else {
3307 ast_log(LOG_WARNING, "Out of resources\n");
3308 ast_mutex_unlock(&iaxsl[x]);
3309 replace_callno(CALLNO_ENTRY_TO_PTR(entry));
3310 return 0;
3311 }
3312 if (!return_locked)
3313 ast_mutex_unlock(&iaxsl[x]);
3314 res = x;
3315 }
3316 return res;
3317}
3318
3319static int find_callno(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame) {
3320 return __find_callno(callno, dcallno, addr, new, sockfd, 0, full_frame);
3321}
3322
3323static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame) {
3324
3325 return __find_callno(callno, dcallno, addr, new, sockfd, 1, full_frame);
3326}
3327
3328/*!
3329 * \brief Queue a frame to a call's owning asterisk channel
3330 *
3331 * \pre This function assumes that iaxsl[callno] is locked when called.
3332 *
3333 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3334 * was valid before calling it, it may no longer be valid after calling it.
3335 * This function may unlock and lock the mutex associated with this callno,
3336 * meaning that another thread may grab it and destroy the call.
3337 */
3338static int iax2_queue_frame(int callno, struct ast_frame *f)
3339{
3340 iax2_lock_owner(callno);
3341 if (iaxs[callno] && iaxs[callno]->owner) {
3342 ast_queue_frame(iaxs[callno]->owner, f);
3343 ast_channel_unlock(iaxs[callno]->owner);
3344 }
3345 return 0;
3346}
3347
3348/*!
3349 * \brief Queue a hold frame on the ast_channel owner
3350 *
3351 * This function queues a hold frame on the owner of the IAX2 pvt struct that
3352 * is active for the given call number.
3353 *
3354 * \pre Assumes lock for callno is already held.
3355 *
3356 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3357 * was valid before calling it, it may no longer be valid after calling it.
3358 * This function may unlock and lock the mutex associated with this callno,
3359 * meaning that another thread may grab it and destroy the call.
3360 */
3361static int iax2_queue_hold(int callno, const char *musicclass)
3362{
3363 iax2_lock_owner(callno);
3364 if (iaxs[callno] && iaxs[callno]->owner) {
3365 ast_queue_hold(iaxs[callno]->owner, musicclass);
3366 ast_channel_unlock(iaxs[callno]->owner);
3367 }
3368 return 0;
3369}
3370
3371/*!
3372 * \brief Queue an unhold frame on the ast_channel owner
3373 *
3374 * This function queues an unhold frame on the owner of the IAX2 pvt struct that
3375 * is active for the given call number.
3376 *
3377 * \pre Assumes lock for callno is already held.
3378 *
3379 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3380 * was valid before calling it, it may no longer be valid after calling it.
3381 * This function may unlock and lock the mutex associated with this callno,
3382 * meaning that another thread may grab it and destroy the call.
3383 */
3384static int iax2_queue_unhold(int callno)
3385{
3386 iax2_lock_owner(callno);
3387 if (iaxs[callno] && iaxs[callno]->owner) {
3388 ast_queue_unhold(iaxs[callno]->owner);
3389 ast_channel_unlock(iaxs[callno]->owner);
3390 }
3391 return 0;
3392}
3393
3394/*!
3395 * \brief Queue a hangup frame on the ast_channel owner
3396 *
3397 * This function queues a hangup frame on the owner of the IAX2 pvt struct that
3398 * is active for the given call number.
3399 *
3400 * \pre Assumes lock for callno is already held.
3401 *
3402 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3403 * was valid before calling it, it may no longer be valid after calling it.
3404 * This function may unlock and lock the mutex associated with this callno,
3405 * meaning that another thread may grab it and destroy the call.
3406 */
3407static int iax2_queue_hangup(int callno)
3408{
3409 iax2_lock_owner(callno);
3410 if (iaxs[callno] && iaxs[callno]->owner) {
3411 ast_queue_hangup(iaxs[callno]->owner);
3412 ast_channel_unlock(iaxs[callno]->owner);
3413 }
3414 return 0;
3415}
3416
3417/*!
3418 * \note This function assumes that iaxsl[callno] is locked when called.
3419 *
3420 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3421 * was valid before calling it, it may no longer be valid after calling it.
3422 * This function calls iax2_queue_frame(), which may unlock and lock the mutex
3423 * associated with this callno, meaning that another thread may grab it and destroy the call.
3424 */
3425static int __do_deliver(void *data)
3426{
3427 /* Just deliver the packet by using queueing. This is called by
3428 the IAX thread with the iaxsl lock held. */
3429 struct iax_frame *fr = data;
3430 fr->retrans = -1;
3431 ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
3432 if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
3433 iax2_queue_frame(fr->callno, &fr->af);
3434 /* Free our iax frame */
3435 iax2_frame_free(fr);
3436 /* And don't run again */
3437 return 0;
3438}
3439
3440static int handle_error(void)
3441{
3442 /* XXX Ideally we should figure out why an error occurred and then abort those
3443 rather than continuing to try. Unfortunately, the published interface does
3444 not seem to work XXX */
3445#if 0
3446 struct sockaddr_in *sin;
3447 int res;
3448 struct msghdr m;
3449 struct sock_extended_err e;
3450 m.msg_name = NULL;
3451 m.msg_namelen = 0;
3452 m.msg_iov = NULL;
3453 m.msg_control = &e;
3454 m.msg_controllen = sizeof(e);
3455 m.msg_flags = 0;
3456 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
3457 if (res < 0)
3458 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
3459 else {
3460 if (m.msg_controllen) {
3461 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
3462 if (sin)
3463 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
3464 else
3465 ast_log(LOG_WARNING, "No address detected??\n");
3466 } else {
3467 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
3468 }
3469 }
3470#endif
3471 return 0;
3472}
3473
3474static int transmit_trunk(struct iax_frame *f, struct ast_sockaddr *addr, int sockfd)
3475{
3476 int res;
3477 res = ast_sendto(sockfd, f->data, f->datalen, 0, addr);
3478
3479 if (res < 0) {
3480 ast_debug(1, "Received error: %s\n", strerror(errno));
3481 handle_error();
3482 } else
3483 res = 0;
3484 return res;
3485}
3486
3487static int send_packet(struct iax_frame *f)
3488{
3489 int res;
3490 int callno = f->callno;
3491
3492 /* Don't send if there was an error, but return error instead */
3493 if (!callno || !iaxs[callno] || iaxs[callno]->error)
3494 return -1;
3495
3496 /* Called with iaxsl held */
3497 if (iaxdebug) {
3498 ast_debug(8, "Sending %u on %d/%d to %s\n", f->ts, callno, iaxs[callno]->peercallno, ast_sockaddr_stringify(&iaxs[callno]->addr));
3499 }
3500 if (f->transfer) {
3501 iax_outputframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
3502 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->transfer);
3503 } else {
3504 iax_outputframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
3505 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->addr);
3506 }
3507 if (res < 0) {
3508 if (iaxdebug)
3509 ast_debug(1, "Received error: %s\n", strerror(errno));
3510 handle_error();
3511 } else
3512 res = 0;
3513
3514 return res;
3515}
3516
3517/*!
3518 * \note Since this function calls iax2_queue_hangup(), the pvt struct
3519 * for the given call number may disappear during its execution.
3520 */
3521static int iax2_predestroy(int callno)
3522{
3523 struct ast_channel *c = NULL;
3524 struct chan_iax2_pvt *pvt = iaxs[callno];
3525
3526 if (!pvt)
3527 return -1;
3528
3529 if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
3530 iax2_destroy_helper(pvt);
3531 ast_set_flag64(pvt, IAX_ALREADYGONE);
3532 }
3533
3534 if ((c = pvt->owner)) {
3535 ast_channel_tech_pvt_set(c, NULL);
3536 iax2_queue_hangup(callno);
3537 pvt->owner = NULL;
3538 ast_module_unref(ast_module_info->self);
3539 }
3540
3541 return 0;
3542}
3543
3544static void iax2_destroy(int callno)
3545{
3546 struct chan_iax2_pvt *pvt = NULL;
3547 struct ast_channel *owner = NULL;
3548
3549retry:
3550 if ((pvt = iaxs[callno])) {
3551#if 0
3552 /* iax2_destroy_helper gets called from this function later on. When
3553 * called twice, we get the (previously) familiar FRACK! errors in
3554 * devmode, from the scheduler. An alternative to this approach is to
3555 * reset the scheduler entries to -1 when they're deleted in
3556 * iax2_destroy_helper(). That approach was previously decided to be
3557 * "wrong" because "the memory is going to be deallocated anyway. Why
3558 * should we be resetting those values?" */
3559 iax2_destroy_helper(pvt);
3560#endif
3561 }
3562
3563 owner = pvt ? pvt->owner : NULL;
3564
3565 if (owner) {
3566 if (ast_channel_trylock(owner)) {
3567 ast_debug(3, "Avoiding IAX destroy deadlock\n");
3568 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
3569 goto retry;
3570 }
3571 }
3572
3573 if (!owner) {
3574 iaxs[callno] = NULL;
3575 }
3576
3577 if (pvt) {
3578 if (!owner) {
3579 pvt->owner = NULL;
3580 } else {
3581 /* If there's an owner, prod it to give up */
3582 /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
3583 * because we already hold the owner channel lock. */
3584 ast_queue_hangup(owner);
3585 }
3586
3587 if (pvt->peercallno) {
3588 remove_by_peercallno(pvt);
3589 }
3590
3591 if (pvt->transfercallno) {
3592 remove_by_transfercallno(pvt);
3593 }
3594
3595 if (!owner) {
3596 ao2_ref(pvt, -1);
3597 pvt = NULL;
3598 }
3599 }
3600
3601 if (owner) {
3602 ast_channel_unlock(owner);
3603 }
3604}
3605
3606static int update_packet(struct iax_frame *f)
3607{
3608 /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
3609 struct ast_iax2_full_hdr *fh = f->data;
3610 struct ast_frame af;
3611
3612 /* if frame is encrypted. decrypt before updating it. */
3613 if (f->encmethods) {
3614 decode_frame(&f->mydcx, fh, &af, &f->datalen);
3615 }
3616 /* Mark this as a retransmission */
3617 fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
3618 /* Update iseqno */
3619 f->iseqno = iaxs[f->callno]->iseqno;
3620 fh->iseqno = f->iseqno;
3621
3622 /* Now re-encrypt the frame */
3623 if (f->encmethods) {
3624 /* since this is a retransmit frame, create a new random padding
3625 * before re-encrypting. */
3626 build_rand_pad(f->semirand, sizeof(f->semirand));
3627 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
3628 }
3629 return 0;
3630}
3631
3632static int attempt_transmit(const void *data);
3633static void __attempt_transmit(const void *data)
3634{
3635 /* Attempt to transmit the frame to the remote peer...
3636 Called without iaxsl held. */
3637 struct iax_frame *f = (struct iax_frame *)data;
3638 int freeme = 0;
3639 int callno = f->callno;
3640
3641 /* Make sure this call is still active */
3642 if (callno)
3643 ast_mutex_lock(&iaxsl[callno]);
3644 if (callno && iaxs[callno]) {
3645 if (f->retries < 0) {
3646 /* Already ACK'd */
3647 freeme = 1;
3648 } else if (f->retries >= max_retries) {
3649 /* Too many attempts. Record an error. */
3650 if (f->transfer) {
3651 /* Transfer timeout */
3652 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
3653 } else if (f->final) {
3654 iax2_destroy(callno);
3655 } else {
3656 if (iaxs[callno]->owner) {
3657 ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %u, subclass = %d, ts=%u, seqno=%d)\n",
3658 ast_sockaddr_stringify_addr(&iaxs[f->callno]->addr),
3659 ast_channel_name(iaxs[f->callno]->owner),
3660 f->af.frametype,
3661 f->af.subclass.integer,
3662 f->ts,
3663 f->oseqno);
3664 }
3665 iaxs[callno]->error = ETIMEDOUT;
3666 if (iaxs[callno]->owner) {
3667 struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
3668 /* Hangup the fd */
3669 iax2_queue_frame(callno, &fr); /* XXX */
3670 /* Remember, owner could disappear */
3671 if (iaxs[callno] && iaxs[callno]->owner)
3672 ast_channel_hangupcause_set(iaxs[callno]->owner, AST_CAUSE_DESTINATION_OUT_OF_ORDER);
3673 } else {
3674 if (iaxs[callno]->reg) {
3675 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
3676 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
3677 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
3678 }
3679 iax2_destroy(callno);
3680 }
3681 }
3682 freeme = 1;
3683 } else {
3684 /* Update it if it needs it */
3685 update_packet(f);
3686 /* Attempt transmission */
3687 send_packet(f);
3688 f->retries++;
3689 /* Try again later after 10 times as long */
3690 f->retrytime *= 10;
3691 if (f->retrytime > MAX_RETRY_TIME)
3692 f->retrytime = MAX_RETRY_TIME;
3693 /* Transfer messages max out at one second */
3694 if (f->transfer && (f->retrytime > 1000))
3695 f->retrytime = 1000;
3696 f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
3697 }
3698 } else {
3699 /* Make sure it gets freed */
3700 f->retries = -1;
3701 freeme = 1;
3702 }
3703
3704 if (freeme) {
3705 /* Don't attempt delivery, just remove it from the queue */
3706 AST_LIST_REMOVE(&frame_queue[callno], f, list);
3707 ast_mutex_unlock(&iaxsl[callno]);
3708 f->retrans = -1; /* this is safe because this is the scheduled function */
3709 /* Free the IAX frame */
3710 iax2_frame_free(f);
3711 } else if (callno) {
3712 ast_mutex_unlock(&iaxsl[callno]);
3713 }
3714}
3715
3716static int attempt_transmit(const void *data)
3717{
3718#ifdef SCHED_MULTITHREADED
3719 if (schedule_action(__attempt_transmit, data))
3720#endif
3721 __attempt_transmit(data);
3722 return 0;
3723}
3724
3725static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3726{
3727 struct iax2_peer *peer = NULL;
3728 struct iax2_user *user = NULL;
3729 static const char * const choices[] = { "all", NULL };
3730 char *cmplt;
3731
3732 switch (cmd) {
3733 case CLI_INIT:
3734 e->command = "iax2 prune realtime";
3735 e->usage =
3736 "Usage: iax2 prune realtime [<peername>|all]\n"
3737 " Prunes object(s) from the cache\n";
3738 return NULL;
3739 case CLI_GENERATE:
3740 if (a->pos == 3) {
3741 cmplt = ast_cli_complete(a->word, choices, a->n);
3742 if (!cmplt)
3743 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
3744 return cmplt;
3745 }
3746 return NULL;
3747 }
3748 if (a->argc != 4)
3749 return CLI_SHOWUSAGE;
3750 if (!strcmp(a->argv[3], "all")) {
3751 prune_users();
3752 prune_peers();
3753 ast_cli(a->fd, "Cache flushed successfully.\n");
3754 return CLI_SUCCESS;
3755 }
3756 peer = find_peer(a->argv[3], 0);
3757 user = find_user(a->argv[3]);
3758 if (peer || user) {
3759 if (peer) {
3760 if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
3761 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
3762 expire_registry(peer_ref(peer));
3763 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
3764 } else {
3765 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
3766 }
3767 peer_unref(peer);
3768 }
3769 if (user) {
3770 if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
3771 ast_set_flag64(user, IAX_RTAUTOCLEAR);
3772 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
3773 } else {
3774 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
3775 }
3776 ao2_unlink(users,user);
3777 user_unref(user);
3778 }
3779 } else {
3780 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
3781 }
3782
3783 return CLI_SUCCESS;
3784}
3785
3786static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3787{
3788 switch (cmd) {
3789 case CLI_INIT:
3790 e->command = "iax2 test losspct";
3791 e->usage =
3792 "Usage: iax2 test losspct <percentage>\n"
3793 " For testing, throws away <percentage> percent of incoming packets\n";
3794 return NULL;
3795 case CLI_GENERATE:
3796 return NULL;
3797 }
3798 if (a->argc != 4)
3799 return CLI_SHOWUSAGE;
3800
3801 test_losspct = atoi(a->argv[3]);
3802
3803 return CLI_SUCCESS;
3804}
3805
3806#ifdef IAXTESTS
3807static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3808{
3809 switch (cmd) {
3810 case CLI_INIT:
3811 e->command = "iax2 test late";
3812 e->usage =
3813 "Usage: iax2 test late <ms>\n"
3814 " For testing, count the next frame as <ms> ms late\n";
3815 return NULL;
3816 case CLI_GENERATE:
3817 return NULL;
3818 }
3819
3820 if (a->argc != 4)
3821 return CLI_SHOWUSAGE;
3822
3823 test_late = atoi(a->argv[3]);
3824
3825 return CLI_SUCCESS;
3826}
3827
3828static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3829{
3830 switch (cmd) {
3831 case CLI_INIT:
3832 e->command = "iax2 test resync";
3833 e->usage =
3834 "Usage: iax2 test resync <ms>\n"
3835 " For testing, adjust all future frames by <ms> ms\n";
3836 return NULL;
3837 case CLI_GENERATE:
3838 return NULL;
3839 }
3840
3841 if (a->argc != 4)
3842 return CLI_SHOWUSAGE;
3843
3844 test_resync = atoi(a->argv[3]);
3845
3846 return CLI_SUCCESS;
3847}
3848
3849static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3850{
3851 switch (cmd) {
3852 case CLI_INIT:
3853 e->command = "iax2 test jitter";
3854 e->usage =
3855 "Usage: iax2 test jitter <ms> <pct>\n"
3856 " For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
3857 " percentage of packets. If <pct> is not specified, adds\n"
3858 " jitter to all packets.\n";
3859 return NULL;
3860 case CLI_GENERATE:
3861 return NULL;
3862 }
3863
3864 if (a->argc < 4 || a->argc > 5)
3865 return CLI_SHOWUSAGE;
3866
3867 test_jit = atoi(a->argv[3]);
3868 if (a->argc == 5)
3869 test_jitpct = atoi(a->argv[4]);
3870
3871 return CLI_SUCCESS;
3872}
3873#endif /* IAXTESTS */
3874
3875/*! \brief peer_status: Report Peer status in character string */
3876/* returns 1 if peer is online, -1 if unmonitored */
3877static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
3878{
3879 int res = 0;
3880 if (peer->maxms) {
3881 if (peer->lastms < 0) {
3882 ast_copy_string(status, "UNREACHABLE", statuslen);
3883 } else if (peer->lastms > peer->maxms) {
3884 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
3885 res = 1;
3886 } else if (peer->lastms) {
3887 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
3888 res = 1;
3889 } else {
3890 ast_copy_string(status, "UNKNOWN", statuslen);
3891 }
3892 } else {
3893 ast_copy_string(status, "Unmonitored", statuslen);
3894 res = -1;
3895 }
3896 return res;
3897}
3898
3899/*! \brief Show one peer in detail */
3900static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3901{
3902 char status[64];
3903 char cbuf[256];
3904 struct iax2_peer *peer;
3905 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
3906 struct ast_str *encmethods = ast_str_alloca(256);
3907 int load_realtime = 0;
3908
3909 switch (cmd) {
3910 case CLI_INIT:
3911 e->command = "iax2 show peer";
3912 e->usage =
3913 "Usage: iax2 show peer <name>\n"
3914 " Display details on specific IAX peer\n";
3915 return NULL;
3916 case CLI_GENERATE:
3917 if (a->pos == 3)
3918 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
3919 return NULL;
3920 }
3921
3922 if (a->argc < 4)
3923 return CLI_SHOWUSAGE;
3924
3925 load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
3926
3927 peer = find_peer(a->argv[3], load_realtime);
3928 if (peer) {
3929 char *str_addr, *str_defaddr;
3930 char *str_port, *str_defport;
3931
3932 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
3933 str_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
3934 str_defaddr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->defaddr));
3935 str_defport = ast_strdupa(ast_sockaddr_stringify_port(&peer->defaddr));
3936
3937 encmethods_to_str(peer->encmethods, &encmethods);
3938 ast_cli(a->fd, "\n\n");
3939 ast_cli(a->fd, " * Name : %s\n", peer->name);
3940 ast_cli(a->fd, " Description : %s\n", peer->description);
3941 ast_cli(a->fd, " Secret : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
3942 ast_cli(a->fd, " Context : %s\n", peer->context);
3943 ast_cli(a->fd, " Parking lot : %s\n", peer->parkinglot);
3944 ast_cli(a->fd, " Mailbox : %s\n", peer->mailbox);
3945 ast_cli(a->fd, " Dynamic : %s\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
3946 ast_cli(a->fd, " Callnum limit: %d\n", peer->maxcallno);
3947 ast_cli(a->fd, " Calltoken req: %s\n", (peer->calltoken_required == CALLTOKEN_YES) ? "Yes" : ((peer->calltoken_required == CALLTOKEN_AUTO) ? "Auto" : "No"));
3948 ast_cli(a->fd, " Trunk : %s\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
3949 ast_cli(a->fd, " Encryption : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
3950 ast_cli(a->fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
3951 ast_cli(a->fd, " Expire : %d\n", peer->expire);
3952 ast_cli(a->fd, " ACL : %s\n", (ast_acl_list_is_empty(peer->acl) ? "No" : "Yes"));
3953 ast_cli(a->fd, " Addr->IP : %s Port %s\n", str_addr ? str_addr : "(Unspecified)", str_port);
3954 ast_cli(a->fd, " Defaddr->IP : %s Port %s\n", str_defaddr, str_defport);
3955 ast_cli(a->fd, " Username : %s\n", peer->username);
3956 ast_cli(a->fd, " Codecs : %s\n", iax2_getformatname_multiple(peer->capability, &codec_buf));
3957
3958 if (iax2_codec_pref_string(&peer->prefs, cbuf, sizeof(cbuf)) < 0) {
3959 strcpy(cbuf, "Error"); /* Safe */
3960 }
3961 ast_cli(a->fd, " Codec Order : %s\n", cbuf);
3962
3963 peer_status(peer, status, sizeof(status));
3964 ast_cli(a->fd, " Status : %s\n", status);
3965 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");
3966 ast_cli(a->fd, "\n");
3967 peer_unref(peer);
3968 } else {
3969 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
3970 ast_cli(a->fd, "\n");
3971 }
3972
3973 return CLI_SUCCESS;
3974}
3975
3976static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags)
3977{
3978 int which = 0;
3979 struct iax2_peer *peer;
3980 char *res = NULL;
3981 int wordlen = strlen(word);
3982 struct ao2_iterator i;
3983
3984 i = ao2_iterator_init(peers, 0);
3985 while ((peer = ao2_iterator_next(&i))) {
3986 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
3987 && (!flags || ast_test_flag64(peer, flags))) {
3988 res = ast_strdup(peer->name);
3989 peer_unref(peer);
3990 break;
3991 }
3992 peer_unref(peer);
3993 }
3994 ao2_iterator_destroy(&i);
3995
3996 return res;
3997}
3998
3999static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
4000{
4001 struct iax_frame *cur;
4002 int cnt = 0, dead = 0, final = 0, i = 0;
4003
4004 switch (cmd) {
4005 case CLI_INIT:
4006 e->command = "iax2 show stats";
4007 e->usage =
4008 "Usage: iax2 show stats\n"
4009 " Display statistics on IAX channel driver.\n";
4010 return NULL;
4011 case CLI_GENERATE:
4012 return NULL;
4013 }
4014
4015 if (a->argc != 3)
4016 return CLI_SHOWUSAGE;
4017
4018 for (i = 0; i < ARRAY_LEN(frame_queue); i++) {
4019 ast_mutex_lock(&iaxsl[i]);
4020 AST_LIST_TRAVERSE(&frame_queue[i], cur, list) {
4021 if (cur->retries < 0)
4022 dead++;
4023 if (cur->final)
4024 final++;
4025 cnt++;
4026 }
4027 ast_mutex_unlock(&iaxsl[i]);
4028 }
4029
4030 ast_cli(a->fd, " IAX Statistics\n");
4031 ast_cli(a->fd, "---------------------\n");
4032 ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
4033 ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
4034 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
4035 ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
4036
4037 trunk_timed = trunk_untimed = 0;
4038 if (trunk_maxmtu > trunk_nmaxmtu)
4039 trunk_nmaxmtu = trunk_maxmtu;
4040
4041 return CLI_SUCCESS;
4042}
4043
4044/*! \brief Set trunk MTU from CLI */
4045static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
4046{
4047 int mtuv;
4048
4049 switch (cmd) {
4050 case CLI_INIT:
4051 e->command = "iax2 set mtu";
4052 e->usage =
4053 "Usage: iax2 set mtu <value>\n"
4054 " Set the system-wide IAX IP mtu to <value> bytes net or\n"
4055 " zero to disable. Disabling means that the operating system\n"
4056 " must handle fragmentation of UDP packets when the IAX2 trunk\n"
4057 " packet exceeds the UDP payload size. This is substantially\n"
4058 " below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
4059 " greater for G.711 samples.\n";
4060 return NULL;
4061 case CLI_GENERATE:
4062 return NULL;
4063 }
4064
4065 if (a->argc != 4)
4066 return CLI_SHOWUSAGE;
4067 if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
4068 mtuv = MAX_TRUNK_MTU;
4069 else
4070 mtuv = atoi(a->argv[3]);
4071
4072 if (mtuv == 0) {
4073 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
4074 global_max_trunk_mtu = 0;
4075 return CLI_SUCCESS;
4076 }
4077 if (mtuv < 172 || mtuv > 4000) {
4078 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n");
4079 return CLI_SHOWUSAGE;
4080 }
4081 ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
4082 global_max_trunk_mtu = mtuv;
4083 return CLI_SUCCESS;
4084}
4085
4086static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
4087{
4088 struct iax2_dpcache *dp = NULL;
4089 char tmp[1024], *pc = NULL;
4090 int s, x, y;
4091 struct timeval now = ast_tvnow();
4092
4093 switch (cmd) {
4094 case CLI_INIT:
4095 e->command = "iax2 show cache";
4096 e->usage =
4097 "Usage: iax2 show cache\n"
4098 " Display currently cached IAX Dialplan results.\n";
4099 return NULL;
4100 case CLI_GENERATE:
4101 return NULL;
4102 }
4103
4104 AST_LIST_LOCK(&dpcache);
4105
4106 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
4107
4108 AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
4109 s = dp->expiry.tv_sec - now.tv_sec;
4110 tmp[0] = '\0';
4111 if (dp->flags & CACHE_FLAG_EXISTS)
4112 strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
4113 if (dp->flags & CACHE_FLAG_NONEXISTENT)
4114 strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
4115 if (dp->flags & CACHE_FLAG_CANEXIST)
4116 strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
4117 if (dp->flags & CACHE_FLAG_PENDING)
4118 strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
4119 if (dp->flags & CACHE_FLAG_TIMEOUT)
4120 strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
4121 if (dp->flags & CACHE_FLAG_TRANSMITTED)
4122 strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
4123 if (dp->flags & CACHE_FLAG_MATCHMORE)
4124 strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
4125 if (dp->flags & CACHE_FLAG_UNKNOWN)
4126 strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
4127 /* Trim trailing pipe */
4128 if (!ast_strlen_zero(tmp)) {
4129 tmp[strlen(tmp) - 1] = '\0';
4130 } else {
4131 ast_copy_string(tmp, "(none)", sizeof(tmp));
4132 }
4133 y = 0;
4134 pc = strchr(dp->peercontext, '@');
4135 if (!pc) {
4136 pc = dp->peercontext;
4137 } else {
4138 pc++;
4139 }
4140 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
4141 if (dp->waiters[x] > -1)
4142 y++;
4143 }
4144 if (s > 0) {
4145 ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
4146 } else {
4147 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
4148 }
4149 }
4150
4151 AST_LIST_UNLOCK(&dpcache);
4152
4153 return CLI_SUCCESS;
4154}
4155
4156static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
4157
4158static void unwrap_timestamp(struct iax_frame *fr)
4159{
4160 /* Video mini frames only encode the lower 15 bits of the session
4161 * timestamp, but other frame types (e.g. audio) encode 16 bits. */
4162 const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
4163 const int lower_mask = (1 << ts_shift) - 1;
4164 const int upper_mask = ~lower_mask;
4165 const int last_upper = iaxs[fr->callno]->last & upper_mask;
4166
4167 if ( (fr->ts & upper_mask) == last_upper ) {
4168 const int x = fr->ts - iaxs[fr->callno]->last;
4169 const int threshold = (ts_shift == 15) ? 25000 : 50000;
4170
4171 if (x < -threshold) {
4172 /* Sudden big jump backwards in timestamp:
4173 What likely happened here is that miniframe timestamp has circled but we haven't
4174 gotten the update from the main packet. We'll just pretend that we did, and
4175 update the timestamp appropriately. */
4176 fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
4177 if (iaxdebug)
4178 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
4179 } else if (x > threshold) {
4180 /* Sudden apparent big jump forwards in timestamp:
4181 What's likely happened is this is an old miniframe belonging to the previous
4182 top 15 or 16-bit timestamp that has turned up out of order.
4183 Adjust the timestamp appropriately. */
4184 fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
4185 if (iaxdebug)
4186 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
4187 }
4188 }
4189}
4190
4191static int get_from_jb(const void *p);
4192
4193static void update_jbsched(struct chan_iax2_pvt *pvt)
4194{
4195 int when;
4196
4197 when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
4198
4199 when = jb_next(pvt->jb) - when;
4200
4201 if (when <= 0) {
4202 /* XXX should really just empty until when > 0.. */
4203 when = 1;
4204 }
4205
4206 pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb,
4207 CALLNO_TO_PTR(pvt->callno));
4208}
4209
4210static void __get_from_jb(const void *p)
4211{
4212 int callno = PTR_TO_CALLNO(p);
4213 struct chan_iax2_pvt *pvt = NULL;
4214 struct iax_frame *fr;
4215 jb_frame frame;
4216 int ret;
4217 long ms;
4218 long next;
4219 struct timeval now = ast_tvnow();
4220 struct ast_format *voicefmt;
4221
4222 /* Make sure we have a valid private structure before going on */
4223 ast_mutex_lock(&iaxsl[callno]);
4224 pvt = iaxs[callno];
4225 if (!pvt) {
4226 /* No go! */
4227 ast_mutex_unlock(&iaxsl[callno]);
4228 return;
4229 }
4230
4231 pvt->jbid = -1;
4232
4233 /* round up a millisecond since ast_sched_runq does; */
4234 /* prevents us from spinning while waiting for our now */
4235 /* to catch up with runq's now */
4236 now.tv_usec += 1000;
4237
4238 ms = ast_tvdiff_ms(now, pvt->rxcore);
4239 if (ms >= (next = jb_next(pvt->jb))) {
4240 voicefmt = ast_format_compatibility_bitfield2format(pvt->voiceformat);
4241 if (!voicefmt) {
4242 /* pvt->voiceformat won't be set if we haven't received any voice frames yet.
4243 * In this case, fall back to using the format negotiated during call setup,
4244 * so we don't stall the jitterbuffer completely. */
4245 voicefmt = ast_format_compatibility_bitfield2format(pvt->peerformat);
4246 if (!voicefmt) {
4247 /* As a last resort, we can use pvt->chosenformat.
4248 * This is set when we receive a call (either authenticated or unauthenticated),
4249 * so even if we haven't received any voice frames yet, we can still use the
4250 * right format.
4251 *
4252 * If we have to do this, in most cases, we aren't even processing voice frames
4253 * anyways, it's likely a non-voice frame. In that case, the format doesn't
4254 * really matter so much, because we could just pass 20 to jb_get instead
4255 * of calling ast_format_get_default_ms. However, until jb_get returns,
4256 * we don't actually know what kind of frame it is for sure, so use
4257 * the right format just to be safe. */
4258 voicefmt = ast_format_compatibility_bitfield2format(pvt->chosenformat);
4259 }
4260 }
4261 if (!voicefmt) {
4262 /* This should never happen, since we should always be able to have an acceptable format to use. */
4263 ast_log(LOG_ERROR, "No voice, peer, or chosen format available on %s, backlogging frame\n", ast_channel_name(pvt->owner));
4264 goto cleanup; /* Don't crash if there's no voice format */
4265 }
4266 ret = jb_get(pvt->jb, &frame, ms, ast_format_get_default_ms(voicefmt));
4267 switch(ret) {
4268 case JB_OK:
4269 fr = frame.data;
4270 __do_deliver(fr);
4271 /* __do_deliver() can cause the call to disappear */
4272 pvt = iaxs[callno];
4273 break;
4274 case JB_INTERP:
4275 {
4276 struct ast_frame af = { 0, };
4277
4278 /* create an interpolation frame */
4279 af.frametype = AST_FRAME_VOICE;
4280 af.subclass.format = voicefmt;
4281 af.samples = frame.ms * (ast_format_get_sample_rate(voicefmt) / 1000);
4282 af.src = "IAX2 JB interpolation";
4283 af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
4284 af.offset = AST_FRIENDLY_OFFSET;
4285
4286 /* queue the frame: For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
4287 * which we'd need to malloc, and then it would free it. That seems like a drag */
4288 if (!ast_test_flag64(iaxs[callno], IAX_ALREADYGONE)) {
4289 iax2_queue_frame(callno, &af);
4290 /* iax2_queue_frame() could cause the call to disappear */
4291 pvt = iaxs[callno];
4292 }
4293 }
4294 break;
4295 case JB_DROP:
4296 iax2_frame_free(frame.data);
4297 break;
4298 case JB_NOFRAME:
4299 case JB_EMPTY:
4300 /* do nothing */
4301 break;
4302 default:
4303 /* shouldn't happen */
4304 break;
4305 }
4306 }
4307cleanup:
4308 if (pvt)
4309 update_jbsched(pvt);
4310 ast_mutex_unlock(&iaxsl[callno]);
4311}
4312
4313static int get_from_jb(const void *data)
4314{
4315#ifdef SCHED_MULTITHREADED
4316 if (schedule_action(__get_from_jb, data))
4317#endif
4318 __get_from_jb(data);
4319 return 0;
4320}
4321
4322/*!
4323 * \note This function assumes fr->callno is locked
4324 *
4325 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
4326 * was valid before calling it, it may no longer be valid after calling it.
4327 */
4328static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
4329{
4330 int type, len;
4331 int ret;
4332 int needfree = 0;
4333
4334 /*
4335 * Clear fr->af.data if there is no data in the buffer. Things
4336 * like AST_CONTROL_HOLD without a suggested music class must
4337 * have a NULL pointer.
4338 */
4339 if (!fr->af.datalen) {
4340 memset(&fr->af.data, 0, sizeof(fr->af.data));
4341 }
4342
4343 /* Attempt to recover wrapped timestamps */
4344 unwrap_timestamp(fr);
4345
4346 /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
4347 if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
4348 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
4349 else {
4350#if 0
4351 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
4352#endif
4353 fr->af.delivery = ast_tv(0,0);
4354 }
4355
4356 type = JB_TYPE_CONTROL;
4357 len = 0;
4358
4359 if(fr->af.frametype == AST_FRAME_VOICE) {
4360 type = JB_TYPE_VOICE;
4361 len = ast_codec_samples_count(&fr->af) / (ast_format_get_sample_rate(fr->af.subclass.format) / 1000);
4362 } else if(fr->af.frametype == AST_FRAME_CNG) {
4363 type = JB_TYPE_SILENCE;
4364 }
4365
4366 if ( (!ast_test_flag64(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
4367 if (tsout)
4368 *tsout = fr->ts;
4369 __do_deliver(fr);
4370 return -1;
4371 }
4372
4373 /* insert into jitterbuffer */
4374 /* TODO: Perhaps we could act immediately if it's not droppable and late */
4375 ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
4376 calc_rxstamp(iaxs[fr->callno],fr->ts));
4377 if (ret == JB_DROP) {
4378 needfree++;
4379 } else if (ret == JB_SCHED) {
4380 update_jbsched(iaxs[fr->callno]);
4381 }
4382 if (tsout)
4383 *tsout = fr->ts;
4384 if (needfree) {
4385 /* Free our iax frame */
4386 iax2_frame_free(fr);
4387 return -1;
4388 }
4389 return 0;
4390}
4391
4392static int transmit_frame(void *data)
4393{
4394 struct iax_frame *fr = data;
4395
4396 ast_mutex_lock(&iaxsl[fr->callno]);
4397
4398 fr->sentyet = 1;
4399
4400 if (iaxs[fr->callno]) {
4401 send_packet(fr);
4402 }
4403
4404 if (fr->retries < 0) {
4405 ast_mutex_unlock(&iaxsl[fr->callno]);
4406 /* No retransmit requested */
4407 iax_frame_free(fr);
4408 } else {
4409 /* We need reliable delivery. Schedule a retransmission */
4410 AST_LIST_INSERT_TAIL(&frame_queue[fr->callno], fr, list);
4411 fr->retries++;
4412 fr->retrans = iax2_sched_add(sched, fr->retrytime, attempt_transmit, fr);
4413 ast_mutex_unlock(&iaxsl[fr->callno]);
4414 }
4415
4416 return 0;
4417}
4418
4419static int iax2_transmit(struct iax_frame *fr)
4420{
4421 fr->sentyet = 0;
4422
4423 return ast_taskprocessor_push(transmit_processor, transmit_frame, fr);
4424}
4425
4426static int iax2_digit_begin(struct ast_channel *c, char digit)
4427{
4428 return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
4429}
4430
4431static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
4432{
4433 return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
4434}
4435
4436static int iax2_sendtext(struct ast_channel *c, const char *text)
4437{
4438
4439 return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_TEXT,
4440 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
4441}
4442
4443static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
4444{
4445 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);
4446}
4447
4448static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
4449{
4450 return send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
4451}
4452
4453static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
4454{
4455 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(newchan));
4456 ast_mutex_lock(&iaxsl[callno]);
4457 if (iaxs[callno])
4458 iaxs[callno]->owner = newchan;
4459 else
4460 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
4461 ast_mutex_unlock(&iaxsl[callno]);
4462 return 0;
4463}
4464
4465/*!
4466 * \note This function calls reg_source_db -> iax2_poke_peer -> find_callno,
4467 * so do not call this with a pvt lock held.
4468 */
4469static struct iax2_peer *realtime_peer(const char *peername, struct ast_sockaddr *addr)
4470{
4471 struct ast_variable *var = NULL;
4472 struct ast_variable *tmp;
4473 struct iax2_peer *peer=NULL;
4474 time_t regseconds = 0, nowtime;
4475 int dynamic=0;
4476 char *str_addr, *str_port;
4477
4478 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
4479 str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
4480
4481 if (peername) {
4482 var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", SENTINEL);
4483 if (!var && !ast_sockaddr_isnull(addr)) {
4484 var = ast_load_realtime("iaxpeers", "name", peername, "host", str_addr, SENTINEL);
4485 }
4486 } else if (!ast_sockaddr_isnull(addr)) {
4487 var = ast_load_realtime("iaxpeers", "ipaddr", str_addr, "port", str_port, SENTINEL);
4488 if (var) {
4489 /* We'll need the peer name in order to build the structure! */
4490 for (tmp = var; tmp; tmp = tmp->next) {
4491 if (!strcasecmp(tmp->name, "name"))
4492 peername = tmp->value;
4493 }
4494 }
4495 }
4496 if (!var && peername) { /* Last ditch effort */
4497 var = ast_load_realtime("iaxpeers", "name", peername, SENTINEL);
4498 /*!\note
4499 * If this one loaded something, then we need to ensure that the host
4500 * field matched. The only reason why we can't have this as a criteria
4501 * is because we only have the IP address and the host field might be
4502 * set as a name (and the reverse PTR might not match).
4503 */
4504 if (var && !ast_sockaddr_isnull(addr)) {
4505 for (tmp = var; tmp; tmp = tmp->next) {
4506 if (!strcasecmp(tmp->name, "host")) {
4507 struct ast_sockaddr *hostaddr = NULL;
4508
4509 if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
4510 || ast_sockaddr_cmp_addr(hostaddr, addr)) {
4511 /* No match */
4512 ast_variables_destroy(var);
4513 var = NULL;
4514 }
4515 ast_free(hostaddr);
4516 break;
4517 }
4518 }
4519 }
4520 }
4521 if (!var)
4522 return NULL;
4523
4524 peer = build_peer(peername, var, NULL, ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
4525
4526 if (!peer) {
4527 ast_variables_destroy(var);
4528 return NULL;
4529 }
4530
4531 for (tmp = var; tmp; tmp = tmp->next) {
4532 /* Make sure it's not a user only... */
4533 if (!strcasecmp(tmp->name, "type")) {
4534 if (strcasecmp(tmp->value, "friend") &&
4535 strcasecmp(tmp->value, "peer")) {
4536 /* Whoops, we weren't supposed to exist! */
4537 peer = peer_unref(peer);
4538 break;
4539 }
4540 } else if (!strcasecmp(tmp->name, "regseconds")) {
4541 ast_get_time_t(tmp->value, &regseconds, 0, NULL);
4542 } else if (!strcasecmp(tmp->name, "ipaddr")) {
4543 int setport = ast_sockaddr_port(&peer->addr);
4544 if (ast_parse_arg(tmp->value, PARSE_ADDR | PARSE_PORT_FORBID, NULL)) {
4545 ast_log(LOG_WARNING, "Failed to parse sockaddr '%s' for ipaddr of realtime peer '%s'\n", tmp->value, tmp->name);
4546 } else {
4547 ast_sockaddr_parse(&peer->addr, tmp->value, 0);
4548 }
4549 ast_sockaddr_set_port(&peer->addr, setport);
4550 } else if (!strcasecmp(tmp->name, "port")) {
4551 int bindport;
4552 if (ast_parse_arg(tmp->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
4553 bindport = IAX_DEFAULT_PORTNO;
4554 }
4555 ast_sockaddr_set_port(&peer->addr, bindport);
4556 } else if (!strcasecmp(tmp->name, "host")) {
4557 if (!strcasecmp(tmp->value, "dynamic"))
4558 dynamic = 1;
4559 }
4560 }
4561
4562 ast_variables_destroy(var);
4563
4564 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
4565 ast_copy_flags64(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
4566 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR)) {
4567 if (peer->expire > -1) {
4568 if (!AST_SCHED_DEL(sched, peer->expire)) {
4569 peer->expire = -1;
4570 peer_unref(peer);
4571 }
4572 }
4573 peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
4574 if (peer->expire == -1)
4575 peer_unref(peer);
4576 }
4577 ao2_link(peers, peer);
4578 if (ast_test_flag64(peer, IAX_DYNAMIC))
4579 reg_source_db(peer);
4580 } else {
4581 ast_set_flag64(peer, IAX_TEMPONLY);
4582 }
4583
4584 if (!ast_test_flag64(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
4585 time(&nowtime);
4586 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
4587 memset(&peer->addr, 0, sizeof(peer->addr));
4588 realtime_update_peer(peer->name, &peer->addr, 0);
4589 ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
4590 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
4591 }
4592 else {
4593 ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
4594 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
4595 }
4596 }
4597
4598 return peer;
4599}
4600
4601static struct iax2_user *realtime_user(const char *username, struct ast_sockaddr *addr)
4602{
4603 struct ast_variable *var;
4604 struct ast_variable *tmp;
4605 struct iax2_user *user=NULL;
4606 char *str_addr, *str_port;
4607
4608 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
4609 str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
4610
4611 var = ast_load_realtime("iaxusers", "name", username, "host", "dynamic", SENTINEL);
4612 if (!var)
4613 var = ast_load_realtime("iaxusers", "name", username, "host", str_addr, SENTINEL);
4614 if (!var && !ast_sockaddr_isnull(addr)) {
4615 var = ast_load_realtime("iaxusers", "name", username, "ipaddr", str_addr, "port", str_port, SENTINEL);
4616 if (!var)
4617 var = ast_load_realtime("iaxusers", "ipaddr", str_addr, "port", str_port, SENTINEL);
4618 }
4619 if (!var) { /* Last ditch effort */
4620 var = ast_load_realtime("iaxusers", "name", username, SENTINEL);
4621 /*!\note
4622 * If this one loaded something, then we need to ensure that the host
4623 * field matched. The only reason why we can't have this as a criteria
4624 * is because we only have the IP address and the host field might be
4625 * set as a name (and the reverse PTR might not match).
4626 */
4627 if (var) {
4628 for (tmp = var; tmp; tmp = tmp->next) {
4629 if (!strcasecmp(tmp->name, "host")) {
4630 struct ast_sockaddr *hostaddr = NULL;
4631
4632 if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
4633 || ast_sockaddr_cmp_addr(hostaddr, addr)) {
4634 /* No match */
4635 ast_variables_destroy(var);
4636 var = NULL;
4637 }
4638 ast_free(hostaddr);
4639 break;
4640 }
4641 }
4642 }
4643 }
4644 if (!var)
4645 return NULL;
4646
4647 tmp = var;
4648 while(tmp) {
4649 /* Make sure it's not a peer only... */
4650 if (!strcasecmp(tmp->name, "type")) {
4651 if (strcasecmp(tmp->value, "friend") &&
4652 strcasecmp(tmp->value, "user")) {
4653 return NULL;
4654 }
4655 }
4656 tmp = tmp->next;
4657 }
4658
4659 user = build_user(username, var, NULL, !ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS));
4660
4661 ast_variables_destroy(var);
4662
4663 if (!user)
4664 return NULL;
4665
4666 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
4667 ast_set_flag64(user, IAX_RTCACHEFRIENDS);
4668 ao2_link(users, user);
4669 } else {
4670 ast_set_flag64(user, IAX_TEMPONLY);
4671 }
4672
4673 return user;
4674}
4675
4676static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime)
4677{
4678 char regseconds[20];
4679 const char *sysname = ast_config_AST_SYSTEM_NAME;
4680 char *syslabel = NULL;
4681 char *port;
4682
4683 if (ast_strlen_zero(sysname)) /* No system name, disable this */
4684 sysname = NULL;
4685 else if (ast_test_flag64(&globalflags, IAX_RTSAVE_SYSNAME))
4686 syslabel = "regserver";
4687
4688 snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
4689 port = ast_strdupa(ast_sockaddr_stringify_port(sockaddr));
4690 ast_update_realtime("iaxpeers", "name", peername,
4691 "ipaddr", ast_sockaddr_isnull(sockaddr) ? "" : ast_sockaddr_stringify_addr(sockaddr),
4692 "port", ast_sockaddr_isnull(sockaddr) ? "" : port,
4693 "regseconds", regseconds, syslabel, sysname, SENTINEL); /* note syslabel can be NULL */
4694}
4695
4696struct create_addr_info {
4697 iax2_format capability;
4698 uint64_t flags;
4699 struct iax2_codec_pref prefs;
4700 int maxtime;
4701 int encmethods;
4702 int authmethods;
4703 int found;
4704 int sockfd;
4705 int adsi;
4706 char username[80];
4707 char secret[80];
4708 char outkey[80];
4709 char timezone[80];
4710 char cid_num[80];
4711 char cid_name[80];
4712 char context[AST_MAX_CONTEXT];
4713 char peercontext[AST_MAX_CONTEXT];
4714 char mohinterpret[MAX_MUSICCLASS];
4715 char mohsuggest[MAX_MUSICCLASS];
4716};
4717
4718static int create_addr(const char *peername, struct ast_channel *c, struct ast_sockaddr *addr, struct create_addr_info *cai)
4719{
4720 struct iax2_peer *peer;
4721 int res = -1;
4722
4723 ast_clear_flag64(cai, IAX_SENDANI | IAX_TRUNK);
4724 cai->sockfd = defaultsockfd;
4725 cai->maxtime = 0;
4726
4727 if (!(peer = find_peer(peername, 1))) {
4728 struct ast_sockaddr peer_addr;
4729
4730 peer_addr.ss.ss_family = AST_AF_UNSPEC;
4731 cai->found = 0;
4732 if (ast_get_ip_or_srv(&peer_addr, peername, srvlookup ? "_iax._udp" : NULL)) {
4733 ast_log(LOG_WARNING, "No such host: %s\n", peername);
4734 return -1;
4735 }
4736
4737 if (!ast_sockaddr_port(&peer_addr)) {
4738 ast_sockaddr_set_port(&peer_addr, IAX_DEFAULT_PORTNO);
4739 }
4740
4741 ast_sockaddr_copy(addr, &peer_addr);
4742 /*
4743 * Use The global iax prefs for unknown peer/user.
4744 * However, move the calling channel's native codec to
4745 * the top of the preference list.
4746 */
4747 cai->prefs = prefs_global;
4748 if (c) {
4749 int i;
4750
4751 for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
4752 struct ast_format *format = ast_format_cap_get_format(
4753 ast_channel_nativeformats(c), i);
4754 iax2_codec_pref_prepend(&cai->prefs, format,
4755 ast_format_cap_get_format_framing(ast_channel_nativeformats(c), format),
4756 1);
4757 ao2_ref(format, -1);
4758 }
4759 }
4760 return 0;
4761 }
4762
4763 cai->found = 1;
4764
4765 /* if the peer has no address (current or default), return failure */
4766 if (ast_sockaddr_isnull(&peer->addr) && ast_sockaddr_isnull(&peer->defaddr)) {
4767 goto return_unref;
4768 }
4769
4770 /* if the peer is being monitored and is currently unreachable, return failure */
4771 if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
4772 goto return_unref;
4773
4774 ast_copy_flags64(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
4775 cai->maxtime = peer->maxms;
4776 cai->capability = peer->capability;
4777 cai->encmethods = peer->encmethods;
4778 cai->authmethods = peer->authmethods;
4779 cai->sockfd = peer->sockfd;
4780 cai->adsi = peer->adsi;
4781 cai->prefs = peer->prefs;
4782 /* Move the calling channel's native codec to the top of the preference list */
4783 if (c) {
4784 int i;
4785
4786 for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
4787 struct ast_format *tmpfmt = ast_format_cap_get_format(
4788 ast_channel_nativeformats(c), i);
4789 iax2_codec_pref_prepend(&cai->prefs, tmpfmt,
4790 ast_format_cap_get_format_framing(ast_channel_nativeformats(c), tmpfmt),
4791 1);
4792 ao2_ref(tmpfmt, -1);
4793 }
4794 }
4795 ast_copy_string(cai->context, peer->context, sizeof(cai->context));
4796 ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
4797 ast_copy_string(cai->username, peer->username, sizeof(cai->username));
4798 ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
4799 ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
4800 ast_copy_string(cai->cid_num, peer->cid_num, sizeof(cai->cid_num));
4801 ast_copy_string(cai->cid_name, peer->cid_name, sizeof(cai->cid_name));
4802 ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
4803 ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
4804 if (ast_strlen_zero(peer->dbsecret)) {
4805 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
4806 } else {
4807 char *family;
4808 char *key = NULL;
4809
4810 family = ast_strdupa(peer->dbsecret);
4811 key = strchr(family, '/');
4812 if (key)
4813 *key++ = '\0';
4814 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
4815 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
4816 goto return_unref;
4817 }
4818 }
4819
4820 if (!ast_sockaddr_isnull(&peer->addr)) {
4821 ast_sockaddr_copy(addr, &peer->addr);
4822 } else {
4823 ast_sockaddr_copy(addr, &peer->defaddr);
4824 }
4825
4826 res = 0;
4827
4828return_unref:
4829 peer_unref(peer);
4830
4831 return res;
4832}
4833
4834static void __auto_congest(const void *nothing)
4835{
4836 int callno = PTR_TO_CALLNO(nothing);
4837 struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_CONGESTION } };
4838 ast_mutex_lock(&iaxsl[callno]);
4839 if (iaxs[callno]) {
4840 iaxs[callno]->initid = -1;
4841 iax2_queue_frame(callno, &f);
4842 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
4843 }
4844 ast_mutex_unlock(&iaxsl[callno]);
4845}
4846
4847static int auto_congest(const void *data)
4848{
4849#ifdef SCHED_MULTITHREADED
4850 if (schedule_action(__auto_congest, data))
4851#endif
4852 __auto_congest(data);
4853 return 0;
4854}
4855
4856static unsigned int iax2_datetime(const char *tz)
4857{
4858 struct timeval t = ast_tvnow();
4859 struct ast_tm tm;
4860 unsigned int tmp;
4861 ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
4862 tmp = (tm.tm_sec >> 1) & 0x1f; /* 5 bits of seconds */
4863 tmp |= (tm.tm_min & 0x3f) << 5; /* 6 bits of minutes */
4864 tmp |= (tm.tm_hour & 0x1f) << 11; /* 5 bits of hours */
4865 tmp |= (tm.tm_mday & 0x1f) << 16; /* 5 bits of day of month */
4866 tmp |= ((tm.tm_mon + 1) & 0xf) << 21; /* 4 bits of month */
4867 tmp |= ((tm.tm_year - 100) & 0x7f) << 25; /* 7 bits of year */
4868 return tmp;
4869}
4870
4871struct parsed_dial_string {
4872 char *username;
4873 char *password;
4874 char *key;
4875 char *peer;
4876 char *port;
4877 char *exten;
4878 char *context;
4879 char *options;
4880};
4881
4882static int send_apathetic_reply(unsigned short callno, unsigned short dcallno,
4883 struct ast_sockaddr *addr, int command, int ts, unsigned char seqno,
4884 int sockfd, struct iax_ie_data *ied)
4885{
4886 struct {
4887 struct ast_iax2_full_hdr f;
4888 struct iax_ie_data ied;
4889 } data;
4890 size_t size = sizeof(struct ast_iax2_full_hdr);
4891
4892 if (ied) {
4893 size += ied->pos;
4894 memcpy(&data.ied, ied->buf, ied->pos);
4895 }
4896
4897 data.f.scallno = htons(0x8000 | callno);
4898 data.f.dcallno = htons(dcallno & ~IAX_FLAG_RETRANS);
4899 data.f.ts = htonl(ts);
4900 data.f.iseqno = seqno;
4901 data.f.oseqno = 0;
4902 data.f.type = AST_FRAME_IAX;
4903 data.f.csub = compress_subclass(command);
4904
4905 iax_outputframe(NULL, &data.f, 0, addr, size - sizeof(struct ast_iax2_full_hdr));
4906
4907 return ast_sendto(sockfd, &data, size, 0, addr);
4908}
4909
4910static void add_empty_calltoken_ie(struct chan_iax2_pvt *pvt, struct iax_ie_data *ied)
4911{
4912 /* first make sure their are two empty bytes left in ied->buf */
4913 if (pvt && ied && (2 < ((int) sizeof(ied->buf) - ied->pos))) {
4914 ied->buf[ied->pos++] = IAX_IE_CALLTOKEN; /* type */
4915 ied->buf[ied->pos++] = 0; /* data size, ZERO in this case */
4916 pvt->calltoken_ie_len = 2;
4917 }
4918}
4919
4920static void resend_with_token(int callno, struct iax_frame *f, const char *newtoken)
4921{
4922 struct chan_iax2_pvt *pvt = iaxs[callno];
4923 int frametype = f->af.frametype;
4924 int subclass = f->af.subclass.integer;
4925 struct {
4926 struct ast_iax2_full_hdr fh;
4927 struct iax_ie_data ied;
4928 } data = {
4929 .ied.buf = { 0 },
4930 .ied.pos = 0,
4931 };
4932 /* total len - header len gives us the frame's IE len */
4933 int ie_data_pos = f->datalen - sizeof(struct ast_iax2_full_hdr);
4934
4935 if (!pvt) {
4936 return; /* this should not be possible if called from socket_process() */
4937 }
4938
4939 /*
4940 * Check to make sure last frame sent is valid for call token resend
4941 * 1. Frame should _NOT_ be encrypted since it starts the IAX dialog
4942 * 2. Frame should _NOT_ already have a destination callno
4943 * 3. Frame must be a valid iax_frame subclass capable of starting dialog
4944 * 4. Pvt must have a calltoken_ie_len which represents the number of
4945 * bytes at the end of the frame used for the previous calltoken ie.
4946 * 5. Pvt's calltoken_ie_len must be _LESS_ than the total IE length
4947 * 6. Total length of f->data must be _LESS_ than size of our data struct
4948 * because f->data must be able to fit within data.
4949 */
4950 if (f->encmethods || f->dcallno || !iax2_allow_new(frametype, subclass, 0)
4951 || !pvt->calltoken_ie_len || (pvt->calltoken_ie_len > ie_data_pos) ||
4952 (f->datalen > sizeof(data))) {
4953
4954 return; /* ignore resend, token was not valid for the dialog */
4955 }
4956
4957 /* token is valid
4958 * 1. Copy frame data over
4959 * 2. Redo calltoken IE, it will always be the last ie in the frame.
4960 * NOTE: Having the ie always be last is not protocol specified,
4961 * it is only an implementation choice. Since we only expect the ie to
4962 * be last for frames we have sent, this can no way be affected by
4963 * another end point.
4964 * 3. Remove frame from queue
4965 * 4. Free old frame
4966 * 5. Clear previous seqnos
4967 * 6. Resend with CALLTOKEN ie.
4968 */
4969
4970 /* ---1.--- */
4971 memcpy(&data, f->data, f->datalen);
4972 data.ied.pos = ie_data_pos;
4973
4974 /* ---2.--- */
4975 /* move to the beginning of the calltoken ie so we can write over it */
4976 data.ied.pos -= pvt->calltoken_ie_len;
4977 iax_ie_append_str(&data.ied, IAX_IE_CALLTOKEN, newtoken);
4978
4979 /* make sure to update token length incase it ever has to be stripped off again */
4980 pvt->calltoken_ie_len = data.ied.pos - ie_data_pos; /* new pos minus old pos tells how big token ie is */
4981
4982 /* ---3.--- */
4983 AST_LIST_REMOVE(&frame_queue[callno], f, list);
4984
4985 /* ---4.--- */
4986 iax2_frame_free(f);
4987
4988 /* ---5.--- */
4989 pvt->oseqno = 0;
4990 pvt->rseqno = 0;
4991 pvt->iseqno = 0;
4992 pvt->aseqno = 0;
4993 if (pvt->peercallno) {
4994 remove_by_peercallno(pvt);
4995 pvt->peercallno = 0;
4996 }
4997
4998 /* ---6.--- */
4999 send_command(pvt, AST_FRAME_IAX, subclass, 0, data.ied.buf, data.ied.pos, -1);
5000}
5001
5002static void requirecalltoken_mark_auto(const char *name, int subclass)
5003{
5004 struct iax2_user *user = NULL;
5005 struct iax2_peer *peer = NULL;
5006
5007 if (ast_strlen_zero(name)) {
5008 return; /* no username given */
5009 }
5010
5011 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(name)) && (user->calltoken_required == CALLTOKEN_AUTO)) {
5012 user->calltoken_required = CALLTOKEN_YES;
5013 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(name, 1)) && (peer->calltoken_required == CALLTOKEN_AUTO)) {
5014 peer->calltoken_required = CALLTOKEN_YES;
5015 }
5016
5017 if (peer) {
5018 peer_unref(peer);
5019 }
5020 if (user) {
5021 user_unref(user);
5022 }
5023}
5024
5025/*!
5026 * \internal
5027 *
5028 * \brief handles calltoken logic for a received iax_frame.
5029 *
5030 * \note frametype must be AST_FRAME_IAX.
5031 *
5032 * \note
5033 * Three different cases are possible here.
5034 * Case 1. An empty calltoken is provided. This means the client supports
5035 * calltokens but has not yet received one from us. In this case
5036 * a full calltoken IE is created and sent in a calltoken fullframe.
5037 * Case 2. A full calltoken is received and must be checked for validity.
5038 * Case 3. No calltoken is received indicating that the client does not
5039 * support calltokens. In this case it is up to the configuration
5040 * to decide how this should be handled (reject or permit without calltoken)
5041 */
5042static int handle_call_token(struct ast_iax2_full_hdr *fh, struct iax_ies *ies,
5043 struct ast_sockaddr *addr, int fd)
5044{
5045#define CALLTOKEN_HASH_FORMAT "%s%u%d" /* address + port + ts + randomcalldata */
5046#define CALLTOKEN_IE_FORMAT "%u?%s" /* time + ? + (40 char hash) */
5047 struct ast_str *buf = ast_str_alloca(256);
5048 time_t t = time(NULL);
5049 char hash[41]; /* 40 char sha1 hash */
5050 int subclass = uncompress_subclass(fh->csub);
5051
5052 /* ----- Case 1 ----- */
5053 if (ies->calltoken && !ies->calltokendata) { /* empty calltoken is provided, client supports calltokens */
5054 struct iax_ie_data ied = {
5055 .buf = { 0 },
5056 .pos = 0,
5057 };
5058
5059 /* create the hash with their address data and our timestamp */
5060 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) t, randomcalltokendata);
5061 ast_sha1_hash(hash, ast_str_buffer(buf));
5062
5063 ast_str_set(&buf, 0, CALLTOKEN_IE_FORMAT, (unsigned int) t, hash);
5064 iax_ie_append_str(&ied, IAX_IE_CALLTOKEN, ast_str_buffer(buf));
5065 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_CALLTOKEN, ntohl(fh->ts), fh->iseqno + 1, fd, &ied);
5066
5067 return 1;
5068
5069 /* ----- Case 2 ----- */
5070 } else if (ies->calltoken && ies->calltokendata) { /* calltoken received, check to see if it is valid */
5071 char *rec_hash = NULL; /* the received hash, make sure it matches with ours. */
5072 char *rec_ts = NULL; /* received timestamp */
5073 unsigned int rec_time; /* received time_t */
5074
5075 /* split the timestamp from the hash data */
5076 rec_hash = strchr((char *) ies->calltokendata, '?');
5077 if (rec_hash) {
5078 *rec_hash++ = '\0';
5079 rec_ts = (char *) ies->calltokendata;
5080 }
5081
5082 /* check that we have valid data before we do any comparisons */
5083 if (!rec_hash || !rec_ts) {
5084 goto reject;
5085 } else if (sscanf(rec_ts, "%u", &rec_time) != 1) {
5086 goto reject;
5087 }
5088
5089 /* create a hash with their address and the _TOKEN'S_ timestamp */
5090 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) rec_time, randomcalltokendata);
5091 ast_sha1_hash(hash, ast_str_buffer(buf));
5092
5093 /* compare hashes and then check timestamp delay */
5094 if (strcmp(hash, rec_hash)) {
5095 ast_log(LOG_WARNING, "Address %s failed CallToken hash inspection\n", ast_sockaddr_stringify(addr));
5096 goto reject; /* received hash does not match ours, reject */
5097 } else if ((t < rec_time) || ((t - rec_time) >= max_calltoken_delay)) {
5098 ast_log(LOG_WARNING, "Too much delay in IAX2 calltoken timestamp from address %s\n", ast_sockaddr_stringify(addr));
5099 goto reject; /* too much delay, reject */
5100 }
5101
5102 /* at this point the call token is valid, returning 0
5103 * will allow socket_process to continue as usual */
5104 requirecalltoken_mark_auto(ies->username, subclass);
5105 return 0;
5106
5107 /* ----- Case 3 ----- */
5108 } else { /* calltokens are not supported for this client, how do we respond? */
5109 if (calltoken_required(addr, ies->username, subclass)) {
5110 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"));
5111 goto reject;
5112 }
5113 return 0; /* calltoken is not required for this addr, so permit it. */
5114 }
5115
5116reject:
5117 /* received frame has failed calltoken inspection, send apathetic reject messages */
5118 if (subclass == IAX_COMMAND_REGREQ || subclass == IAX_COMMAND_REGREL) {
5119 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
5120 } else {
5121 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
5122 }
5123
5124 return 1;
5125}
5126
5127/*!
5128 * \brief Parses an IAX dial string into its component parts.
5129 * \param data the string to be parsed
5130 * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
5131 *
5132 * This function parses the string and fills the structure
5133 * with pointers to its component parts. The input string
5134 * will be modified.
5135 *
5136 * \note This function supports both plaintext passwords and RSA
5137 * key names; if the password string is formatted as '[keyname]',
5138 * then the keyname will be placed into the key field, and the
5139 * password field will be set to NULL.
5140 *
5141 * \note The dial string format is:
5142 * \verbatim [username[:password]@]peer[:port][/exten[@context]][/options] \endverbatim
5143 */
5144static void parse_dial_string(char *data, struct parsed_dial_string *pds)
5145{
5146 char *outkey = NULL;
5147
5148 if (ast_strlen_zero(data))
5149 return;
5150
5151 pds->peer = strsep(&data, "/");
5152 pds->exten = strsep(&data, "/");
5153 pds->options = data;
5154
5155 if (pds->exten) {
5156 data = pds->exten;
5157 pds->exten = strsep(&data, "@");
5158 pds->context = data;
5159 }
5160
5161 if (strchr(pds->peer, '@')) {
5162 data = pds->peer;
5163 pds->username = strsep(&data, "@");
5164 pds->peer = data;
5165 }
5166
5167 if (pds->username) {
5168 data = pds->username;
5169 pds->username = strsep(&data, ":");
5170 pds->password = strsep(&data, ":");
5171 outkey = data;
5172 }
5173
5174 data = pds->peer;
5175 pds->peer = strsep(&data, ":");
5176 pds->port = data;
5177
5178 /*
5179 * Check for a key name wrapped in [] in the password position.
5180 * If found, move it to the key field instead.
5181 * Also allow for both key and secret to be specified, now that
5182 * encryption is possible with RSA authentication.
5183 */
5184
5185 if (pds->password && (pds->password[0] == '[')) { /* key (then maybe secret) */
5186 pds->key = ast_strip_quoted(pds->password, "[", "]");
5187 if (ast_strlen_zero(outkey)) {
5188 pds->password = NULL;
5189 ast_debug(1, "Outkey (%s), no secret\n", pds->key);
5190 } else {
5191 pds->password = outkey;
5192 ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
5193 }
5194 } else if (outkey && (outkey[0] == '[')) { /* secret, then key */
5195 pds->key = ast_strip_quoted(outkey, "[", "]");
5196 if (ast_strlen_zero(pds->password)) {
5197 ast_debug(1, "Outkey (%s), no secret\n", pds->key);
5198 } else {
5199 ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
5200 }
5201 }
5202}
5203
5204static int iax2_call(struct ast_channel *c, const char *dest, int timeout)
5205{
5206 struct ast_sockaddr addr;
5207 char *l=NULL, *n=NULL, *tmpstr;
5208 struct iax_ie_data ied;
5209 char *defaultrdest = "s";
5210 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5211 struct parsed_dial_string pds;
5212 struct create_addr_info cai;
5213 struct ast_var_t *var;
5214 struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
5215 const char* osp_token_ptr;
5216 unsigned int osp_token_length;
5217 unsigned char osp_block_index;
5218 unsigned int osp_block_length;
5219 unsigned char osp_buffer[256];
5220 char encoded_prefs[32];
5221 iax2_format iax2_tmpfmt;
5222
5223 if ((ast_channel_state(c) != AST_STATE_DOWN) && (ast_channel_state(c) != AST_STATE_RESERVED)) {
5224 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", ast_channel_name(c));
5225 return -1;
5226 }
5227
5228 memset(&cai, 0, sizeof(cai));
5229 cai.encmethods = iax2_encryption;
5230 cai.authmethods = iax2_authmethods;
5231
5232 memset(&pds, 0, sizeof(pds));
5233 tmpstr = ast_strdupa(dest);
5234 parse_dial_string(tmpstr, &pds);
5235
5236 if (ast_strlen_zero(pds.peer)) {
5237 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", dest);
5238 return -1;
5239 }
5240 if (!pds.exten) {
5241 pds.exten = defaultrdest;
5242 }
5243 if (create_addr(pds.peer, c, &addr, &cai)) {
5244 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
5245 return -1;
5246 }
5247
5248 if (ast_test_flag64(&cai, IAX_FORCE_ENCRYPT) ||
5249 ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
5250 if (!cai.encmethods) {
5251 ast_log(LOG_WARNING, "Encryption forced for call, but not enabled\n");
5252 ast_channel_hangupcause_set(c, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
5253 return -1;
5254 }
5255 if (((cai.authmethods & IAX_AUTH_RSA) || (cai.authmethods & IAX_AUTH_MD5) || (cai.authmethods & IAX_AUTH_PLAINTEXT)) &&
5256 ast_strlen_zero(cai.secret) && ast_strlen_zero(pds.password)) {
5257 ast_log(LOG_WARNING, "Call terminated. Encryption forced but no secret provided\n");
5258 return -1;
5259 }
5260 }
5261
5262 if (!pds.username && !ast_strlen_zero(cai.username))
5263 pds.username = cai.username;
5264 if (!pds.password && !ast_strlen_zero(cai.secret))
5265 pds.password = cai.secret;
5266 if (!pds.key && !ast_strlen_zero(cai.outkey))
5267 pds.key = cai.outkey;
5268 if (!pds.context && !ast_strlen_zero(cai.peercontext))
5269 pds.context = cai.peercontext;
5270
5271 /* Keep track of the context for outgoing calls too */
5272 ast_channel_context_set(c, cai.context);
5273
5274 if (pds.port) {
5275 int bindport;
5276 if (ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
5277 ast_sockaddr_set_port(&addr, bindport);
5278 }
5279 }
5280
5281 l = ast_channel_connected(c)->id.number.valid ? ast_channel_connected(c)->id.number.str : NULL;
5282 n = ast_channel_connected(c)->id.name.valid ? ast_channel_connected(c)->id.name.str : NULL;
5283
5284 /* Now build request */
5285 memset(&ied, 0, sizeof(ied));
5286
5287 /* On new call, first IE MUST be IAX version of caller */
5288 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
5289 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
5290 if (pds.options && strchr(pds.options, 'a')) {
5291 /* Request auto answer */
5292 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
5293 }
5294
5295 /* WARNING: this breaks down at 190 bits! */
5296 iax2_codec_pref_convert(&cai.prefs, encoded_prefs, sizeof(encoded_prefs), 1);
5297 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, encoded_prefs);
5298
5299 if (l) {
5300 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
5301 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
5302 ast_party_id_presentation(&ast_channel_connected(c)->id));
5303 } else if (n) {
5304 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
5305 ast_party_id_presentation(&ast_channel_connected(c)->id));
5306 } else {
5307 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
5308 }
5309
5310 iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, ast_channel_connected(c)->id.number.plan);
5311 iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, ast_channel_dialed(c)->transit_network_select);
5312 iax_ie_append_int(&ied, IAX_IE_CALLINGANI2, ast_channel_connected(c)->ani2);
5313
5314 if (n)
5315 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
5316 if (ast_test_flag64(iaxs[callno], IAX_SENDANI)
5317 && ast_channel_connected(c)->ani.number.valid
5318 && ast_channel_connected(c)->ani.number.str) {
5319 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, ast_channel_connected(c)->ani.number.str);
5320 }
5321
5322 if (!ast_strlen_zero(ast_channel_language(c)))
5323 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, ast_channel_language(c));
5324 if (!ast_strlen_zero(ast_channel_dialed(c)->number.str)) {
5325 iax_ie_append_str(&ied, IAX_IE_DNID, ast_channel_dialed(c)->number.str);
5326 }
5327 if (ast_channel_redirecting(c)->from.number.valid
5328 && !ast_strlen_zero(ast_channel_redirecting(c)->from.number.str)) {
5329 iax_ie_append_str(&ied, IAX_IE_RDNIS, ast_channel_redirecting(c)->from.number.str);
5330 }
5331
5332 if (pds.context)
5333 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
5334
5335 if (pds.username)
5336 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
5337
5338 if (cai.encmethods)
5339 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
5340
5341 ast_mutex_lock(&iaxsl[callno]);
5342
5343 if (!ast_strlen_zero(ast_channel_context(c)))
5344 ast_string_field_set(iaxs[callno], context, ast_channel_context(c));
5345
5346 if (pds.username)
5347 ast_string_field_set(iaxs[callno], username, pds.username);
5348
5349 iaxs[callno]->encmethods = cai.encmethods;
5350
5351 iaxs[callno]->adsi = cai.adsi;
5352
5353 ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
5354 ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
5355
5356 if (pds.key)
5357 ast_string_field_set(iaxs[callno], outkey, pds.key);
5358 if (pds.password)
5359 ast_string_field_set(iaxs[callno], secret, pds.password);
5360
5361 iax2_tmpfmt = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(c));
5362 iax_ie_append_int(&ied, IAX_IE_FORMAT, (int) iax2_tmpfmt);
5363 iax_ie_append_versioned_uint64(&ied, IAX_IE_FORMAT2, 0, iax2_tmpfmt);
5364
5365 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, (int) iaxs[callno]->capability);
5366 iax_ie_append_versioned_uint64(&ied, IAX_IE_CAPABILITY2, 0, iaxs[callno]->capability);
5367 iax_ie_append_short(&ied, IAX_IE_ADSICPE, ast_channel_adsicpe(c));
5368 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
5369
5370 if (iaxs[callno]->maxtime) {
5371 /* Initialize pingtime and auto-congest time */
5372 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
5373 iaxs[callno]->initid = iax2_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
5374 } else if (autokill) {
5375 iaxs[callno]->pingtime = autokill / 2;
5376 iaxs[callno]->initid = iax2_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
5377 }
5378
5379 /* Check if there is an OSP token */
5380 osp_token_ptr = pbx_builtin_getvar_helper(c, "IAX2OSPTOKEN");
5381 if (!ast_strlen_zero(osp_token_ptr)) {
5382 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
5383 osp_block_index = 0;
5384 while (osp_token_length > 0) {
5385 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
5386 osp_buffer[0] = osp_block_index;
5387 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
5388 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
5389 osp_block_index++;
5390 osp_token_ptr += osp_block_length;
5391 osp_token_length -= osp_block_length;
5392 }
5393 } else
5394 ast_log(LOG_WARNING, "OSP token is too long\n");
5395 } else if (iaxdebug)
5396 ast_debug(1, "OSP token is undefined\n");
5397
5398 /* send the command using the appropriate socket for this peer */
5399 iaxs[callno]->sockfd = cai.sockfd;
5400
5401 /* Add remote vars */
5402 if (variablestore) {
5403 AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
5404 ast_debug(1, "Found an IAX variable store on this channel\n");
5405 AST_LIST_LOCK(variablelist);
5406 AST_LIST_TRAVERSE(variablelist, var, entries) {
5407 char tmp[256];
5408 int i;
5409 ast_debug(1, "Found IAXVAR '%s' with value '%s' (to transmit)\n", ast_var_name(var), ast_var_value(var));
5410 /* Automatically divide the value up into sized chunks */
5411 for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) + 1)) {
5412 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var), ast_var_value(var) + i);
5413 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
5414 }
5415 }
5416 AST_LIST_UNLOCK(variablelist);
5417 }
5418
5419 /* Transmit the string in a "NEW" request */
5420 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
5421 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
5422
5423 ast_mutex_unlock(&iaxsl[callno]);
5424 ast_setstate(c, AST_STATE_RINGING);
5425
5426 return 0;
5427}
5428
5429static int iax2_hangup(struct ast_channel *c)
5430{
5431 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5432 struct iax_ie_data ied;
5433 int alreadygone;
5434 memset(&ied, 0, sizeof(ied));
5435 ast_mutex_lock(&iaxsl[callno]);
5436 if (callno && iaxs[callno]) {
5437 ast_debug(1, "We're hanging up %s now...\n", ast_channel_name(c));
5438 alreadygone = ast_test_flag64(iaxs[callno], IAX_ALREADYGONE);
5439 /* Send the hangup unless we have had a transmission error or are already gone */
5440 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)ast_channel_hangupcause(c));
5441 if (!iaxs[callno]->error && !alreadygone) {
5442 if (send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1)) {
5443 ast_log(LOG_WARNING, "No final packet could be sent for callno %d\n", callno);
5444 }
5445 if (!iaxs[callno]) {
5446 ast_mutex_unlock(&iaxsl[callno]);
5447 return 0;
5448 }
5449 }
5450 /* Explicitly predestroy it */
5451 iax2_predestroy(callno);
5452 /* If we were already gone to begin with, destroy us now */
5453 if (iaxs[callno] && alreadygone) {
5454 ast_debug(1, "Really destroying %s now...\n", ast_channel_name(c));
5455 iax2_destroy(callno);
5456 } else if (iaxs[callno]) {
5457 if (ast_sched_add(sched, 10000, scheduled_destroy, CALLNO_TO_PTR(callno)) < 0) {
5458 ast_log(LOG_ERROR, "Unable to schedule iax2 callno %d destruction?!! Destroying immediately.\n", callno);
5459 iax2_destroy(callno);
5460 }
5461 }
5462 } else if (ast_channel_tech_pvt(c)) {
5463 /* If this call no longer exists, but the channel still
5464 * references it we need to set the channel's tech_pvt to null
5465 * to avoid ast_channel_free() trying to free it.
5466 */
5467 ast_channel_tech_pvt_set(c, NULL);
5468 }
5469 ast_mutex_unlock(&iaxsl[callno]);
5470 ast_verb(3, "Hungup '%s'\n", ast_channel_name(c));
5471 return 0;
5472}
5473
5474/*!
5475 * \note expects the pvt to be locked
5476 */
5477static int wait_for_peercallno(struct chan_iax2_pvt *pvt)
5478{
5479 unsigned short callno = pvt->callno;
5480
5481 if (!pvt->peercallno) {
5482 /* We don't know the remote side's call number, yet. :( */
5483 int count = 10;
5484 while (count-- && pvt && !pvt->peercallno) {
5485 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
5486 pvt = iaxs[callno];
5487 }
5488 if (!pvt || !pvt->peercallno) {
5489 return -1;
5490 }
5491 }
5492
5493 return 0;
5494}
5495
5496static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
5497{
5498 struct ast_option_header *h;
5499 int res;
5500
5501 switch (option) {
5502 case AST_OPTION_TXGAIN:
5503 case AST_OPTION_RXGAIN:
5504 /* these two cannot be sent, because they require a result */
5505 errno = ENOSYS;
5506 return -1;
5507 case AST_OPTION_OPRMODE:
5508 errno = EINVAL;
5509 return -1;
5510 case AST_OPTION_SECURE_SIGNALING:
5511 case AST_OPTION_SECURE_MEDIA:
5512 {
5513 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5514 ast_mutex_lock(&iaxsl[callno]);
5515 if ((*(int *) data)) {
5516 ast_set_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
5517 } else {
5518 ast_clear_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
5519 }
5520 ast_mutex_unlock(&iaxsl[callno]);
5521 return 0;
5522 }
5523 /* These options are sent to the other side across the network where
5524 * they will be passed to whatever channel is bridged there. Don't
5525 * do anything silly like pass an option that transmits pointers to
5526 * memory on this machine to a remote machine to use */
5527 case AST_OPTION_TONE_VERIFY:
5528 case AST_OPTION_TDD:
5529 case AST_OPTION_RELAXDTMF:
5530 case AST_OPTION_AUDIO_MODE:
5531 case AST_OPTION_DIGIT_DETECT:
5532 case AST_OPTION_FAX_DETECT:
5533 {
5534 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5535 struct chan_iax2_pvt *pvt;
5536
5537 ast_mutex_lock(&iaxsl[callno]);
5538 pvt = iaxs[callno];
5539
5540 if (wait_for_peercallno(pvt)) {
5541 ast_mutex_unlock(&iaxsl[callno]);
5542 return -1;
5543 }
5544
5545 ast_mutex_unlock(&iaxsl[callno]);
5546
5547 if (!(h = ast_malloc(datalen + sizeof(*h)))) {
5548 return -1;
5549 }
5550
5551 h->flag = AST_OPTION_FLAG_REQUEST;
5552 h->option = htons(option);
5553 memcpy(h->data, data, datalen);
5554 res = send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_CONTROL,
5555 AST_CONTROL_OPTION, 0, (unsigned char *) h,
5556 datalen + sizeof(*h), -1);
5557 ast_free(h);
5558 return res;
5559 }
5560 default:
5561 return -1;
5562 }
5563
5564 /* Just in case someone does a break instead of a return */
5565 return -1;
5566}
5567
5568static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen)
5569{
5570 switch (option) {
5571 case AST_OPTION_SECURE_SIGNALING:
5572 case AST_OPTION_SECURE_MEDIA:
5573 {
5574 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5575 ast_mutex_lock(&iaxsl[callno]);
5576 *((int *) data) = ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT) ? 1 : 0;
5577 ast_mutex_unlock(&iaxsl[callno]);
5578 return 0;
5579 }
5580 default:
5581 return -1;
5582 }
5583}
5584
5585static struct ast_frame *iax2_read(struct ast_channel *c)
5586{
5587 ast_debug(1, "I should never be called!\n");
5588 return &ast_null_frame;
5589}
5590
5591static int iax2_key_rotate(const void *vpvt)
5592{
5593 int res = 0;
5594 struct chan_iax2_pvt *pvt = (void *) vpvt;
5595 struct MD5Context md5;
5596 char key[17] = "";
5597 struct iax_ie_data ied = {
5598 .pos = 0,
5599 };
5600
5601 ast_mutex_lock(&iaxsl[pvt->callno]);
5602 pvt->keyrotateid = ast_sched_add(sched, 120000 + (ast_random() % 180001), iax2_key_rotate, vpvt);
5603
5604 snprintf(key, sizeof(key), "%lX", (unsigned long)ast_random());
5605
5606 MD5Init(&md5);
5607 MD5Update(&md5, (unsigned char *) key, strlen(key));
5608 MD5Final((unsigned char *) key, &md5);
5609
5610 IAX_DEBUGDIGEST("Sending", key);
5611
5612 iax_ie_append_raw(&ied, IAX_IE_CHALLENGE, key, 16);
5613
5614 res = send_command(pvt, AST_FRAME_IAX, IAX_COMMAND_RTKEY, 0, ied.buf, ied.pos, -1);
5615
5616 build_ecx_key((unsigned char *) key, pvt);
5617
5618 ast_mutex_unlock(&iaxsl[pvt->callno]);
5619
5620 return res;
5621}
5622
5623#if defined(IAX2_NATIVE_BRIDGING)
5624static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
5625{
5626 int res;
5627 struct iax_ie_data ied0;
5628 struct iax_ie_data ied1;
5629 unsigned int transferid = (unsigned int)ast_random();
5630
5631 if (IAX_CALLENCRYPTED(iaxs[callno0]) || IAX_CALLENCRYPTED(iaxs[callno1])) {
5632 ast_debug(1, "transfers are not supported for encrypted calls at this time\n");
5633 ast_set_flag64(iaxs[callno0], IAX_NOTRANSFER);
5634 ast_set_flag64(iaxs[callno1], IAX_NOTRANSFER);
5635 return 0;
5636 }
5637
5638 memset(&ied0, 0, sizeof(ied0));
5639 iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
5640 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
5641 iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
5642
5643 memset(&ied1, 0, sizeof(ied1));
5644 iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
5645 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
5646 iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
5647
5648 res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
5649 if (res)
5650 return -1;
5651 res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
5652 if (res)
5653 return -1;
5654 iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
5655 iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
5656 return 0;
5657}
5658#endif /* defined(IAX2_NATIVE_BRIDGING) */
5659
5660#if defined(IAX2_NATIVE_BRIDGING)
5661static void lock_both(unsigned short callno0, unsigned short callno1)
5662{
5663 ast_mutex_lock(&iaxsl[callno0]);
5664 while (ast_mutex_trylock(&iaxsl[callno1])) {
5665 DEADLOCK_AVOIDANCE(&iaxsl[callno0]);
5666 }
5667}
5668#endif /* defined(IAX2_NATIVE_BRIDGING) */
5669
5670#if defined(IAX2_NATIVE_BRIDGING)
5671static void unlock_both(unsigned short callno0, unsigned short callno1)
5672{
5673 ast_mutex_unlock(&iaxsl[callno1]);
5674 ast_mutex_unlock(&iaxsl[callno0]);
5675}
5676#endif /* defined(IAX2_NATIVE_BRIDGING) */
5677
5678#if defined(IAX2_NATIVE_BRIDGING)
5679static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
5680{
5681 struct ast_channel *cs[3];
5682 struct ast_channel *who, *other;
5683 int to = -1;
5684 int res = -1;
5685 int transferstarted=0;
5686 struct ast_frame *f;
5687 unsigned short callno0 = PTR_TO_CALLNO(ast_channel_tech_pvt(c0));
5688 unsigned short callno1 = PTR_TO_CALLNO(ast_channel_tech_pvt(c1));
5689 struct timeval waittimer = {0, 0};
5690
5691 /* We currently do not support native bridging if a timeoutms value has been provided */
5692 if (timeoutms > 0) {
5693 return AST_BRIDGE_FAILED;
5694 }
5695
5696 timeoutms = -1;
5697
5698 lock_both(callno0, callno1);
5699 if (!iaxs[callno0] || !iaxs[callno1]) {
5700 unlock_both(callno0, callno1);
5701 return AST_BRIDGE_FAILED;
5702 }
5703 /* Put them in native bridge mode */
5704 if (!(flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
5705 iaxs[callno0]->bridgecallno = callno1;
5706 iaxs[callno1]->bridgecallno = callno0;
5707 }
5708 unlock_both(callno0, callno1);
5709
5710 /* If not, try to bridge until we can execute a transfer, if we can */
5711 cs[0] = c0;
5712 cs[1] = c1;
5713 for (/* ever */;;) {
5714 /* Check in case we got masqueraded into */
5715 if ((ast_channel_tech(c0) != &iax2_tech) || (ast_channel_tech(c1) != &iax2_tech)) {
5716 ast_verb(3, "Can't masquerade, we're different...\n");
5717 /* Remove from native mode */
5718 if (ast_channel_tech(c0) == &iax2_tech) {
5719 ast_mutex_lock(&iaxsl[callno0]);
5720 iaxs[callno0]->bridgecallno = 0;
5721 ast_mutex_unlock(&iaxsl[callno0]);
5722 }
5723 if (ast_channel_tech(c1) == &iax2_tech) {
5724 ast_mutex_lock(&iaxsl[callno1]);
5725 iaxs[callno1]->bridgecallno = 0;
5726 ast_mutex_unlock(&iaxsl[callno1]);
5727 }
5728 return AST_BRIDGE_FAILED_NOWARN;
5729 }
5730 if (!(ast_format_cap_identical(ast_channel_nativeformats(c0), ast_channel_nativeformats(c1)))) {
5731 struct ast_str *c0_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5732 struct ast_str *c1_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5733
5734 ast_verb(3, "Operating with different codecs [%s] [%s] , can't native bridge...\n",
5735 ast_format_cap_get_names(ast_channel_nativeformats(c0), &c0_buf),
5736 ast_format_cap_get_names(ast_channel_nativeformats(c1), &c1_buf));
5737
5738 /* Remove from native mode */
5739 lock_both(callno0, callno1);
5740 if (iaxs[callno0])
5741 iaxs[callno0]->bridgecallno = 0;
5742 if (iaxs[callno1])
5743 iaxs[callno1]->bridgecallno = 0;
5744 unlock_both(callno0, callno1);
5745 return AST_BRIDGE_FAILED_NOWARN;
5746 }
5747 /* check if transferred and if we really want native bridging */
5748 if (!transferstarted && !ast_test_flag64(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag64(iaxs[callno1], IAX_NOTRANSFER)) {
5749 /* Try the transfer */
5750 if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
5751 ast_test_flag64(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag64(iaxs[callno1], IAX_TRANSFERMEDIA)))
5752 ast_log(LOG_WARNING, "Unable to start the transfer\n");
5753 transferstarted = 1;
5754 }
5755 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
5756 /* Call has been transferred. We're no longer involved */
5757 struct timeval now = ast_tvnow();
5758 if (ast_tvzero(waittimer)) {
5759 waittimer = now;
5760 } else if (now.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
5761 ast_channel_softhangup_internal_flag_add(c0, AST_SOFTHANGUP_DEV);
5762 ast_channel_softhangup_internal_flag_add(c1, AST_SOFTHANGUP_DEV);
5763 *fo = NULL;
5764 *rc = c0;
5765 res = AST_BRIDGE_COMPLETE;
5766 break;
5767 }
5768 }
5769 to = 1000;
5770 who = ast_waitfor_n(cs, 2, &to);
5771 /* XXX This will need to be updated to calculate
5772 * timeout correctly once timeoutms is allowed to be
5773 * > 0. Right now, this can go badly if the waitfor
5774 * times out in less than a millisecond
5775 */
5776 if (timeoutms > -1) {
5777 timeoutms -= (1000 - to);
5778 if (timeoutms < 0)
5779 timeoutms = 0;
5780 }
5781 if (!who) {
5782 if (!timeoutms) {
5783 res = AST_BRIDGE_RETRY;
5784 break;
5785 }
5786 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
5787 res = AST_BRIDGE_FAILED;
5788 break;
5789 }
5790 continue;
5791 }
5792 f = ast_read(who);
5793 if (!f) {
5794 *fo = NULL;
5795 *rc = who;
5796 res = AST_BRIDGE_COMPLETE;
5797 break;
5798 }
5799 other = (who == c0) ? c1 : c0; /* the 'other' channel */
5800 if (f->frametype == AST_FRAME_CONTROL) {
5801 switch (f->subclass.integer) {
5802 case AST_CONTROL_VIDUPDATE:
5803 case AST_CONTROL_SRCUPDATE:
5804 case AST_CONTROL_SRCCHANGE:
5805 case AST_CONTROL_T38_PARAMETERS:
5806 ast_write(other, f);
5807 break;
5808 case AST_CONTROL_PVT_CAUSE_CODE:
5809 ast_channel_hangupcause_hash_set(other, f->data.ptr, f->datalen);
5810 break;
5811 default:
5812 *fo = f;
5813 *rc = who;
5814 res = AST_BRIDGE_COMPLETE;
5815 break;
5816 }
5817 if (res == AST_BRIDGE_COMPLETE) {
5818 break;
5819 }
5820 } else if (f->frametype == AST_FRAME_VOICE
5821 || f->frametype == AST_FRAME_TEXT
5822 || f->frametype == AST_FRAME_VIDEO
5823 || f->frametype == AST_FRAME_IMAGE) {
5824 ast_write(other, f);
5825 } else if (f->frametype == AST_FRAME_DTMF) {
5826 /* monitored dtmf take out of the bridge.
5827 * check if we monitor the specific source.
5828 */
5829 int monitored_source = (who == c0) ? AST_BRIDGE_DTMF_CHANNEL_0 : AST_BRIDGE_DTMF_CHANNEL_1;
5830
5831 if (flags & monitored_source) {
5832 *rc = who;
5833 *fo = f;
5834 res = AST_BRIDGE_COMPLETE;
5835 /* Remove from native mode */
5836 break;
5837 }
5838 ast_write(other, f);
5839 }
5840 ast_frfree(f);
5841 /* Swap who gets priority */
5842 cs[2] = cs[0];
5843 cs[0] = cs[1];
5844 cs[1] = cs[2];
5845 }
5846 lock_both(callno0, callno1);
5847 if(iaxs[callno0])
5848 iaxs[callno0]->bridgecallno = 0;
5849 if(iaxs[callno1])
5850 iaxs[callno1]->bridgecallno = 0;
5851 unlock_both(callno0, callno1);
5852 return res;
5853}
5854#endif /* defined(IAX2_NATIVE_BRIDGING) */
5855
5856static int iax2_answer(struct ast_channel *c)
5857{
5858 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5859 ast_debug(1, "Answering IAX2 call\n");
5860 return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
5861}
5862
5863static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
5864{
5865 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5866 struct chan_iax2_pvt *pvt;
5867 int res = 0;
5868
5869 if (iaxdebug)
5870 ast_debug(1, "Indicating condition %d\n", condition);
5871
5872 ast_mutex_lock(&iaxsl[callno]);
5873 pvt = iaxs[callno];
5874
5875 if (wait_for_peercallno(pvt)) {
5876 res = -1;
5877 goto done;
5878 }
5879
5880 switch (condition) {
5881 case AST_CONTROL_HOLD:
5882 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
5883 ast_moh_start(c, data, pvt->mohinterpret);
5884 goto done;
5885 }
5886 break;
5887 case AST_CONTROL_UNHOLD:
5888 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
5889 ast_moh_stop(c);
5890 goto done;
5891 }
5892 break;
5893 case AST_CONTROL_CONNECTED_LINE:
5894 case AST_CONTROL_REDIRECTING:
5895 if (!ast_test_flag64(pvt, IAX_SENDCONNECTEDLINE)) {
5896 /* We are not configured to allow sending these updates. */
5897 ast_debug(2, "Callno %d: Config blocked sending control frame %d.\n",
5898 callno, condition);
5899 goto done;
5900 }
5901 break;
5902 case AST_CONTROL_PVT_CAUSE_CODE:
5903 case AST_CONTROL_MASQUERADE_NOTIFY:
5904 res = -1;
5905 goto done;
5906 }
5907
5908 res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
5909
5910done:
5911 ast_mutex_unlock(&iaxsl[callno]);
5912
5913 return res;
5914}
5915
5916static int iax2_transfer(struct ast_channel *c, const char *dest)
5917{
5918 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5919 struct iax_ie_data ied = { "", };
5920 char tmp[256], *context;
5921 enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
5922 ast_copy_string(tmp, dest, sizeof(tmp));
5923 context = strchr(tmp, '@');
5924 if (context) {
5925 *context = '\0';
5926 context++;
5927 }
5928 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
5929 if (context)
5930 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
5931 ast_debug(1, "Transferring '%s' to '%s'\n", ast_channel_name(c), dest);
5932 ast_queue_control_data(c, AST_CONTROL_TRANSFER, &message, sizeof(message));
5933 return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
5934}
5935
5936static int iax2_getpeertrunk(struct ast_sockaddr addr)
5937{
5938 struct iax2_peer *peer;
5939 int res = 0;
5940 struct ao2_iterator i;
5941
5942 i = ao2_iterator_init(peers, 0);
5943 while ((peer = ao2_iterator_next(&i))) {
5944
5945 if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
5946 res = ast_test_flag64(peer, IAX_TRUNK);
5947 peer_unref(peer);
5948 break;
5949 }
5950 peer_unref(peer);
5951 }
5952 ao2_iterator_destroy(&i);
5953
5954 return res;
5955}
5956
5957/*! \brief Create new call, interface with the PBX core */
5958static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capability,
5959 struct iax2_codec_pref *prefs, const struct ast_assigned_ids *assignedids,
5960 const struct ast_channel *requestor, unsigned int cachable)
5961{
5962 struct ast_channel *tmp = NULL;
5963 struct chan_iax2_pvt *i;
5964 struct iax2_peer *peer;
5965 struct ast_variable *v = NULL;
5966 struct ast_format_cap *native;
5967 struct ast_format *tmpfmt;
5968 ast_callid callid;
5969 char *peer_name = NULL;
5970
5971 if (!(i = iaxs[callno])) {
5972 ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
5973 return NULL;
5974 }
5975
5976 if (!capability) {
5977 ast_log(LOG_WARNING, "No formats specified for call to: IAX2/%s-%d\n",
5978 i->host, i->callno);
5979 return NULL;
5980 }
5981 native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
5982 if (!native) {
5983 return NULL;
5984 }
5985 if (iax2_codec_pref_best_bitfield2cap(capability, prefs, native)
5986 || !ast_format_cap_count(native)) {
5987 ast_log(LOG_WARNING, "No requested formats available for call to: IAX2/%s-%d\n",
5988 i->host, i->callno);
5989 ao2_ref(native, -1);
5990 return NULL;
5991 }
5992
5993 if (!ast_strlen_zero(i->peer)) {
5994 peer_name = ast_strdupa(i->peer);
5995 } else if (!ast_strlen_zero(i->host)) {
5996 peer_name = ast_strdupa(i->host);
5997 }
5998
5999 /* Don't hold call lock while making a channel or looking up a peer */
6000 ast_mutex_unlock(&iaxsl[callno]);
6001
6002 if (!ast_strlen_zero(peer_name)) {
6003 peer = find_peer(peer_name, 1);
6004 if (peer && peer->endpoint) {
6005 tmp = ast_channel_alloc_with_endpoint(1, state, i->cid_num, i->cid_name,
6006 i->accountcode, i->exten, i->context, assignedids, requestor,
6007 i->amaflags, peer->endpoint, "IAX2/%s-%d", i->host, i->callno);
6008 }
6009 ao2_cleanup(peer);
6010 }
6011
6012 if (!tmp) {
6013 tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode,
6014 i->exten, i->context, assignedids, requestor, i->amaflags, "IAX2/%s-%d",
6015 i->host, i->callno);
6016 }
6017
6018 ast_mutex_lock(&iaxsl[callno]);
6019 if (i != iaxs[callno]) {
6020 if (tmp) {
6021 /* unlock and relock iaxsl[callno] to preserve locking order */
6022 ast_mutex_unlock(&iaxsl[callno]);
6023 ast_channel_unlock(tmp);
6024 tmp = ast_channel_release(tmp);
6025 ast_mutex_lock(&iaxsl[callno]);
6026 }
6027 ao2_ref(native, -1);
6028 return NULL;
6029 }
6030 if (!tmp) {
6031 ao2_ref(native, -1);
6032 return NULL;
6033 }
6034
6035 ast_channel_stage_snapshot(tmp);
6036
6037 if ((callid = iaxs[callno]->callid)) {
6038 ast_channel_callid_set(tmp, callid);
6039 }
6040
6041 ast_channel_tech_set(tmp, &iax2_tech);
6042
6043 /* We can support any format by default, until we get restricted */
6044 ast_channel_nativeformats_set(tmp, native);
6045 tmpfmt = ast_format_cap_get_format(native, 0);
6046
6047 ast_channel_set_readformat(tmp, tmpfmt);
6048 ast_channel_set_rawreadformat(tmp, tmpfmt);
6049 ast_channel_set_writeformat(tmp, tmpfmt);
6050 ast_channel_set_rawwriteformat(tmp, tmpfmt);
6051
6052 ao2_ref(tmpfmt, -1);
6053 ao2_ref(native, -1);
6054
6055 ast_channel_tech_pvt_set(tmp, CALLNO_TO_PTR(i->callno));
6056
6057 if (!ast_strlen_zero(i->parkinglot))
6058 ast_channel_parkinglot_set(tmp, i->parkinglot);
6059 /* Don't use ast_set_callerid() here because it will
6060 * generate a NewCallerID event before the NewChannel event */
6061 if (!ast_strlen_zero(i->ani)) {
6062 ast_channel_caller(tmp)->ani.number.valid = 1;
6063 ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->ani);
6064 } else if (!ast_strlen_zero(i->cid_num)) {
6065 ast_channel_caller(tmp)->ani.number.valid = 1;
6066 ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->cid_num);
6067 }
6068 ast_channel_dialed(tmp)->number.str = ast_strdup(i->dnid);
6069 if (!ast_strlen_zero(i->rdnis)) {
6070 ast_channel_redirecting(tmp)->from.number.valid = 1;
6071 ast_channel_redirecting(tmp)->from.number.str = ast_strdup(i->rdnis);
6072 }
6073 ast_channel_caller(tmp)->ani2 = i->calling_ani2;
6074 ast_channel_caller(tmp)->id.name.presentation = i->calling_pres;
6075 ast_channel_caller(tmp)->id.number.presentation = i->calling_pres;
6076 ast_channel_caller(tmp)->id.number.plan = i->calling_ton;
6077 ast_channel_dialed(tmp)->transit_network_select = i->calling_tns;
6078 if (!ast_strlen_zero(i->language))
6079 ast_channel_language_set(tmp, i->language);
6080 if (!ast_strlen_zero(i->accountcode))
6081 ast_channel_accountcode_set(tmp, i->accountcode);
6082 if (i->amaflags)
6083 ast_channel_amaflags_set(tmp, i->amaflags);
6084 ast_channel_context_set(tmp, i->context);
6085 ast_channel_exten_set(tmp, i->exten);
6086 if (i->adsi)
6087 ast_channel_adsicpe_set(tmp, i->peeradsicpe);
6088 else
6089 ast_channel_adsicpe_set(tmp, AST_ADSI_UNAVAILABLE);
6090 i->owner = tmp;
6091 i->capability = capability;
6092
6093 if (!cachable) {
6094 ast_set_flag(ast_channel_flags(tmp), AST_FLAG_DISABLE_DEVSTATE_CACHE);
6095 }
6096
6097 /* Set inherited variables */
6098 if (i->vars) {
6099 for (v = i->vars ; v ; v = v->next)
6100 pbx_builtin_setvar_helper(tmp, v->name, v->value);
6101 }
6102 if (i->iaxvars) {
6103 struct ast_datastore *variablestore;
6104 struct ast_variable *var, *prev = NULL;
6105 AST_LIST_HEAD(, ast_var_t) *varlist;
6106 ast_debug(1, "Loading up the channel with IAXVARs\n");
6107 varlist = ast_calloc(1, sizeof(*varlist));
6108 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
6109 if (variablestore && varlist) {
6110 variablestore->data = varlist;
6111 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
6112 AST_LIST_HEAD_INIT(varlist);
6113 for (var = i->iaxvars; var; var = var->next) {
6114 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
6115 if (prev)
6116 ast_free(prev);
6117 prev = var;
6118 if (!newvar) {
6119 /* Don't abort list traversal, as this would leave i->iaxvars in an inconsistent state. */
6120 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
6121 } else {
6122 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
6123 }
6124 }
6125 if (prev)
6126 ast_free(prev);
6127 i->iaxvars = NULL;
6128 ast_channel_datastore_add(i->owner, variablestore);
6129 } else {
6130 if (variablestore) {
6131 ast_datastore_free(variablestore);
6132 }
6133 if (varlist) {
6134 ast_free(varlist);
6135 }
6136 }
6137 }
6138
6139 ast_channel_stage_snapshot_done(tmp);
6140 ast_channel_unlock(tmp);
6141
6142 if (state != AST_STATE_DOWN) {
6143 if (ast_pbx_start(tmp)) {
6144 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast_channel_name(tmp));
6145 /* unlock and relock iaxsl[callno] to preserve locking order */
6146 ast_mutex_unlock(&iaxsl[callno]);
6147 ast_hangup(tmp);
6148 ast_mutex_lock(&iaxsl[callno]);
6149 return NULL;
6150 }
6151 }
6152
6153 ast_module_ref(ast_module_info->self);
6154 return tmp;
6155}
6156
6157static unsigned int calc_txpeerstamp(struct iax2_trunk_peer *tpeer, int sampms, struct timeval *now)
6158{
6159 unsigned long int mssincetx; /* unsigned to handle overflows */
6160 long int ms, pred;
6161
6162 tpeer->trunkact = *now;
6163 mssincetx = ast_tvdiff_ms(*now, tpeer->lasttxtime);
6164 if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
6165 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
6166 tpeer->txtrunktime = *now;
6167 tpeer->lastsent = 999999;
6168 }
6169 /* Update last transmit time now */
6170 tpeer->lasttxtime = *now;
6171
6172 /* Calculate ms offset */
6173 ms = ast_tvdiff_ms(*now, tpeer->txtrunktime);
6174 /* Predict from last value */
6175 pred = tpeer->lastsent + sampms;
6176 if (labs(ms - pred) < MAX_TIMESTAMP_SKEW)
6177 ms = pred;
6178
6179 /* We never send the same timestamp twice, so fudge a little if we must */
6180 if (ms == tpeer->lastsent)
6181 ms = tpeer->lastsent + 1;
6182 tpeer->lastsent = ms;
6183 return ms;
6184}
6185
6186static unsigned int fix_peerts(struct timeval *rxtrunktime, int callno, unsigned int ts)
6187{
6188 long ms; /* NOT unsigned */
6189 if (ast_tvzero(iaxs[callno]->rxcore)) {
6190 /* Initialize rxcore time if appropriate */
6191 iaxs[callno]->rxcore = ast_tvnow();
6192 /* Round to nearest 20ms so traces look pretty */
6193 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
6194 }
6195 /* Calculate difference between trunk and channel */
6196 ms = ast_tvdiff_ms(*rxtrunktime, iaxs[callno]->rxcore);
6197 /* Return as the sum of trunk time and the difference between trunk and real time */
6198 return ms + ts;
6199}
6200
6201static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
6202{
6203 int ms;
6204 int voice = 0;
6205 int genuine = 0;
6206 int adjust;
6207 int rate = 0;
6208 struct timeval *delivery = NULL;
6209
6210
6211 /* What sort of frame do we have?: voice is self-explanatory
6212 "genuine" means an IAX frame - things like LAGRQ/RP, PING/PONG, ACK
6213 non-genuine frames are CONTROL frames [ringing etc], DTMF
6214 The "genuine" distinction is needed because genuine frames must get a clock-based timestamp,
6215 the others need a timestamp slaved to the voice frames so that they go in sequence
6216 */
6217 if (f->frametype == AST_FRAME_VOICE) {
6218 voice = 1;
6219 rate = ast_format_get_sample_rate(f->subclass.format) / 1000;
6220 delivery = &f->delivery;
6221 } else if (f->frametype == AST_FRAME_IAX) {
6222 genuine = 1;
6223 } else if (f->frametype == AST_FRAME_CNG) {
6224 p->notsilenttx = 0;
6225 }
6226
6227 if (ast_tvzero(p->offset)) {
6228 p->offset = ast_tvnow();
6229 /* Round to nearest 20ms for nice looking traces */
6230 p->offset.tv_usec -= p->offset.tv_usec % 20000;
6231 }
6232 /* If the timestamp is specified, just send it as is */
6233 if (ts)
6234 return ts;
6235 /* If we have a time that the frame arrived, always use it to make our timestamp */
6236 if (delivery && !ast_tvzero(*delivery)) {
6237 ms = ast_tvdiff_ms(*delivery, p->offset);
6238 if (ms < 0) {
6239 ms = 0;
6240 }
6241 if (iaxdebug)
6242 ast_debug(3, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
6243 } else {
6244 ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
6245 if (ms < 0)
6246 ms = 0;
6247 if (voice) {
6248 /* On a voice frame, use predicted values if appropriate */
6249 adjust = (ms - p->nextpred);
6250 if (p->notsilenttx && abs(adjust) <= MAX_TIMESTAMP_SKEW) {
6251 /* Adjust our txcore, keeping voice and non-voice synchronized */
6252 /* AN EXPLANATION:
6253 When we send voice, we usually send "calculated" timestamps worked out
6254 on the basis of the number of samples sent. When we send other frames,
6255 we usually send timestamps worked out from the real clock.
6256 The problem is that they can tend to drift out of step because the
6257 source channel's clock and our clock may not be exactly at the same rate.
6258 We fix this by continuously "tweaking" p->offset. p->offset is "time zero"
6259 for this call. Moving it adjusts timestamps for non-voice frames.
6260 We make the adjustment in the style of a moving average. Each time we
6261 adjust p->offset by 10% of the difference between our clock-derived
6262 timestamp and the predicted timestamp. That's why you see "10000"
6263 below even though IAX2 timestamps are in milliseconds.
6264 The use of a moving average avoids offset moving too radically.
6265 Generally, "adjust" roams back and forth around 0, with offset hardly
6266 changing at all. But if a consistent different starts to develop it
6267 will be eliminated over the course of 10 frames (200-300msecs)
6268 */
6269 if (adjust < 0)
6270 p->offset = ast_tvsub(p->offset, ast_samp2tv(abs(adjust), 10000));
6271 else if (adjust > 0)
6272 p->offset = ast_tvadd(p->offset, ast_samp2tv(adjust, 10000));
6273
6274 if (!p->nextpred) {
6275 p->nextpred = ms; /*f->samples / rate;*/
6276 if (p->nextpred <= p->lastsent)
6277 p->nextpred = p->lastsent + 3;
6278 }
6279 ms = p->nextpred;
6280 } else {
6281 /* in this case, just use the actual
6282 * time, since we're either way off
6283 * (shouldn't happen), or we're ending a
6284 * silent period -- and seed the next
6285 * predicted time. Also, round ms to the
6286 * next multiple of frame size (so our
6287 * silent periods are multiples of
6288 * frame size too) */
6289
6290 if (iaxdebug && abs(adjust) > MAX_TIMESTAMP_SKEW )
6291 ast_debug(1, "predicted timestamp skew (%d) > max (%d), using real ts instead.\n",
6292 abs(adjust), MAX_TIMESTAMP_SKEW);
6293
6294 if (f->samples >= rate) /* check to make sure we don't core dump */
6295 {
6296 int diff = ms % (f->samples / rate);
6297 if (diff)
6298 ms += f->samples/rate - diff;
6299 }
6300
6301 p->nextpred = ms;
6302 p->notsilenttx = 1;
6303 }
6304 } else if ( f->frametype == AST_FRAME_VIDEO ) {
6305 /*
6306 * IAX2 draft 03 says that timestamps MUST be in order.
6307 * It does not say anything about several frames having the same timestamp
6308 * When transporting video, we can have a frame that spans multiple iax packets
6309 * (so called slices), so it would make sense to use the same timestamp for all of
6310 * them
6311 * We do want to make sure that frames don't go backwards though
6312 */
6313 if ( (unsigned int)ms < p->lastsent )
6314 ms = p->lastsent;
6315 } else {
6316 /* On a dataframe, use last value + 3 (to accommodate jitter buffer shrinking) if appropriate unless
6317 it's a genuine frame */
6318 adjust = (ms - p->lastsent);
6319 if (genuine) {
6320 /* genuine (IAX LAGRQ etc) must keep their clock-based stamps */
6321 if (ms <= p->lastsent)
6322 ms = p->lastsent + 3;
6323 } else if (abs(adjust) <= MAX_TIMESTAMP_SKEW) {
6324 /* non-genuine frames (!?) (DTMF, CONTROL) should be pulled into the predicted stream stamps */
6325 ms = p->lastsent + 3;
6326 }
6327 }
6328 }
6329 p->lastsent = ms;
6330 if (voice) {
6331 p->nextpred = p->nextpred + f->samples / rate;
6332 }
6333 return ms;
6334}
6335
6336static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset)
6337{
6338 /* Returns where in "receive time" we are. That is, how many ms
6339 since we received (or would have received) the frame with timestamp 0 */
6340 int ms;
6341#ifdef IAXTESTS
6342 int jit;
6343#endif /* IAXTESTS */
6344 /* Setup rxcore if necessary */
6345 if (ast_tvzero(p->rxcore)) {
6346 p->rxcore = ast_tvnow();
6347 if (iaxdebug)
6348 ast_debug(1, "calc_rxstamp: call=%d: rxcore set to %d.%6.6d - %ums\n",
6349 p->callno, (int)(p->rxcore.tv_sec), (int)(p->rxcore.tv_usec), offset);
6350 p->rxcore = ast_tvsub(p->rxcore, ast_samp2tv(offset, 1000));
6351#if 1
6352 if (iaxdebug)
6353 ast_debug(1, "calc_rxstamp: call=%d: works out as %d.%6.6d\n",
6354 p->callno, (int)(p->rxcore.tv_sec),(int)( p->rxcore.tv_usec));
6355#endif
6356 }
6357
6358 ms = ast_tvdiff_ms(ast_tvnow(), p->rxcore);
6359#ifdef IAXTESTS
6360 if (test_jit) {
6361 if (!test_jitpct || ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_jitpct)) {
6362 jit = (int)((float)test_jit * ast_random() / (RAND_MAX + 1.0));
6363 if ((int)(2.0 * ast_random() / (RAND_MAX + 1.0)))
6364 jit = -jit;
6365 ms += jit;
6366 }
6367 }
6368 if (test_late) {
6369 ms += test_late;
6370 test_late = 0;
6371 }
6372#endif /* IAXTESTS */
6373 return ms;
6374}
6375
6376static struct iax2_trunk_peer *find_tpeer(struct ast_sockaddr *addr, int fd)
6377{
6378 struct iax2_trunk_peer *tpeer = NULL;
6379
6380 /* Finds and locks trunk peer */
6381 AST_LIST_LOCK(&tpeers);
6382
6383 AST_LIST_TRAVERSE(&tpeers, tpeer, list) {
6384 if (!ast_sockaddr_cmp(&tpeer->addr, addr)) {
6385 ast_mutex_lock(&tpeer->lock);
6386 break;
6387 }
6388 }
6389
6390 if (!tpeer) {
6391 if ((tpeer = ast_calloc(1, sizeof(*tpeer)))) {
6392 ast_mutex_init(&tpeer->lock);
6393 tpeer->lastsent = 9999;
6394 ast_sockaddr_copy(&tpeer->addr, addr);
6395 tpeer->trunkact = ast_tvnow();
6396 ast_mutex_lock(&tpeer->lock);
6397 tpeer->sockfd = fd;
6398
6399#ifdef SO_NO_CHECK
6400 setsockopt(tpeer->sockfd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
6401#endif
6402 ast_debug(1, "Created trunk peer for '%s'\n", ast_sockaddr_stringify(&tpeer->addr));
6403 AST_LIST_INSERT_TAIL(&tpeers, tpeer, list);
6404 }
6405 }
6406
6407 AST_LIST_UNLOCK(&tpeers);
6408
6409 return tpeer;
6410}
6411
6412static int iax2_trunk_queue(struct chan_iax2_pvt *pvt, struct iax_frame *fr)
6413{
6414 struct ast_frame *f;
6415 struct iax2_trunk_peer *tpeer;
6416 void *tmp, *ptr;
6417 struct timeval now;
6418 struct ast_iax2_meta_trunk_entry *met;
6419 struct ast_iax2_meta_trunk_mini *mtm;
6420
6421 f = &fr->af;
6422 tpeer = find_tpeer(&pvt->addr, pvt->sockfd);
6423 if (tpeer) {
6424
6425 if (tpeer->trunkdatalen + f->datalen + 4 >= tpeer->trunkdataalloc) {
6426 /* Need to reallocate space */
6427 if (tpeer->trunkdataalloc < trunkmaxsize) {
6428 if (!(tmp = ast_realloc(tpeer->trunkdata, tpeer->trunkdataalloc + DEFAULT_TRUNKDATA + IAX2_TRUNK_PREFACE))) {
6429 ast_mutex_unlock(&tpeer->lock);
6430 return -1;
6431 }
6432
6433 tpeer->trunkdataalloc += DEFAULT_TRUNKDATA;
6434 tpeer->trunkdata = tmp;
6435 ast_debug(1, "Expanded trunk '%s' to %u bytes\n", ast_sockaddr_stringify(&tpeer->addr), tpeer->trunkdataalloc);
6436 } else {
6437 ast_log(LOG_WARNING, "Maximum trunk data space exceeded to %s\n", ast_sockaddr_stringify(&tpeer->addr));
6438 ast_mutex_unlock(&tpeer->lock);
6439 return -1;
6440 }
6441 }
6442
6443 /* Append to meta frame */
6444 ptr = tpeer->trunkdata + IAX2_TRUNK_PREFACE + tpeer->trunkdatalen;
6445 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS)) {
6446 mtm = (struct ast_iax2_meta_trunk_mini *)ptr;
6447 mtm->len = htons(f->datalen);
6448 mtm->mini.callno = htons(pvt->callno);
6449 mtm->mini.ts = htons(0xffff & fr->ts);
6450 ptr += sizeof(struct ast_iax2_meta_trunk_mini);
6451 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_mini);
6452 } else {
6453 met = (struct ast_iax2_meta_trunk_entry *)ptr;
6454 /* Store call number and length in meta header */
6455 met->callno = htons(pvt->callno);
6456 met->len = htons(f->datalen);
6457 /* Advance pointers/decrease length past trunk entry header */
6458 ptr += sizeof(struct ast_iax2_meta_trunk_entry);
6459 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
6460 }
6461 /* Copy actual trunk data */
6462 memcpy(ptr, f->data.ptr, f->datalen);
6463 tpeer->trunkdatalen += f->datalen;
6464
6465 tpeer->calls++;
6466
6467 /* track the largest mtu we actually have sent */
6468 if (tpeer->trunkdatalen + f->datalen + 4 > trunk_maxmtu)
6469 trunk_maxmtu = tpeer->trunkdatalen + f->datalen + 4 ;
6470
6471 /* if we have enough for a full MTU, ship it now without waiting */
6472 if (global_max_trunk_mtu > 0 && tpeer->trunkdatalen + f->datalen + 4 >= global_max_trunk_mtu) {
6473 now = ast_tvnow();
6474 send_trunk(tpeer, &now);
6475 trunk_untimed ++;
6476 }
6477
6478 ast_mutex_unlock(&tpeer->lock);
6479 }
6480 return 0;
6481}
6482
6483/* IAX2 encryption requires 16 to 32 bytes of random padding to be present
6484 * before the encryption data. This function randomizes that data. */
6485static void build_rand_pad(unsigned char *buf, ssize_t len)
6486{
6487 long tmp;
6488 for (tmp = ast_random(); len > 0; tmp = ast_random()) {
6489 memcpy(buf, (unsigned char *) &tmp, (len > sizeof(tmp)) ? sizeof(tmp) : len);
6490 buf += sizeof(tmp);
6491 len -= sizeof(tmp);
6492 }
6493}
6494
6495static int invalid_key(ast_aes_decrypt_key *ecx)
6496{
6497#ifdef HAVE_OPENSSL
6498 int i;
6499 for (i = 0; i < 60; i++) {
6500 if (ecx->raw[i]) {
6501 return 0; /* stop if we encounter anything non-zero */
6502 }
6503 }
6504 /* if ast_aes_encrypt or ast_aes_decrypt is called, then we'll crash when calling AES_encrypt or AES_decrypt */
6505 return -1;
6506#else
6507 return 0; /* Can't verify, but doesn't matter anyways */
6508#endif
6509}
6510
6511static void build_encryption_keys(const unsigned char *digest, struct chan_iax2_pvt *pvt)
6512{
6513 build_ecx_key(digest, pvt);
6514 ast_aes_set_decrypt_key(digest, &pvt->dcx);
6515}
6516
6517static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt)
6518{
6519 /* it is required to hold the corresponding decrypt key to our encrypt key
6520 * in the pvt struct because queued frames occasionally need to be decrypted and
6521 * re-encrypted when updated for a retransmission */
6522 build_rand_pad(pvt->semirand, sizeof(pvt->semirand));
6523 ast_aes_set_encrypt_key(digest, &pvt->ecx);
6524 ast_aes_set_decrypt_key(digest, &pvt->mydcx);
6525}
6526
6527static void memcpy_decrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_decrypt_key *dcx)
6528{
6529#if 0
6530 /* Debug with "fake encryption" */
6531 int x;
6532 if (len % 16)
6533 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
6534 for (x=0;x<len;x++)
6535 dst[x] = src[x] ^ 0xff;
6536#else
6537 unsigned char lastblock[16] = { 0 };
6538 int x;
6539 while(len > 0) {
6540 ast_aes_decrypt(src, dst, dcx);
6541 for (x=0;x<16;x++)
6542 dst[x] ^= lastblock[x];
6543 memcpy(lastblock, src, sizeof(lastblock));
6544 dst += 16;
6545 src += 16;
6546 len -= 16;
6547 }
6548#endif
6549}
6550
6551static void memcpy_encrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_encrypt_key *ecx)
6552{
6553#if 0
6554 /* Debug with "fake encryption" */
6555 int x;
6556 if (len % 16)
6557 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
6558 for (x=0;x<len;x++)
6559 dst[x] = src[x] ^ 0xff;
6560#else
6561 unsigned char curblock[16] = { 0 };
6562 int x;
6563 while(len > 0) {
6564 for (x=0;x<16;x++)
6565 curblock[x] ^= src[x];
6566 ast_aes_encrypt(curblock, dst, ecx);
6567 memcpy(curblock, dst, sizeof(curblock));
6568 dst += 16;
6569 src += 16;
6570 len -= 16;
6571 }
6572#endif
6573}
6574
6575static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
6576{
6577 int padding;
6578 unsigned char *workspace;
6579
6580 workspace = ast_alloca(*datalen);
6581 memset(f, 0, sizeof(*f));
6582 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
6583 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
6584 if (*datalen < 16 + sizeof(struct ast_iax2_full_hdr))
6585 return -1;
6586 /* Decrypt */
6587 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr), dcx);
6588
6589 padding = 16 + (workspace[15] & 0x0f);
6590 if (iaxdebug)
6591 ast_debug(1, "Decoding full frame with length %d (padding = %d) (15=%02hhx)\n", *datalen, padding, workspace[15]);
6592 if (*datalen < padding + sizeof(struct ast_iax2_full_hdr))
6593 return -1;
6594
6595 *datalen -= padding;
6596 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
6597 f->frametype = fh->type;
6598 if (f->frametype == AST_FRAME_VIDEO) {
6599 f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1));
6600 if (!f->subclass.format) {
6601 f->subclass.format = ast_format_none;
6602 }
6603 } else if (f->frametype == AST_FRAME_VOICE) {
6604 f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
6605 if (!f->subclass.format) {
6606 f->subclass.format = ast_format_none;
6607 }
6608 } else {
6609 f->subclass.integer = uncompress_subclass(fh->csub);
6610 }
6611 } else {
6612 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
6613 if (iaxdebug)
6614 ast_debug(5, "Decoding mini with length %d\n", *datalen);
6615 if (*datalen < 16 + sizeof(struct ast_iax2_mini_hdr))
6616 return -1;
6617 /* Decrypt */
6618 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), dcx);
6619 padding = 16 + (workspace[15] & 0x0f);
6620 if (*datalen < padding + sizeof(struct ast_iax2_mini_hdr))
6621 return -1;
6622 *datalen -= padding;
6623 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
6624 }
6625 return 0;
6626}
6627
6628static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen)
6629{
6630 int padding;
6631 unsigned char *workspace;
6632 workspace = ast_alloca(*datalen + 32);
6633 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
6634 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
6635 if (iaxdebug)
6636 ast_debug(1, "Encoding full frame %d/%d with length %d\n", fh->type, fh->csub, *datalen);
6637 padding = 16 - ((*datalen - sizeof(struct ast_iax2_full_enc_hdr)) % 16);
6638 padding = 16 + (padding & 0xf);
6639 memcpy(workspace, poo, padding);
6640 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
6641 workspace[15] &= 0xf0;
6642 workspace[15] |= (padding & 0xf);
6643 if (iaxdebug)
6644 ast_debug(1, "Encoding full frame %d/%d with length %d + %d padding (15=%02hhx)\n", fh->type, fh->csub, *datalen, padding, workspace[15]);
6645 *datalen += padding;
6646 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_full_enc_hdr), ecx);
6647 if (*datalen >= 32 + sizeof(struct ast_iax2_full_enc_hdr))
6648 memcpy(poo, workspace + *datalen - 32, 32);
6649 } else {
6650 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
6651 if (iaxdebug)
6652 ast_debug(5, "Encoding mini frame with length %d\n", *datalen);
6653 padding = 16 - ((*datalen - sizeof(struct ast_iax2_mini_enc_hdr)) % 16);
6654 padding = 16 + (padding & 0xf);
6655 memcpy(workspace, poo, padding);
6656 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
6657 workspace[15] &= 0xf0;
6658 workspace[15] |= (padding & 0x0f);
6659 *datalen += padding;
6660 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), ecx);
6661 if (*datalen >= 32 + sizeof(struct ast_iax2_mini_enc_hdr))
6662 memcpy(poo, workspace + *datalen - 32, 32);
6663 }
6664 return 0;
6665}
6666
6667static int decrypt_frame(int callno, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
6668{
6669 int res=-1;
6670 if (!ast_test_flag64(iaxs[callno], IAX_KEYPOPULATED)) {
6671 /* Search for possible keys, given secrets */
6672 struct MD5Context md5;
6673 unsigned char digest[16];
6674 char *tmppw, *stringp;
6675
6676 tmppw = ast_strdupa(iaxs[callno]->secret);
6677 stringp = tmppw;
6678 while ((tmppw = strsep(&stringp, ";"))) {
6679 MD5Init(&md5);
6680 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
6681 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
6682 MD5Final(digest, &md5);
6683 build_encryption_keys(digest, iaxs[callno]);
6684 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
6685 if (!res) {
6686 ast_set_flag64(iaxs[callno], IAX_KEYPOPULATED);
6687 break;
6688 }
6689 }
6690 } else
6691 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
6692 return res;
6693}
6694
6695static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
6696{
6697 /* Queue a packet for delivery on a given private structure. Use "ts" for
6698 timestamp, or calculate if ts is 0. Send immediately without retransmission
6699 or delayed, with retransmission */
6700 struct ast_iax2_full_hdr *fh;
6701 struct ast_iax2_mini_hdr *mh;
6702 struct ast_iax2_video_hdr *vh;
6703 struct {
6704 struct iax_frame fr2;
6705 unsigned char buffer[4096];
6706 } frb;
6707 struct iax_frame *fr;
6708 int res;
6709 int sendmini=0;
6710 unsigned int lastsent;
6711 unsigned int fts;
6712
6713 frb.fr2.afdatalen = sizeof(frb.buffer);
6714
6715 if (!pvt) {
6716 ast_log(LOG_WARNING, "No private structure for packet?\n");
6717 return -1;
6718 }
6719
6720 lastsent = pvt->lastsent;
6721
6722 /* Calculate actual timestamp */
6723 fts = calc_timestamp(pvt, ts, f);
6724
6725 /* Bail here if this is an "interp" frame; we don't want or need to send these placeholders out
6726 * (the endpoint should detect the lost packet itself). But, we want to do this here, so that we
6727 * increment the "predicted timestamps" for voice, if we're predicting */
6728 if(f->frametype == AST_FRAME_VOICE && f->datalen == 0)
6729 return 0;
6730#if 0
6731 ast_log(LOG_NOTICE,
6732 "f->frametype %c= AST_FRAME_VOICE, %sencrypted, %srotation scheduled...\n",
6733 *("=!" + (f->frametype == AST_FRAME_VOICE)),
6734 IAX_CALLENCRYPTED(pvt) ? "" : "not ",
6735 pvt->keyrotateid != -1 ? "" : "no "
6736 );
6737#endif
6738 if (pvt->keyrotateid == -1 && f->frametype == AST_FRAME_VOICE && IAX_CALLENCRYPTED(pvt)) {
6739 iax2_key_rotate(pvt);
6740 }
6741
6742 if ((ast_test_flag64(pvt, IAX_TRUNK) ||
6743 (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)) ||
6744 ((fts & 0xFFFF0000L) == ((lastsent + 0x10000) & 0xFFFF0000L))))
6745 /* High two bytes are the same on timestamp, or sending on a trunk */ &&
6746 (f->frametype == AST_FRAME_VOICE)
6747 /* is a voice frame */ &&
6748 (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svoiceformat)) ==
6749 AST_FORMAT_CMP_EQUAL)
6750 /* is the same type */ ) {
6751 /* Force immediate rather than delayed transmission */
6752 now = 1;
6753 /* Mark that mini-style frame is appropriate */
6754 sendmini = 1;
6755 }
6756 if ( f->frametype == AST_FRAME_VIDEO ) {
6757 /*
6758 * If the lower 15 bits of the timestamp roll over, or if
6759 * the video format changed then send a full frame.
6760 * Otherwise send a mini video frame
6761 */
6762 if (((fts & 0xFFFF8000L) == (pvt->lastvsent & 0xFFFF8000L)) &&
6763 (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svideoformat)) ==
6764 AST_FORMAT_CMP_EQUAL)
6765 ) {
6766 now = 1;
6767 sendmini = 1;
6768 } else {
6769 now = 0;
6770 sendmini = 0;
6771 }
6772 pvt->lastvsent = fts;
6773 }
6774 if (f->frametype == AST_FRAME_IAX) {
6775 /* 0x8000 marks this message as TX:, this bit will be stripped later */
6776 pvt->last_iax_message = f->subclass.integer | MARK_IAX_SUBCLASS_TX;
6777 if (!pvt->first_iax_message) {
6778 pvt->first_iax_message = pvt->last_iax_message;
6779 }
6780 }
6781 /* Allocate an iax_frame */
6782 if (now) {
6783 fr = &frb.fr2;
6784 } else
6785 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));
6786 if (!fr) {
6787 ast_log(LOG_WARNING, "Out of memory\n");
6788 return -1;
6789 }
6790 /* Copy our prospective frame into our immediate or retransmitted wrapper */
6791 iax_frame_wrap(fr, f);
6792
6793 fr->ts = fts;
6794 fr->callno = pvt->callno;
6795 fr->transfer = transfer;
6796 fr->final = final;
6797 fr->encmethods = 0;
6798 if (!sendmini) {
6799 /* We need a full frame */
6800 if (seqno > -1)
6801 fr->oseqno = seqno;
6802 else
6803 fr->oseqno = pvt->oseqno++;
6804 fr->iseqno = pvt->iseqno;
6805 fh = (struct ast_iax2_full_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_full_hdr));
6806 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
6807 fh->ts = htonl(fr->ts);
6808 fh->oseqno = fr->oseqno;
6809 if (transfer) {
6810 fh->iseqno = 0;
6811 } else
6812 fh->iseqno = fr->iseqno;
6813 /* Keep track of the last thing we've acknowledged */
6814 if (!transfer)
6815 pvt->aseqno = fr->iseqno;
6816 fh->type = fr->af.frametype & 0xFF;
6817
6818 if (fr->af.frametype == AST_FRAME_VIDEO) {
6819 iax2_format tmpfmt = ast_format_compatibility_format2bitfield(fr->af.subclass.format);
6820 tmpfmt |= fr->af.subclass.frame_ending ? 0x1LL : 0;
6821 fh->csub = compress_subclass(tmpfmt | ((tmpfmt & 0x1LL) << 6));
6822 } else if (fr->af.frametype == AST_FRAME_VOICE) {
6823 fh->csub = compress_subclass(ast_format_compatibility_format2bitfield(fr->af.subclass.format));
6824 } else {
6825 fh->csub = compress_subclass(fr->af.subclass.integer);
6826 }
6827
6828 if (transfer) {
6829 fr->dcallno = pvt->transfercallno;
6830 } else
6831 fr->dcallno = pvt->peercallno;
6832 fh->dcallno = htons(fr->dcallno);
6833 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
6834 fr->data = fh;
6835 fr->retries = 0;
6836 /* Retry after 2x the ping time has passed */
6837 fr->retrytime = pvt->pingtime * 2;
6838 if (fr->retrytime < MIN_RETRY_TIME)
6839 fr->retrytime = MIN_RETRY_TIME;
6840 if (fr->retrytime > MAX_RETRY_TIME)
6841 fr->retrytime = MAX_RETRY_TIME;
6842 /* Acks' don't get retried */
6843 if ((f->frametype == AST_FRAME_IAX) && (f->subclass.integer == IAX_COMMAND_ACK))
6844 fr->retries = -1;
6845 else if (f->frametype == AST_FRAME_VOICE)
6846 pvt->svoiceformat = ast_format_compatibility_format2bitfield(f->subclass.format);
6847 else if (f->frametype == AST_FRAME_VIDEO)
6848 pvt->svideoformat = ast_format_compatibility_format2bitfield(f->subclass.format);
6849 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
6850 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
6851 if (fr->transfer)
6852 iax_outputframe(fr, NULL, 2, &pvt->transfer, fr->datalen - sizeof(struct ast_iax2_full_hdr));
6853 else
6854 iax_outputframe(fr, NULL, 2, &pvt->addr, fr->datalen - sizeof(struct ast_iax2_full_hdr));
6855 encrypt_frame(&pvt->ecx, fh, pvt->semirand, &fr->datalen);
6856 fr->encmethods = pvt->encmethods;
6857 fr->ecx = pvt->ecx;
6858 fr->mydcx = pvt->mydcx;
6859 memcpy(fr->semirand, pvt->semirand, sizeof(fr->semirand));
6860 } else
6861 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
6862 }
6863
6864 if (now) {
6865 res = send_packet(fr);
6866 } else
6867 res = iax2_transmit(fr);
6868 } else {
6869 if (ast_test_flag64(pvt, IAX_TRUNK)) {
6870 iax2_trunk_queue(pvt, fr);
6871 res = 0;
6872 } else if (fr->af.frametype == AST_FRAME_VIDEO) {
6873 /* Video frame have no sequence number */
6874 fr->oseqno = -1;
6875 fr->iseqno = -1;
6876 vh = (struct ast_iax2_video_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_video_hdr));
6877 vh->zeros = 0;
6878 vh->callno = htons(0x8000 | fr->callno);
6879 vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass.frame_ending ? 0x8000 : 0));
6880 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
6881 fr->data = vh;
6882 fr->retries = -1;
6883 res = send_packet(fr);
6884 } else {
6885 /* Mini-frames have no sequence number */
6886 fr->oseqno = -1;
6887 fr->iseqno = -1;
6888 /* Mini frame will do */
6889 mh = (struct ast_iax2_mini_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_mini_hdr));
6890 mh->callno = htons(fr->callno);
6891 mh->ts = htons(fr->ts & 0xFFFF);
6892 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
6893 fr->data = mh;
6894 fr->retries = -1;
6895 if (pvt->transferring == TRANSFER_MEDIAPASS)
6896 fr->transfer = 1;
6897 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
6898 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
6899 encrypt_frame(&pvt->ecx, (struct ast_iax2_full_hdr *)mh, pvt->semirand, &fr->datalen);
6900 } else
6901 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
6902 }
6903 res = send_packet(fr);
6904 }
6905 }
6906 return res;
6907}
6908
6909static char *handle_cli_iax2_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6910{
6911 regex_t regexbuf;
6912 int havepattern = 0;
6913
6914#define FORMAT "%-15.15s %-20.20s %-15.15s %-15.15s %-5.5s %-5.10s\n"
6915#define FORMAT2 "%-15.15s %-20.20s %-15.15d %-15.15s %-5.5s %-5.10s\n"
6916
6917 struct iax2_user *user = NULL;
6918 char auth[90];
6919 char *pstr = "";
6920 struct ao2_iterator i;
6921
6922 switch (cmd) {
6923 case CLI_INIT:
6924 e->command = "iax2 show users [like]";
6925 e->usage =
6926 "Usage: iax2 show users [like <pattern>]\n"
6927 " Lists all known IAX2 users.\n"
6928 " Optional regular expression pattern is used to filter the user list.\n";
6929 return NULL;
6930 case CLI_GENERATE:
6931 return NULL;
6932 }
6933
6934 switch (a->argc) {
6935 case 5:
6936 if (!strcasecmp(a->argv[3], "like")) {
6937 if (regcomp(&regexbuf, a->argv[4], REG_EXTENDED | REG_NOSUB))
6938 return CLI_SHOWUSAGE;
6939 havepattern = 1;
6940 } else
6941 return CLI_SHOWUSAGE;
6942 case 3:
6943 break;
6944 default:
6945 return CLI_SHOWUSAGE;
6946 }
6947
6948 ast_cli(a->fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C","Codec Pref");
6949 i = ao2_iterator_init(users, 0);
6950 for (; (user = ao2_iterator_next(&i)); user_unref(user)) {
6951 if (havepattern && regexec(&regexbuf, user->name, 0, NULL, 0))
6952 continue;
6953
6954 if (!ast_strlen_zero(user->secret)) {
6955 ast_copy_string(auth,user->secret, sizeof(auth));
6956 } else if (!ast_strlen_zero(user->inkeys)) {
6957 snprintf(auth, sizeof(auth), "Key: %-15.15s ", user->inkeys);
6958 } else
6959 ast_copy_string(auth, "-no secret-", sizeof(auth));
6960
6961 if(ast_test_flag64(user, IAX_CODEC_NOCAP))
6962 pstr = "REQ Only";
6963 else if(ast_test_flag64(user, IAX_CODEC_NOPREFS))
6964 pstr = "Disabled";
6965 else
6966 pstr = ast_test_flag64(user, IAX_CODEC_USER_FIRST) ? "Caller" : "Host";
6967
6968 ast_cli(a->fd, FORMAT2, user->name, auth, user->authmethods,
6969 user->contexts ? user->contexts->context : DEFAULT_CONTEXT,
6970 ast_acl_list_is_empty(user->acl) ? "No" : "Yes", pstr);
6971 }
6972 ao2_iterator_destroy(&i);
6973
6974 if (havepattern)
6975 regfree(&regexbuf);
6976
6977 return CLI_SUCCESS;
6978#undef FORMAT
6979#undef FORMAT2
6980}
6981
6982struct show_peers_context {
6983 regex_t regexbuf;
6984 int havepattern;
6985 char idtext[256];
6986 int registeredonly;
6987 int peerlist;
6988 int total_peers;
6989 int online_peers;
6990 int offline_peers;
6991 int unmonitored_peers;
6992};
6993
6994#define PEERS_FORMAT2 "%-15.15s %-40.40s %s %-40.40s %-9s %s %-11s %-32.32s\n"
6995#define PEERS_FORMAT "%-15.15s %-40.40s %s %-40.40s %-6s%s %s %-11s %-32.32s\n"
6996
6997static void _iax2_show_peers_one(int fd, struct mansession *s, struct show_peers_context *cont, struct iax2_peer *peer)
6998{
6999 char name[256] = "";
7000 char status[64];
7001 int retstatus;
7002 struct ast_str *encmethods = ast_str_alloca(256);
7003
7004 char *tmp_host, *tmp_mask, *tmp_port;
7005
7006 tmp_host = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
7007 tmp_mask = ast_strdupa(ast_sockaddr_stringify_addr(&peer->mask));
7008 tmp_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
7009
7010 if (!ast_strlen_zero(peer->username)) {
7011 snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
7012 } else {
7013 ast_copy_string(name, peer->name, sizeof(name));
7014 }
7015
7016 encmethods_to_str(peer->encmethods, &encmethods);
7017 retstatus = peer_status(peer, status, sizeof(status));
7018 if (retstatus > 0) {
7019 cont->online_peers++;
7020 } else if (!retstatus) {
7021 cont->offline_peers++;
7022 } else {
7023 cont->unmonitored_peers++;
7024 }
7025
7026 if (s) {
7027 if (cont->peerlist) { /* IAXpeerlist */
7028 astman_append(s,
7029 "Event: PeerEntry\r\n%s"
7030 "Channeltype: IAX\r\n",
7031 cont->idtext);
7032 if (!ast_strlen_zero(peer->username)) {
7033 astman_append(s,
7034 "ObjectName: %s\r\n"
7035 "ObjectUsername: %s\r\n",
7036 peer->name,
7037 peer->username);
7038 } else {
7039 astman_append(s,
7040 "ObjectName: %s\r\n",
7041 name);
7042 }
7043 } else { /* IAXpeers */
7044 astman_append(s,
7045 "Event: PeerEntry\r\n%s"
7046 "Channeltype: IAX2\r\n"
7047 "ObjectName: %s\r\n",
7048 cont->idtext,
7049 name);
7050 }
7051 astman_append(s,
7052 "ChanObjectType: peer\r\n"
7053 "IPaddress: %s\r\n",
7054 tmp_host);
7055 if (cont->peerlist) { /* IAXpeerlist */
7056 astman_append(s,
7057 "Mask: %s\r\n"
7058 "Port: %s\r\n",
7059 tmp_mask,
7060 tmp_port);
7061 } else { /* IAXpeers */
7062 astman_append(s,
7063 "IPport: %s\r\n",
7064 tmp_port);
7065 }
7066 astman_append(s,
7067 "Dynamic: %s\r\n"
7068 "Trunk: %s\r\n"
7069 "Encryption: %s\r\n"
7070 "Status: %s\r\n",
7071 ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no",
7072 ast_test_flag64(peer, IAX_TRUNK) ? "yes" : "no",
7073 peer->encmethods ? ast_str_buffer(encmethods) : "no",
7074 status);
7075 if (cont->peerlist) { /* IAXpeerlist */
7076 astman_append(s, "\r\n");
7077 } else { /* IAXpeers */
7078 astman_append(s,
7079 "Description: %s\r\n\r\n",
7080 peer->description);
7081 }
7082 } else {
7083 ast_cli(fd, PEERS_FORMAT,
7084 name,
7085 tmp_host,
7086 ast_test_flag64(peer, IAX_DYNAMIC) ? "(D)" : "(S)",
7087 tmp_mask,
7088 tmp_port,
7089 ast_test_flag64(peer, IAX_TRUNK) ? "(T)" : " ",
7090 peer->encmethods ? "(E)" : " ",
7091 status,
7092 peer->description);
7093 }
7094
7095 cont->total_peers++;
7096}
7097
7098static int __iax2_show_peers(int fd, int *total, struct mansession *s, const int argc, const char * const argv[])
7099{
7100 struct show_peers_context cont = {
7101 .havepattern = 0,
7102 .idtext = "",
7103 .registeredonly = 0,
7104
7105 .peerlist = 0,
7106
7107 .total_peers = 0,
7108 .online_peers = 0,
7109 .offline_peers = 0,
7110 .unmonitored_peers = 0,
7111 };
7112
7113 struct ao2_iterator i;
7114
7115 struct iax2_peer *peer = NULL;
7116
7117 switch (argc) {
7118 case 6:
7119 if (!strcasecmp(argv[3], "registered"))
7120 cont.registeredonly = 1;
7121 else
7122 return RESULT_SHOWUSAGE;
7123 if (!strcasecmp(argv[4], "like")) {
7124 if (regcomp(&cont.regexbuf, argv[5], REG_EXTENDED | REG_NOSUB))
7125 return RESULT_SHOWUSAGE;
7126 cont.havepattern = 1;
7127 } else
7128 return RESULT_SHOWUSAGE;
7129 break;
7130 case 5:
7131 if (!strcasecmp(argv[3], "like")) {
7132 if (regcomp(&cont.regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
7133 return RESULT_SHOWUSAGE;
7134 cont.havepattern = 1;
7135 } else
7136 return RESULT_SHOWUSAGE;
7137 break;
7138 case 4:
7139 if (!strcasecmp(argv[3], "registered")) {
7140 cont.registeredonly = 1;
7141 } else {
7142 return RESULT_SHOWUSAGE;
7143 }
7144 break;
7145 case 3:
7146 break;
7147 default:
7148 return RESULT_SHOWUSAGE;
7149 }
7150
7151
7152 if (!s) {
7153 ast_cli(fd, PEERS_FORMAT2, "Name/Username", "Host", " ", "Mask", "Port", " ", "Status", "Description");
7154 }
7155
7156 i = ao2_iterator_init(peers, 0);
7157 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
7158
7159 if (cont.registeredonly && ast_sockaddr_isnull(&peer->addr)) {
7160 continue;
7161 }
7162 if (cont.havepattern && regexec(&cont.regexbuf, peer->name, 0, NULL, 0)) {
7163 continue;
7164 }
7165
7166 _iax2_show_peers_one(fd, s, &cont, peer);
7167
7168 }
7169 ao2_iterator_destroy(&i);
7170
7171 if (!s) {
7172 ast_cli(fd,"%d iax2 peers [%d online, %d offline, %d unmonitored]\n",
7173 cont.total_peers, cont.online_peers, cont.offline_peers, cont.unmonitored_peers);
7174 }
7175
7176 if (cont.havepattern) {
7177 regfree(&cont.regexbuf);
7178 }
7179
7180 if (total) {
7181 *total = cont.total_peers;
7182 }
7183
7184 return RESULT_SUCCESS;
7185
7186}
7187#undef PEERS_FORMAT2
7188#undef PEERS_FORMAT
7189
7190static char *handle_cli_iax2_show_threads(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7191{
7192 struct iax2_thread *thread = NULL;
7193 time_t t;
7194 int threadcount = 0, dynamiccount = 0;
7195 char type;
7196
7197 switch (cmd) {
7198 case CLI_INIT:
7199 e->command = "iax2 show threads";
7200 e->usage =
7201 "Usage: iax2 show threads\n"
7202 " Lists status of IAX helper threads\n";
7203 return NULL;
7204 case CLI_GENERATE:
7205 return NULL;
7206 }
7207 if (a->argc != 3)
7208 return CLI_SHOWUSAGE;
7209
7210 ast_cli(a->fd, "IAX2 Thread Information\n");
7211 time(&t);
7212 ast_cli(a->fd, "Idle Threads:\n");
7213 AST_LIST_LOCK(&idle_list);
7214 AST_LIST_TRAVERSE(&idle_list, thread, list) {
7215#ifdef DEBUG_SCHED_MULTITHREAD
7216 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
7217 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7218#else
7219 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
7220 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7221#endif
7222 threadcount++;
7223 }
7224 AST_LIST_UNLOCK(&idle_list);
7225 ast_cli(a->fd, "Active Threads:\n");
7226 AST_LIST_LOCK(&active_list);
7227 AST_LIST_TRAVERSE(&active_list, thread, list) {
7228 if (thread->type == IAX_THREAD_TYPE_DYNAMIC)
7229 type = 'D';
7230 else
7231 type = 'P';
7232#ifdef DEBUG_SCHED_MULTITHREAD
7233 ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d, func='%s'\n",
7234 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7235#else
7236 ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d\n",
7237 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7238#endif
7239 threadcount++;
7240 }
7241 AST_LIST_UNLOCK(&active_list);
7242 ast_cli(a->fd, "Dynamic Threads:\n");
7243 AST_LIST_LOCK(&dynamic_list);
7244 AST_LIST_TRAVERSE(&dynamic_list, thread, list) {
7245#ifdef DEBUG_SCHED_MULTITHREAD
7246 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
7247 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7248#else
7249 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
7250 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7251#endif
7252 dynamiccount++;
7253 }
7254 AST_LIST_UNLOCK(&dynamic_list);
7255 ast_cli(a->fd, "%d of %d threads accounted for with %d dynamic threads\n", threadcount, iaxthreadcount, dynamiccount);
7256 return CLI_SUCCESS;
7257}
7258
7259static char *handle_cli_iax2_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7260{
7261 struct iax2_peer *p;
7262
7263 switch (cmd) {
7264 case CLI_INIT:
7265 e->command = "iax2 unregister";
7266 e->usage =
7267 "Usage: iax2 unregister <peername>\n"
7268 " Unregister (force expiration) an IAX2 peer from the registry.\n";
7269 return NULL;
7270 case CLI_GENERATE:
7271 return complete_iax2_unregister(a->line, a->word, a->pos, a->n);
7272 }
7273
7274 if (a->argc != 3)
7275 return CLI_SHOWUSAGE;
7276
7277 p = find_peer(a->argv[2], 1);
7278 if (p) {
7279 if (p->expire > -1) {
7280 struct iax2_peer *peer;
7281
7282 peer = ao2_find(peers, a->argv[2], OBJ_KEY);
7283 if (peer) {
7284 expire_registry(peer_ref(peer)); /* will release its own reference when done */
7285 peer_unref(peer); /* ref from ao2_find() */
7286 ast_cli(a->fd, "Peer %s unregistered\n", a->argv[2]);
7287 } else {
7288 ast_cli(a->fd, "Peer %s not found\n", a->argv[2]);
7289 }
7290 } else {
7291 ast_cli(a->fd, "Peer %s not registered\n", a->argv[2]);
7292 }
7293 peer_unref(p);
7294 } else {
7295 ast_cli(a->fd, "Peer unknown: %s. Not unregistered\n", a->argv[2]);
7296 }
7297 return CLI_SUCCESS;
7298}
7299
7300static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state)
7301{
7302 int which = 0;
7303 struct iax2_peer *p = NULL;
7304 char *res = NULL;
7305 int wordlen = strlen(word);
7306
7307 /* 0 - iax2; 1 - unregister; 2 - <peername> */
7308 if (pos == 2) {
7309 struct ao2_iterator i = ao2_iterator_init(peers, 0);
7310 while ((p = ao2_iterator_next(&i))) {
7311 if (!strncasecmp(p->name, word, wordlen) &&
7312 ++which > state && p->expire > -1) {
7313 res = ast_strdup(p->name);
7314 peer_unref(p);
7315 break;
7316 }
7317 peer_unref(p);
7318 }
7319 ao2_iterator_destroy(&i);
7320 }
7321
7322 return res;
7323}
7324
7325static char *handle_cli_iax2_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7326{
7327 switch (cmd) {
7328 case CLI_INIT:
7329 e->command = "iax2 show peers";
7330 e->usage =
7331 "Usage: iax2 show peers [registered] [like <pattern>]\n"
7332 " Lists all known IAX2 peers.\n"
7333 " Optional 'registered' argument lists only peers with known addresses.\n"
7334 " Optional regular expression pattern is used to filter the peer list.\n";
7335 return NULL;
7336 case CLI_GENERATE:
7337 return NULL;
7338 }
7339
7340 switch (__iax2_show_peers(a->fd, NULL, NULL, a->argc, a->argv)) {
7341 case RESULT_SHOWUSAGE:
7342 return CLI_SHOWUSAGE;
7343 case RESULT_FAILURE:
7344 return CLI_FAILURE;
7345 default:
7346 return CLI_SUCCESS;
7347 }
7348}
7349
7350static int manager_iax2_show_netstats(struct mansession *s, const struct message *m)
7351{
7352 ast_cli_netstats(s, -1, 0);
7353 astman_append(s, "\r\n");
7354 return RESULT_SUCCESS;
7355}
7356
7357static int firmware_show_callback(struct ast_iax2_firmware_header *header,
7358 void *user_data)
7359{
7360 int *fd = user_data;
7361
7362 ast_cli(*fd, "%-15.15s %-15d %-15d\n",
7363 header->devname,
7364 ntohs(header->version),
7365 (int) ntohl(header->datalen));
7366
7367 return 0;
7368}
7369
7370static char *handle_cli_iax2_show_firmware(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7371{
7372 switch (cmd) {
7373 case CLI_INIT:
7374 e->command = "iax2 show firmware";
7375 e->usage =
7376 "Usage: iax2 show firmware\n"
7377 " Lists all known IAX firmware images.\n";
7378 return NULL;
7379 case CLI_GENERATE:
7380 return NULL;
7381 }
7382
7383 if (a->argc != 3 && a->argc != 4)
7384 return CLI_SHOWUSAGE;
7385
7386 ast_cli(a->fd, "%-15.15s %-15.15s %-15.15s\n", "Device", "Version", "Size");
7387
7388 iax_firmware_traverse(
7389 a->argc == 3 ? NULL : a->argv[3],
7390 firmware_show_callback,
7391 (void *) &a->fd);
7392
7393 return CLI_SUCCESS;
7394}
7395
7396/*! \brief callback to display iax peers in manager */
7397static int manager_iax2_show_peers(struct mansession *s, const struct message *m)
7398{
7399 static const char * const a[] = { "iax2", "show", "peers" };
7400 const char *id = astman_get_header(m,"ActionID");
7401 char idtext[256] = "";
7402 int total = 0;
7403
7404 if (!ast_strlen_zero(id))
7405 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
7406
7407 astman_send_listack(s, m, "Peer status list will follow", "start");
7408
7409 /* List the peers in separate manager events */
7410 __iax2_show_peers(-1, &total, s, 3, a);
7411
7412 /* Send final confirmation */
7413 astman_send_list_complete_start(s, m, "PeerlistComplete", total);
7414 astman_send_list_complete_end(s);
7415 return 0;
7416}
7417
7418/*! \brief callback to display iax peers in manager format */
7419static int manager_iax2_show_peer_list(struct mansession *s, const struct message *m)
7420{
7421 struct show_peers_context cont = {
7422 .havepattern = 0,
7423 .idtext = "",
7424 .registeredonly = 0,
7425
7426 .peerlist = 1,
7427
7428 .total_peers = 0,
7429 .online_peers = 0,
7430 .offline_peers = 0,
7431 .unmonitored_peers = 0,
7432 };
7433
7434 struct iax2_peer *peer = NULL;
7435 struct ao2_iterator i;
7436
7437 const char *id = astman_get_header(m,"ActionID");
7438
7439 if (!ast_strlen_zero(id)) {
7440 snprintf(cont.idtext, sizeof(cont.idtext), "ActionID: %s\r\n", id);
7441 }
7442
7443 astman_send_listack(s, m, "IAX Peer status list will follow", "start");
7444
7445 i = ao2_iterator_init(peers, 0);
7446 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
7447 _iax2_show_peers_one(-1, s, &cont, peer);
7448 }
7449 ao2_iterator_destroy(&i);
7450
7451 astman_send_list_complete_start(s, m, "PeerlistComplete", cont.total_peers);
7452 astman_send_list_complete_end(s);
7453
7454 return RESULT_SUCCESS;
7455}
7456
7457
7458static char *regstate2str(int regstate)
7459{
7460 switch(regstate) {
7461 case REG_STATE_UNREGISTERED:
7462 return "Unregistered";
7463 case REG_STATE_REGSENT:
7464 return "Request Sent";
7465 case REG_STATE_AUTHSENT:
7466 return "Auth. Sent";
7467 case REG_STATE_REGISTERED:
7468 return "Registered";
7469 case REG_STATE_REJECTED:
7470 return "Rejected";
7471 case REG_STATE_TIMEOUT:
7472 return "Timeout";
7473 case REG_STATE_NOAUTH:
7474 return "No Authentication";
7475 default:
7476 return "Unknown";
7477 }
7478}
7479
7480static char *handle_cli_iax2_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7481{
7482#define FORMAT2 "%-45.45s %-6.6s %-10.10s %-45.45s %8.8s %s\n"
7483#define FORMAT "%-45.45s %-6.6s %-10.10s %-45.45s %8d %s\n"
7484
7485 struct iax2_registry *reg = NULL;
7486 char host[80];
7487 char perceived[80];
7488 int counter = 0;
7489
7490 switch (cmd) {
7491 case CLI_INIT:
7492 e->command = "iax2 show registry";
7493 e->usage =
7494 "Usage: iax2 show registry\n"
7495 " Lists all registration requests and status.\n";
7496 return NULL;
7497 case CLI_GENERATE:
7498 return NULL;
7499 }
7500 if (a->argc != 3)
7501 return CLI_SHOWUSAGE;
7502 ast_cli(a->fd, FORMAT2, "Host", "dnsmgr", "Username", "Perceived", "Refresh", "State");
7503 AST_LIST_LOCK(&registrations);
7504 AST_LIST_TRAVERSE(&registrations, reg, entry) {
7505 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
7506
7507 snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
7508
7509 ast_cli(a->fd, FORMAT, host,
7510 (reg->dnsmgr) ? "Y" : "N",
7511 reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
7512 counter++;
7513 }
7514 AST_LIST_UNLOCK(&registrations);
7515 ast_cli(a->fd, "%d IAX2 registrations.\n", counter);
7516 return CLI_SUCCESS;
7517#undef FORMAT
7518#undef FORMAT2
7519}
7520
7521static int manager_iax2_show_registry(struct mansession *s, const struct message *m)
7522{
7523 const char *id = astman_get_header(m, "ActionID");
7524 struct iax2_registry *reg = NULL;
7525 char idtext[256] = "";
7526 char host[80] = "";
7527 char perceived[80] = "";
7528 int total = 0;
7529
7530 if (!ast_strlen_zero(id))
7531 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
7532
7533 astman_send_listack(s, m, "Registrations will follow", "start");
7534
7535 AST_LIST_LOCK(&registrations);
7536 AST_LIST_TRAVERSE(&registrations, reg, entry) {
7537 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
7538
7539 snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
7540
7541 astman_append(s,
7542 "Event: RegistryEntry\r\n"
7543 "%s"
7544 "Host: %s\r\n"
7545 "DNSmanager: %s\r\n"
7546 "Username: %s\r\n"
7547 "Perceived: %s\r\n"
7548 "Refresh: %d\r\n"
7549 "State: %s\r\n"
7550 "\r\n", idtext, host, (reg->dnsmgr) ? "Y" : "N", reg->username, perceived,
7551 reg->refresh, regstate2str(reg->regstate));
7552
7553 total++;
7554 }
7555 AST_LIST_UNLOCK(&registrations);
7556
7557 astman_send_list_complete_start(s, m, "RegistrationsComplete", total);
7558 astman_send_list_complete_end(s);
7559
7560 return 0;
7561}
7562
7563static char *handle_cli_iax2_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7564{
7565#define FORMAT2 "%-20.20s %-40.40s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %-6.6s %s %s %9s\n"
7566#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"
7567#define FORMATB "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d [Native Bridged to ID=%5.5d]\n"
7568 int x;
7569 int numchans = 0;
7570 char first_message[10] = { 0, };
7571 char last_message[10] = { 0, };
7572
7573 switch (cmd) {
7574 case CLI_INIT:
7575 e->command = "iax2 show channels";
7576 e->usage =
7577 "Usage: iax2 show channels\n"
7578 " Lists all currently active IAX channels.\n";
7579 return NULL;
7580 case CLI_GENERATE:
7581 return NULL;
7582 }
7583
7584 if (a->argc != 3)
7585 return CLI_SHOWUSAGE;
7586 ast_cli(a->fd, FORMAT2, "Channel", "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "JitBuf", "Format", "FirstMsg", "LastMsg");
7587 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
7588 ast_mutex_lock(&iaxsl[x]);
7589 if (iaxs[x]) {
7590 int lag, jitter, localdelay;
7591 jb_info jbinfo;
7592 if (ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
7593 jb_getinfo(iaxs[x]->jb, &jbinfo);
7594 jitter = jbinfo.jitter;
7595 localdelay = jbinfo.current - jbinfo.min;
7596 } else {
7597 jitter = -1;
7598 localdelay = 0;
7599 }
7600
7601 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
7602 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
7603 lag = iaxs[x]->remote_rr.delay;
7604 ast_cli(a->fd, FORMAT,
7605 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7606 ast_sockaddr_stringify_addr(&iaxs[x]->addr),
7607 S_OR(iaxs[x]->username, "(None)"),
7608 iaxs[x]->callno, iaxs[x]->peercallno,
7609 iaxs[x]->oseqno, iaxs[x]->iseqno,
7610 lag,
7611 jitter,
7612 localdelay,
7613 iax2_getformatname(iaxs[x]->voiceformat),
7614 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7615 first_message,
7616 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7617 last_message);
7618 numchans++;
7619 }
7620 ast_mutex_unlock(&iaxsl[x]);
7621 }
7622 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
7623 return CLI_SUCCESS;
7624#undef FORMAT
7625#undef FORMAT2
7626#undef FORMATB
7627}
7628
7629static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt)
7630{
7631 int x;
7632 int numchans = 0;
7633 char first_message[10] = { 0, };
7634 char last_message[10] = { 0, };
7635#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"
7636#define ACN_FORMAT2 "%s %u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"
7637 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
7638 ast_mutex_lock(&iaxsl[x]);
7639 if (iaxs[x]) {
7640 int localjitter, localdelay, locallost, locallosspct, localdropped, localooo;
7641 jb_info jbinfo;
7642 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
7643 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
7644
7645 if(ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
7646 jb_getinfo(iaxs[x]->jb, &jbinfo);
7647 localjitter = jbinfo.jitter;
7648 localdelay = jbinfo.current - jbinfo.min;
7649 locallost = jbinfo.frames_lost;
7650 locallosspct = jbinfo.losspct/1000;
7651 localdropped = jbinfo.frames_dropped;
7652 localooo = jbinfo.frames_ooo;
7653 } else {
7654 localjitter = -1;
7655 localdelay = 0;
7656 locallost = -1;
7657 locallosspct = -1;
7658 localdropped = 0;
7659 localooo = -1;
7660 }
7661 if (s)
7662 astman_append(s, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
7663 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7664 iaxs[x]->pingtime,
7665 localjitter,
7666 localdelay,
7667 locallost,
7668 locallosspct,
7669 localdropped,
7670 localooo,
7671 iaxs[x]->frames_received/1000,
7672 iaxs[x]->remote_rr.jitter,
7673 iaxs[x]->remote_rr.delay,
7674 iaxs[x]->remote_rr.losscnt,
7675 iaxs[x]->remote_rr.losspct,
7676 iaxs[x]->remote_rr.dropped,
7677 iaxs[x]->remote_rr.ooo,
7678 iaxs[x]->remote_rr.packets/1000,
7679 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7680 first_message,
7681 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7682 last_message);
7683 else
7684 ast_cli(fd, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
7685 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7686 iaxs[x]->pingtime,
7687 localjitter,
7688 localdelay,
7689 locallost,
7690 locallosspct,
7691 localdropped,
7692 localooo,
7693 iaxs[x]->frames_received/1000,
7694 iaxs[x]->remote_rr.jitter,
7695 iaxs[x]->remote_rr.delay,
7696 iaxs[x]->remote_rr.losscnt,
7697 iaxs[x]->remote_rr.losspct,
7698 iaxs[x]->remote_rr.dropped,
7699 iaxs[x]->remote_rr.ooo,
7700 iaxs[x]->remote_rr.packets/1000,
7701 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7702 first_message,
7703 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7704 last_message);
7705 numchans++;
7706 }
7707 ast_mutex_unlock(&iaxsl[x]);
7708 }
7709
7710 return numchans;
7711}
7712
7713static char *handle_cli_iax2_show_netstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7714{
7715 int numchans = 0;
7716
7717 switch (cmd) {
7718 case CLI_INIT:
7719 e->command = "iax2 show netstats";
7720 e->usage =
7721 "Usage: iax2 show netstats\n"
7722 " Lists network status for all currently active IAX channels.\n";
7723 return NULL;
7724 case CLI_GENERATE:
7725 return NULL;
7726 }
7727 if (a->argc != 3)
7728 return CLI_SHOWUSAGE;
7729 ast_cli(a->fd, " -------- LOCAL --------------------- -------- REMOTE --------------------\n");
7730 ast_cli(a->fd, "Channel RTT Jit Del Lost %% Drop OOO Kpkts Jit Del Lost %% Drop OOO Kpkts FirstMsg LastMsg\n");
7731 numchans = ast_cli_netstats(NULL, a->fd, 1);
7732 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
7733 return CLI_SUCCESS;
7734}
7735
7736static char *handle_cli_iax2_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7737{
7738 switch (cmd) {
7739 case CLI_INIT:
7740 e->command = "iax2 set debug {on|off|peer}";
7741 e->usage =
7742 "Usage: iax2 set debug {on|off|peer peername}\n"
7743 " Enables/Disables dumping of IAX packets for debugging purposes.\n";
7744 return NULL;
7745 case CLI_GENERATE:
7746 if (a->pos == 4 && !strcasecmp(a->argv[3], "peer"))
7747 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
7748 return NULL;
7749 }
7750
7751 if (a->argc < e->args || a->argc > e->args + 1)
7752 return CLI_SHOWUSAGE;
7753
7754 if (!strcasecmp(a->argv[3], "peer")) {
7755 struct iax2_peer *peer;
7756
7757 if (a->argc != e->args + 1)
7758 return CLI_SHOWUSAGE;
7759
7760 peer = find_peer(a->argv[4], 1);
7761
7762 if (!peer) {
7763 ast_cli(a->fd, "IAX2 peer '%s' does not exist\n", a->argv[e->args-1]);
7764 return CLI_FAILURE;
7765 }
7766
7767 ast_sockaddr_copy(&debugaddr, &peer->addr);
7768
7769 ast_cli(a->fd, "IAX2 Debugging Enabled for IP: %s\n", ast_sockaddr_stringify_port(&debugaddr));
7770
7771 ao2_ref(peer, -1);
7772 } else if (!strncasecmp(a->argv[3], "on", 2)) {
7773 iaxdebug = 1;
7774 ast_cli(a->fd, "IAX2 Debugging Enabled\n");
7775 } else {
7776 iaxdebug = 0;
7777 memset(&debugaddr, 0, sizeof(debugaddr));
7778 ast_cli(a->fd, "IAX2 Debugging Disabled\n");
7779 }
7780 return CLI_SUCCESS;
7781}
7782
7783static char *handle_cli_iax2_set_debug_trunk(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7784{
7785 switch (cmd) {
7786 case CLI_INIT:
7787 e->command = "iax2 set debug trunk {on|off}";
7788 e->usage =
7789 "Usage: iax2 set debug trunk {on|off}\n"
7790 " Enables/Disables debugging of IAX trunking\n";
7791 return NULL;
7792 case CLI_GENERATE:
7793 return NULL;
7794 }
7795
7796 if (a->argc != e->args)
7797 return CLI_SHOWUSAGE;
7798
7799 if (!strncasecmp(a->argv[e->args - 1], "on", 2)) {
7800 iaxtrunkdebug = 1;
7801 ast_cli(a->fd, "IAX2 Trunk Debugging Enabled\n");
7802 } else {
7803 iaxtrunkdebug = 0;
7804 ast_cli(a->fd, "IAX2 Trunk Debugging Disabled\n");
7805 }
7806 return CLI_SUCCESS;
7807}
7808
7809static char *handle_cli_iax2_set_debug_jb(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
7810{
7811 switch (cmd) {
7812 case CLI_INIT:
7813 e->command = "iax2 set debug jb {on|off}";
7814 e->usage =
7815 "Usage: iax2 set debug jb {on|off}\n"
7816 " Enables/Disables jitterbuffer debugging information\n";
7817 return NULL;
7818 case CLI_GENERATE:
7819 return NULL;
7820 }
7821
7822 if (a->argc != e->args)
7823 return CLI_SHOWUSAGE;
7824
7825 if (!strncasecmp(a->argv[e->args -1], "on", 2)) {
7826 jb_setoutput(jb_error_output, jb_warning_output, jb_debug_output);
7827 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Enabled\n");
7828 } else {
7829 jb_setoutput(jb_error_output, jb_warning_output, NULL);
7830 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Disabled\n");
7831 }
7832 return CLI_SUCCESS;
7833}
7834
7835static int iax2_write(struct ast_channel *c, struct ast_frame *f)
7836{
7837 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
7838 int res = -1;
7839 ast_mutex_lock(&iaxsl[callno]);
7840 if (iaxs[callno]) {
7841 /* If there's an outstanding error, return failure now */
7842 if (!iaxs[callno]->error) {
7843 if (ast_test_flag64(iaxs[callno], IAX_ALREADYGONE))
7844 res = 0;
7845 /* Don't waste bandwidth sending null frames */
7846 else if (f->frametype == AST_FRAME_NULL)
7847 res = 0;
7848 else if ((f->frametype == AST_FRAME_VOICE) && ast_test_flag64(iaxs[callno], IAX_QUELCH))
7849 res = 0;
7850 else if (!ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
7851 res = 0;
7852 else
7853 /* Simple, just queue for transmission */
7854 res = iax2_send(iaxs[callno], f, 0, -1, 0, 0, 0);
7855 } else {
7856 ast_debug(1, "Write error: %s\n", strerror(errno));
7857 }
7858 }
7859 /* If it's already gone, just return */
7860 ast_mutex_unlock(&iaxsl[callno]);
7861 return res;
7862}
7863
7864static int __send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno,
7865 int now, int transfer, int final)
7866{
7867 struct ast_frame f = { 0, };
7868 int res = 0;
7869
7870 f.frametype = type;
7871 f.subclass.integer = command;
7872 f.datalen = datalen;
7873 f.src = __FUNCTION__;
7874 f.data.ptr = (void *) data;
7875
7876 if ((res = queue_signalling(i, &f)) <= 0) {
7877 return res;
7878 }
7879
7880 return iax2_send(i, &f, ts, seqno, now, transfer, final);
7881}
7882
7883static int send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
7884{
7885 if (type == AST_FRAME_CONTROL && !iax2_is_control_frame_allowed(command)) {
7886 /* Control frame should not go out on the wire. */
7887 ast_debug(2, "Callno %d: Blocked sending control frame %d.\n",
7888 i->callno, command);
7889 return 0;
7890 }
7891 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
7892}
7893
7894static int send_command_locked(unsigned short callno, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
7895{
7896 int res;
7897 ast_mutex_lock(&iaxsl[callno]);
7898 res = send_command(iaxs[callno], type, command, ts, data, datalen, seqno);
7899 ast_mutex_unlock(&iaxsl[callno]);
7900 return res;
7901}
7902
7903/*!
7904 * \note Since this function calls iax2_predestroy() -> iax2_queue_hangup(),
7905 * the pvt struct for the given call number may disappear during its
7906 * execution.
7907 */
7908static int send_command_final(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
7909{
7910 int call_num = i->callno;
7911 /* It is assumed that the callno has already been locked */
7912 iax2_predestroy(i->callno);
7913 if (!iaxs[call_num])
7914 return -1;
7915 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
7916}
7917
7918static int send_command_immediate(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen, int seqno)
7919{
7920 return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
7921}
7922
7923static int send_command_transfer(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, const unsigned char *data, int datalen)
7924{
7925 return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
7926}
7927
7928static int apply_context(struct iax2_context *con, const char *context)
7929{
7930 while(con) {
7931 if (!strcmp(con->context, context) || !strcmp(con->context, "*"))
7932 return -1;
7933 con = con->next;
7934 }
7935 return 0;
7936}
7937
7938
7939static int check_access(int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
7940{
7941 /* Start pessimistic */
7942 int res = -1;
7943 int version = 2;
7944 struct iax2_user *user = NULL, *best = NULL;
7945 int bestscore = 0;
7946 int gotcapability = 0;
7947 struct ast_variable *v = NULL, *tmpvar = NULL;
7948 struct ao2_iterator i;
7949
7950 if (!iaxs[callno])
7951 return res;
7952 if (ies->called_number)
7953 ast_string_field_set(iaxs[callno], exten, ies->called_number);
7954 if (ies->calling_number) {
7955 if (ast_test_flag64(&globalflags, IAX_SHRINKCALLERID)) {
7956 ast_shrink_phone_number(ies->calling_number);
7957 }
7958 ast_string_field_set(iaxs[callno], cid_num, ies->calling_number);
7959 }
7960 if (ies->calling_name)
7961 ast_string_field_set(iaxs[callno], cid_name, ies->calling_name);
7962 if (ies->calling_ani)
7963 ast_string_field_set(iaxs[callno], ani, ies->calling_ani);
7964 if (ies->dnid)
7965 ast_string_field_set(iaxs[callno], dnid, ies->dnid);
7966 if (ies->rdnis)
7967 ast_string_field_set(iaxs[callno], rdnis, ies->rdnis);
7968 if (ies->called_context)
7969 ast_string_field_set(iaxs[callno], context, ies->called_context);
7970 if (ies->language)
7971 ast_string_field_set(iaxs[callno], language, ies->language);
7972 if (ies->username)
7973 ast_string_field_set(iaxs[callno], username, ies->username);
7974 if (ies->calling_ton > -1)
7975 iaxs[callno]->calling_ton = ies->calling_ton;
7976 if (ies->calling_tns > -1)
7977 iaxs[callno]->calling_tns = ies->calling_tns;
7978 if (ies->calling_pres > -1)
7979 iaxs[callno]->calling_pres = ies->calling_pres;
7980 if (ies->calling_ani2 > -1)
7981 iaxs[callno]->calling_ani2 = ies->calling_ani2;
7982 if (ies->format)
7983 iaxs[callno]->peerformat = ies->format;
7984 if (ies->adsicpe)
7985 iaxs[callno]->peeradsicpe = ies->adsicpe;
7986 if (ies->capability) {
7987 gotcapability = 1;
7988 iaxs[callno]->peercapability = ies->capability;
7989 }
7990 if (ies->version)
7991 version = ies->version;
7992
7993 /* Use provided preferences until told otherwise for actual preferences */
7994 if (ies->codec_prefs) {
7995 iax2_codec_pref_convert(&iaxs[callno]->rprefs, ies->codec_prefs, 32, 0);
7996 } else {
7997 memset(&iaxs[callno]->rprefs, 0, sizeof(iaxs[callno]->rprefs));
7998 }
7999 iaxs[callno]->prefs = iaxs[callno]->rprefs;
8000
8001 if (!gotcapability) {
8002 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
8003 }
8004 if (version > IAX_PROTO_VERSION) {
8005 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
8006 ast_sockaddr_stringify_addr(addr), version);
8007 return res;
8008 }
8009 /* Search the userlist for a compatible entry, and fill in the rest */
8010 i = ao2_iterator_init(users, 0);
8011 while ((user = ao2_iterator_next(&i))) {
8012 if ((ast_strlen_zero(iaxs[callno]->username) || /* No username specified */
8013 !strcmp(iaxs[callno]->username, user->name)) /* Or this username specified */
8014 && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_ALLOW) /* Access is permitted from this IP */
8015 && (ast_strlen_zero(iaxs[callno]->context) || /* No context specified */
8016 apply_context(user->contexts, iaxs[callno]->context))) { /* Context is permitted */
8017 if (!ast_strlen_zero(iaxs[callno]->username)) {
8018 /* Exact match, stop right now. */
8019 if (best)
8020 user_unref(best);
8021 best = user;
8022 break;
8023 } else if (ast_strlen_zero(user->secret) && ast_strlen_zero(user->dbsecret) && ast_strlen_zero(user->inkeys)) {
8024 /* No required authentication */
8025 if (user->acl) {
8026 /* There was host authentication and we passed, bonus! */
8027 if (bestscore < 4) {
8028 bestscore = 4;
8029 if (best)
8030 user_unref(best);
8031 best = user;
8032 continue;
8033 }
8034 } else {
8035 /* No host access, but no secret, either, not bad */
8036 if (bestscore < 3) {
8037 bestscore = 3;
8038 if (best)
8039 user_unref(best);
8040 best = user;
8041 continue;
8042 }
8043 }
8044 } else {
8045 if (user->acl) {
8046 /* Authentication, but host access too, eh, it's something.. */
8047 if (bestscore < 2) {
8048 bestscore = 2;
8049 if (best)
8050 user_unref(best);
8051 best = user;
8052 continue;
8053 }
8054 } else {
8055 /* Authentication and no host access... This is our baseline */
8056 if (bestscore < 1) {
8057 bestscore = 1;
8058 if (best)
8059 user_unref(best);
8060 best = user;
8061 continue;
8062 }
8063 }
8064 }
8065 }
8066 user_unref(user);
8067 }
8068 ao2_iterator_destroy(&i);
8069 user = best;
8070 if (!user && !ast_strlen_zero(iaxs[callno]->username)) {
8071 user = realtime_user(iaxs[callno]->username, addr);
8072 if (user && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_DENY /* Access is denied from this IP */
8073 || (!ast_strlen_zero(iaxs[callno]->context) && /* No context specified */
8074 !apply_context(user->contexts, iaxs[callno]->context)))) { /* Context is permitted */
8075 user = user_unref(user);
8076 }
8077 }
8078 if (user) {
8079 /* We found our match (use the first) */
8080 /* copy vars */
8081 for (v = user->vars ; v ; v = v->next) {
8082 if ((tmpvar = ast_variable_new(v->name, v->value, v->file))) {
8083 if (ast_variable_list_replace(&iaxs[callno]->vars, tmpvar)) {
8084 tmpvar->next = iaxs[callno]->vars;
8085 iaxs[callno]->vars = tmpvar;
8086 }
8087 }
8088 }
8089 /* If a max AUTHREQ restriction is in place, activate it */
8090 if (user->maxauthreq > 0)
8091 ast_set_flag64(iaxs[callno], IAX_MAXAUTHREQ);
8092 iaxs[callno]->prefs = user->prefs;
8093 ast_copy_flags64(iaxs[callno], user, IAX_CODEC_USER_FIRST | IAX_IMMEDIATE | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_FORCE_ENCRYPT);
8094 iaxs[callno]->encmethods = user->encmethods;
8095 /* Store the requested username if not specified */
8096 if (ast_strlen_zero(iaxs[callno]->username))
8097 ast_string_field_set(iaxs[callno], username, user->name);
8098 /* Store whether this is a trunked call, too, of course, and move if appropriate */
8099 ast_copy_flags64(iaxs[callno], user, IAX_TRUNK);
8100 iaxs[callno]->capability = user->capability;
8101 /* And use the default context */
8102 if (ast_strlen_zero(iaxs[callno]->context)) {
8103 if (user->contexts)
8104 ast_string_field_set(iaxs[callno], context, user->contexts->context);
8105 else
8106 ast_string_field_set(iaxs[callno], context, DEFAULT_CONTEXT);
8107 }
8108 /* And any input keys */
8109 ast_string_field_set(iaxs[callno], inkeys, user->inkeys);
8110 /* And the permitted authentication methods */
8111 iaxs[callno]->authmethods = user->authmethods;
8112 iaxs[callno]->adsi = user->adsi;
8113 /* If the user has callerid, override the remote caller id. */
8114 if (ast_test_flag64(user, IAX_HASCALLERID)) {
8115 iaxs[callno]->calling_tns = 0;
8116 iaxs[callno]->calling_ton = 0;
8117 ast_string_field_set(iaxs[callno], cid_num, user->cid_num);
8118 ast_string_field_set(iaxs[callno], cid_name, user->cid_name);
8119 ast_string_field_set(iaxs[callno], ani, user->cid_num);
8120 iaxs[callno]->calling_pres = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
8121 } else if (ast_strlen_zero(iaxs[callno]->cid_num) && ast_strlen_zero(iaxs[callno]->cid_name)) {
8122 iaxs[callno]->calling_pres = AST_PRES_NUMBER_NOT_AVAILABLE;
8123 } /* else user is allowed to set their own CID settings */
8124 if (!ast_strlen_zero(user->accountcode))
8125 ast_string_field_set(iaxs[callno], accountcode, user->accountcode);
8126 if (!ast_strlen_zero(user->mohinterpret))
8127 ast_string_field_set(iaxs[callno], mohinterpret, user->mohinterpret);
8128 if (!ast_strlen_zero(user->mohsuggest))
8129 ast_string_field_set(iaxs[callno], mohsuggest, user->mohsuggest);
8130 if (!ast_strlen_zero(user->parkinglot))
8131 ast_string_field_set(iaxs[callno], parkinglot, user->parkinglot);
8132 if (user->amaflags)
8133 iaxs[callno]->amaflags = user->amaflags;
8134 if (!ast_strlen_zero(user->language))
8135 ast_string_field_set(iaxs[callno], language, user->language);
8136 ast_copy_flags64(iaxs[callno], user, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
8137 /* Keep this check last */
8138 if (!ast_strlen_zero(user->dbsecret)) {
8139 char *family, *key=NULL;
8140 char buf[80];
8141 family = ast_strdupa(user->dbsecret);
8142 key = strchr(family, '/');
8143 if (key) {
8144 *key = '\0';
8145 key++;
8146 }
8147 if (!key || ast_db_get(family, key, buf, sizeof(buf)))
8148 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", user->dbsecret);
8149 else
8150 ast_string_field_set(iaxs[callno], secret, buf);
8151 } else
8152 ast_string_field_set(iaxs[callno], secret, user->secret);
8153 res = 0;
8154 user = user_unref(user);
8155 } else {
8156 /* user was not found, but we should still fake an AUTHREQ.
8157 * Set authmethods to the last known authmethod used by the system
8158 * Set a fake secret, it's not looked at, just required to attempt authentication.
8159 * Set authrej so the AUTHREP is rejected without even looking at its contents */
8160 iaxs[callno]->authmethods = last_authmethod ? last_authmethod : IAX_AUTH_MD5;
8161 ast_string_field_set(iaxs[callno], secret, "badsecret");
8162 iaxs[callno]->authrej = 1;
8163 if (!ast_strlen_zero(iaxs[callno]->username)) {
8164 /* only send the AUTHREQ if a username was specified. */
8165 res = 0;
8166 }
8167 }
8168 ast_set2_flag64(iaxs[callno], iax2_getpeertrunk(*addr), IAX_TRUNK);
8169 return res;
8170}
8171
8172static int raw_hangup(struct ast_sockaddr *addr, unsigned short src, unsigned short dst, int sockfd)
8173{
8174 struct ast_iax2_full_hdr fh;
8175 fh.scallno = htons(src | IAX_FLAG_FULL);
8176 fh.dcallno = htons(dst);
8177 fh.ts = 0;
8178 fh.oseqno = 0;
8179 fh.iseqno = 0;
8180 fh.type = AST_FRAME_IAX;
8181 fh.csub = compress_subclass(IAX_COMMAND_INVAL);
8182 iax_outputframe(NULL, &fh, 0, addr, 0);
8183
8184 ast_debug(1, "Raw Hangup %s, src=%d, dst=%d\n", ast_sockaddr_stringify(addr), src, dst);
8185 return ast_sendto(sockfd, &fh, sizeof(fh), 0, addr);
8186}
8187
8188static void merge_encryption(struct chan_iax2_pvt *p, unsigned int enc)
8189{
8190 /* Select exactly one common encryption if there are any */
8191 p->encmethods &= enc;
8192 if (p->encmethods) {
8193 if (!(p->encmethods & IAX_ENCRYPT_KEYROTATE)){ /* if key rotation is not supported, turn off keyrotation. */
8194 p->keyrotateid = -2;
8195 }
8196 if (p->encmethods & IAX_ENCRYPT_AES128)
8197 p->encmethods = IAX_ENCRYPT_AES128;
8198 else
8199 p->encmethods = 0;
8200 }
8201}
8202
8203/*!
8204 * \pre iaxsl[call_num] is locked
8205 *
8206 * \note Since this function calls send_command_final(), the pvt struct for the given
8207 * call number may disappear while executing this function.
8208 */
8209static int authenticate_request(int call_num)
8210{
8211 struct iax_ie_data ied;
8212 int res = -1, authreq_restrict = 0;
8213 char challenge[10];
8214 struct chan_iax2_pvt *p = iaxs[call_num];
8215
8216 memset(&ied, 0, sizeof(ied));
8217
8218 /* If an AUTHREQ restriction is in place, make sure we can send an AUTHREQ back */
8219 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
8220 struct iax2_user *user;
8221
8222 user = ao2_find(users, p->username, OBJ_KEY);
8223 if (user) {
8224 if (user->curauthreq == user->maxauthreq)
8225 authreq_restrict = 1;
8226 else
8227 user->curauthreq++;
8228 user = user_unref(user);
8229 }
8230 }
8231
8232 /* If the AUTHREQ limit test failed, send back an error */
8233 if (authreq_restrict) {
8234 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Unauthenticated call limit reached");
8235 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_CALL_REJECTED);
8236 send_command_final(p, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
8237 return 0;
8238 }
8239
8240 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, p->authmethods);
8241 if (p->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA)) {
8242 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
8243 ast_string_field_set(p, challenge, challenge);
8244 /* snprintf(p->challenge, sizeof(p->challenge), "%d", (int)ast_random()); */
8245 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, p->challenge);
8246 }
8247 if (p->encmethods)
8248 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, p->encmethods);
8249
8250 iax_ie_append_str(&ied,IAX_IE_USERNAME, p->username);
8251
8252 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREQ, 0, ied.buf, ied.pos, -1);
8253
8254 if (p->encmethods)
8255 ast_set_flag64(p, IAX_ENCRYPTED);
8256
8257 return res;
8258}
8259
8260static int authenticate_verify(struct chan_iax2_pvt *p, struct iax_ies *ies)
8261{
8262 char requeststr[256];
8263 char md5secret[256] = "";
8264 char secret[256] = "";
8265 char rsasecret[256] = "";
8266 int res = -1;
8267 int x;
8268 struct iax2_user *user;
8269
8270 if (p->authrej) {
8271 return res;
8272 }
8273
8274 user = ao2_find(users, p->username, OBJ_KEY);
8275 if (user) {
8276 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
8277 ast_atomic_fetchadd_int(&user->curauthreq, -1);
8278 ast_clear_flag64(p, IAX_MAXAUTHREQ);
8279 }
8280 ast_string_field_set(p, host, user->name);
8281 user = user_unref(user);
8282 }
8283 if (ast_test_flag64(p, IAX_FORCE_ENCRYPT) && !p->encmethods) {
8284 ast_log(LOG_WARNING, "Call Terminated, incoming call is unencrypted while force encrypt is enabled.\n");
8285 return res;
8286 }
8287 if (!ast_test_flag(&p->state, IAX_STATE_AUTHENTICATED))
8288 return res;
8289 if (ies->password)
8290 ast_copy_string(secret, ies->password, sizeof(secret));
8291 if (ies->md5_result)
8292 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
8293 if (ies->rsa_result)
8294 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
8295 if ((p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(rsasecret) && !ast_strlen_zero(p->inkeys)) {
8296 struct ast_key *key;
8297 char *keyn;
8298 char *tmpkey;
8299 char *stringp=NULL;
8300 if (!(tmpkey = ast_strdup(p->inkeys))) {
8301 ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
8302 return res;
8303 }
8304 stringp = tmpkey;
8305 keyn = strsep(&stringp, ":");
8306 while(keyn) {
8307 key = ast_key_get(keyn, AST_KEY_PUBLIC);
8308 if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
8309 res = 0;
8310 p->eff_auth_method = IAX_AUTH_RSA;
8311 break;
8312 } else if (!key) {
8313 ast_log(LOG_WARNING, "Requested inkey '%s' for RSA authentication does not exist\n", keyn);
8314 }
8315 keyn = strsep(&stringp, ":");
8316 }
8317 ast_free(tmpkey);
8318 if (res && authdebug) {
8319 ast_log(LOG_WARNING, "No RSA public keys on file matched incoming call\n");
8320 }
8321 } else if (p->authmethods & IAX_AUTH_MD5) {
8322 struct MD5Context md5;
8323 unsigned char digest[16];
8324 char *tmppw, *stringp;
8325 tmppw = ast_strdupa(p->secret);
8326 stringp = tmppw;
8327 while((tmppw = strsep(&stringp, ";"))) {
8328 MD5Init(&md5);
8329 MD5Update(&md5, (unsigned char *)p->challenge, strlen(p->challenge));
8330 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
8331 MD5Final(digest, &md5);
8332 /* If they support md5, authenticate with it. */
8333 for (x=0;x<16;x++)
8334 sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
8335 if (!strcasecmp(requeststr, md5secret)) {
8336 res = 0;
8337 p->eff_auth_method = IAX_AUTH_MD5;
8338 break;
8339 } else if (authdebug) {
8340 ast_log(LOG_WARNING, "MD5 secret mismatch\n");
8341 }
8342 }
8343 } else if (p->authmethods & IAX_AUTH_PLAINTEXT) {
8344 if (!strcmp(secret, p->secret)) {
8345 res = 0;
8346 p->eff_auth_method = IAX_AUTH_PLAINTEXT;
8347 } else if (authdebug) {
8348 ast_log(LOG_WARNING, "Plaintext secret mismatch\n");
8349 }
8350 }
8351 return res;
8352}
8353
8354/*! \brief Verify inbound registration */
8355static int register_verify(int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
8356{
8357 char requeststr[256] = "";
8358 char peer[256] = "";
8359 char md5secret[256] = "";
8360 char rsasecret[256] = "";
8361 char secret[256] = "";
8362 struct iax2_peer *p = NULL;
8363 struct ast_key *key;
8364 char *keyn;
8365 int x;
8366 int expire = 0;
8367 int res = -1;
8368
8369 ast_clear_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8370 /* iaxs[callno]->peer[0] = '\0'; not necc. any more-- stringfield is pre-inited to null string */
8371 if (ies->username)
8372 ast_copy_string(peer, ies->username, sizeof(peer));
8373 if (ies->password)
8374 ast_copy_string(secret, ies->password, sizeof(secret));
8375 if (ies->md5_result)
8376 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
8377 if (ies->rsa_result)
8378 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
8379 if (ies->refresh)
8380 expire = ies->refresh;
8381
8382 if (ast_strlen_zero(peer)) {
8383 ast_log(LOG_NOTICE, "Empty registration from %s\n", ast_sockaddr_stringify_addr(addr));
8384 return -1;
8385 }
8386
8387 /* SLD: first call to lookup peer during registration */
8388 ast_mutex_unlock(&iaxsl[callno]);
8389 p = find_peer(peer, 1);
8390 ast_mutex_lock(&iaxsl[callno]);
8391 if (!p || !iaxs[callno]) {
8392 if (iaxs[callno]) {
8393 int plaintext = ((last_authmethod & IAX_AUTH_PLAINTEXT) | (iaxs[callno]->authmethods & IAX_AUTH_PLAINTEXT));
8394 /* Anything, as long as it's non-blank */
8395 ast_string_field_set(iaxs[callno], secret, "badsecret");
8396 /* An AUTHREQ must be sent in response to a REGREQ of an invalid peer unless
8397 * 1. A challenge already exists indicating a AUTHREQ was already sent out.
8398 * 2. A plaintext secret is present in ie as result of a previous AUTHREQ requesting it.
8399 * 3. A plaintext secret is present in the ie and the last_authmethod used by a peer happened
8400 * to be plaintext, indicating it is an authmethod used by other peers on the system.
8401 *
8402 * If none of these cases exist, res will be returned as 0 without authentication indicating
8403 * an AUTHREQ needs to be sent out. */
8404
8405 if (ast_strlen_zero(iaxs[callno]->challenge) &&
8406 !(!ast_strlen_zero(secret) && plaintext)) {
8407 /* by setting res to 0, an REGAUTH will be sent */
8408 res = 0;
8409 }
8410 }
8411 if (authdebug && !p)
8412 ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
8413 goto return_unref;
8414 }
8415
8416 if (!ast_test_flag64(p, IAX_DYNAMIC)) {
8417 if (authdebug)
8418 ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
8419 goto return_unref;
8420 }
8421
8422 if (!ast_apply_acl(p->acl, addr, "IAX2 Peer ACL: ")) {
8423 if (authdebug)
8424 ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
8425 goto return_unref;
8426 }
8427 ast_string_field_set(iaxs[callno], secret, p->secret);
8428 ast_string_field_set(iaxs[callno], inkeys, p->inkeys);
8429 /* Check secret against what we have on file */
8430 if (!ast_strlen_zero(rsasecret) && (p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(iaxs[callno]->challenge)) {
8431 if (!ast_strlen_zero(p->inkeys)) {
8432 char *tmpkey;
8433 char *stringp=NULL;
8434 if (!(tmpkey = ast_strdup(p->inkeys))) {
8435 ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
8436 goto return_unref;
8437 }
8438 stringp = tmpkey;
8439 keyn = strsep(&stringp, ":");
8440 while(keyn) {
8441 key = ast_key_get(keyn, AST_KEY_PUBLIC);
8442 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
8443 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8444 break;
8445 } else if (!key)
8446 ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
8447 keyn = strsep(&stringp, ":");
8448 }
8449 ast_free(tmpkey);
8450 if (!keyn) {
8451 if (authdebug)
8452 ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
8453 goto return_unref;
8454 }
8455 } else {
8456 if (authdebug)
8457 ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
8458 goto return_unref;
8459 }
8460 } else if (!ast_strlen_zero(md5secret) && (p->authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(iaxs[callno]->challenge)) {
8461 struct MD5Context md5;
8462 unsigned char digest[16];
8463 char *tmppw, *stringp;
8464
8465 tmppw = ast_strdupa(p->secret);
8466 stringp = tmppw;
8467 while((tmppw = strsep(&stringp, ";"))) {
8468 MD5Init(&md5);
8469 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
8470 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
8471 MD5Final(digest, &md5);
8472 for (x=0;x<16;x++)
8473 sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
8474 if (!strcasecmp(requeststr, md5secret))
8475 break;
8476 }
8477 if (tmppw) {
8478 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8479 } else {
8480 if (authdebug)
8481 ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", ast_sockaddr_stringify_addr(addr), p->name, requeststr, md5secret);
8482 goto return_unref;
8483 }
8484 } else if (!ast_strlen_zero(secret) && (p->authmethods & IAX_AUTH_PLAINTEXT)) {
8485 /* They've provided a plain text password and we support that */
8486 if (strcmp(secret, p->secret)) {
8487 if (authdebug)
8488 ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
8489 goto return_unref;
8490 } else
8491 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8492 } else if (!ast_strlen_zero(iaxs[callno]->challenge) && ast_strlen_zero(md5secret) && ast_strlen_zero(rsasecret)) {
8493 /* if challenge has been sent, but no challenge response if given, reject. */
8494 goto return_unref;
8495 }
8496 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
8497
8498 /* either Authentication has taken place, or a REGAUTH must be sent before verifying registration */
8499 res = 0;
8500
8501return_unref:
8502 if (iaxs[callno]) {
8503 ast_string_field_set(iaxs[callno], peer, peer);
8504
8505 /* Choose lowest expiry number */
8506 if (expire && (expire < iaxs[callno]->expiry)) {
8507 iaxs[callno]->expiry = expire;
8508 }
8509 }
8510
8511 if (p) {
8512 peer_unref(p);
8513 }
8514 return res;
8515}
8516
8517static 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)
8518{
8519 int res = -1;
8520 int x;
8521 if (!ast_strlen_zero(keyn)) {
8522 if (!(authmethods & IAX_AUTH_RSA)) {
8523 if (ast_strlen_zero(secret)) {
8524 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));
8525 }
8526 } else if (ast_strlen_zero(challenge)) {
8527 ast_log(LOG_WARNING, "No challenge provided for RSA authentication to %s\n", ast_sockaddr_stringify_addr(addr));
8528 } else {
8529 char sig[256];
8530 struct ast_key *key;
8531 key = ast_key_get(keyn, AST_KEY_PRIVATE);
8532 if (!key) {
8533 ast_log(LOG_WARNING, "Unable to find private key '%s'\n", keyn);
8534 } else {
8535 if (ast_sign(key, (char*)challenge, sig)) {
8536 ast_log(LOG_WARNING, "Unable to sign challenge with key\n");
8537 res = -1;
8538 } else {
8539 iax_ie_append_str(ied, IAX_IE_RSA_RESULT, sig);
8540 if (pvt) {
8541 pvt->eff_auth_method = IAX_AUTH_RSA;
8542 }
8543 res = 0;
8544 }
8545 }
8546
8547 if (pvt && !ast_strlen_zero(secret)) {
8548 struct MD5Context md5;
8549 unsigned char digest[16];
8550
8551 MD5Init(&md5);
8552 MD5Update(&md5, (unsigned char *) challenge, strlen(challenge));
8553 MD5Update(&md5, (unsigned char *) secret, strlen(secret));
8554 MD5Final(digest, &md5);
8555
8556 build_encryption_keys(digest, pvt);
8557 }
8558 }
8559 }
8560 /* Fall back */
8561 if (res && !ast_strlen_zero(secret)) {
8562 if ((authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(challenge)) {
8563 struct MD5Context md5;
8564 unsigned char digest[16];
8565 char digres[128];
8566 MD5Init(&md5);
8567 MD5Update(&md5, (unsigned char *)challenge, strlen(challenge));
8568 MD5Update(&md5, (unsigned char *)secret, strlen(secret));
8569 MD5Final(digest, &md5);
8570 /* If they support md5, authenticate with it. */
8571 for (x=0;x<16;x++)
8572 sprintf(digres + (x << 1), "%02hhx", digest[x]); /* safe */
8573 if (pvt) {
8574 build_encryption_keys(digest, pvt);
8575 pvt->eff_auth_method = IAX_AUTH_MD5;
8576 }
8577 iax_ie_append_str(ied, IAX_IE_MD5_RESULT, digres);
8578 res = 0;
8579 } else if (authmethods & IAX_AUTH_PLAINTEXT) {
8580 iax_ie_append_str(ied, IAX_IE_PASSWORD, secret);
8581 if (pvt) {
8582 pvt->eff_auth_method = IAX_AUTH_PLAINTEXT;
8583 }
8584 res = 0;
8585 } else
8586 ast_log(LOG_WARNING, "No way to send secret to peer '%s' (their methods: %d)\n", ast_sockaddr_stringify_addr(addr), authmethods);
8587 }
8588 return res;
8589}
8590
8591/*!
8592 * \note This function calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
8593 * so do not call this function with a pvt lock held.
8594 */
8595static int authenticate_reply(struct chan_iax2_pvt *p, struct ast_sockaddr *addr, struct iax_ies *ies, const char *override, const char *okey)
8596{
8597 struct iax2_peer *peer = NULL;
8598 /* Start pessimistic */
8599 int res = -1;
8600 int authmethods = 0;
8601 struct iax_ie_data ied;
8602 uint16_t callno = p->callno;
8603
8604 memset(&ied, 0, sizeof(ied));
8605
8606 if (ies->username)
8607 ast_string_field_set(p, username, ies->username);
8608 if (ies->challenge)
8609 ast_string_field_set(p, challenge, ies->challenge);
8610 if (ies->authmethods)
8611 authmethods = ies->authmethods;
8612 if (authmethods & IAX_AUTH_MD5)
8613 merge_encryption(p, ies->encmethods);
8614 else
8615 p->encmethods = 0;
8616
8617 /* Check for override RSA authentication first */
8618 if (!ast_strlen_zero(override) || !ast_strlen_zero(okey)) {
8619 /* Normal password authentication */
8620 res = authenticate(p->challenge, override, okey, authmethods, &ied, addr, p);
8621 } else {
8622 struct ao2_iterator i = ao2_iterator_init(peers, 0);
8623 while ((peer = ao2_iterator_next(&i))) {
8624 struct ast_sockaddr peer_addr;
8625 struct ast_sockaddr tmp_sockaddr1;
8626 struct ast_sockaddr tmp_sockaddr2;
8627
8628 ast_sockaddr_copy(&peer_addr, &peer->addr);
8629
8630 ast_sockaddr_apply_netmask(addr, &peer->mask, &tmp_sockaddr1);
8631 ast_sockaddr_apply_netmask(&peer_addr, &peer->mask, &tmp_sockaddr2);
8632
8633 if ((ast_strlen_zero(p->peer) || !strcmp(p->peer, peer->name))
8634 /* No peer specified at our end, or this is the peer */
8635 && (ast_strlen_zero(peer->username) || (!strcmp(peer->username, p->username)))
8636 /* No username specified in peer rule, or this is the right username */
8637 && (ast_sockaddr_isnull(&peer_addr) || !(ast_sockaddr_cmp_addr(&tmp_sockaddr1, &tmp_sockaddr2)))
8638 /* No specified host, or this is our host */
8639 ) {
8640 res = authenticate(p->challenge, peer->secret, peer->outkey, authmethods, &ied, addr, p);
8641 if (!res) {
8642 peer_unref(peer);
8643 break;
8644 }
8645 }
8646 peer_unref(peer);
8647 }
8648 ao2_iterator_destroy(&i);
8649 if (!peer) {
8650 /* We checked our list and didn't find one. It's unlikely, but possible,
8651 that we're trying to authenticate *to* a realtime peer */
8652 const char *peer_name = ast_strdupa(p->peer);
8653 ast_mutex_unlock(&iaxsl[callno]);
8654 if ((peer = realtime_peer(peer_name, NULL))) {
8655 ast_mutex_lock(&iaxsl[callno]);
8656 if (!(p = iaxs[callno])) {
8657 peer_unref(peer);
8658 return -1;
8659 }
8660 res = authenticate(p->challenge, peer->secret,peer->outkey, authmethods, &ied, addr, p);
8661 peer_unref(peer);
8662 }
8663 if (!peer) {
8664 ast_mutex_lock(&iaxsl[callno]);
8665 if (!(p = iaxs[callno]))
8666 return -1;
8667 }
8668 }
8669 }
8670
8671 if (!(ies->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT)) && (ies->authmethods & IAX_AUTH_RSA) && ast_strlen_zero(okey)) {
8672 /* If the only thing available is RSA, and we don't have an outkey, we can't do it... */
8673 ast_log(LOG_WARNING, "Call terminated. RSA authentication requires an outkey\n");
8674 return -1;
8675 }
8676
8677 if (ies->encmethods) {
8678 if (ast_strlen_zero(p->secret) &&
8679 ((ies->authmethods & IAX_AUTH_RSA) || (ies->authmethods & IAX_AUTH_MD5) || (ies->authmethods & IAX_AUTH_PLAINTEXT))) {
8680 ast_log(LOG_WARNING, "Call terminated. Encryption requested by peer but no secret available locally\n");
8681 return -1;
8682 }
8683 /* Don't even THINK about trying to encrypt or decrypt anything if we don't have valid keys, for some reason... */
8684 /* If either of these happens, it's our fault, not the user's. But we should abort rather than crash. */
8685 ast_assert_return(!invalid_key(&p->ecx), -1);
8686 ast_assert_return(!invalid_key(&p->dcx), -1);
8687 ast_set_flag64(p, IAX_ENCRYPTED | IAX_KEYPOPULATED);
8688 } else if (ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
8689 ast_log(LOG_NOTICE, "Call initiated without encryption while forceencryption=yes option is set\n");
8690 return -1; /* if force encryption is yes, and no encryption methods, then return -1 to hangup */
8691 }
8692 if (!res) {
8693 struct ast_datastore *variablestore;
8694 struct ast_variable *var, *prev = NULL;
8695 AST_LIST_HEAD(, ast_var_t) *varlist;
8696 varlist = ast_calloc(1, sizeof(*varlist));
8697 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
8698 if (variablestore && varlist && p->owner) {
8699 variablestore->data = varlist;
8700 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
8701 AST_LIST_HEAD_INIT(varlist);
8702 for (var = ies->vars; var; var = var->next) {
8703 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
8704 if (prev)
8705 ast_free(prev);
8706 prev = var;
8707 if (!newvar) {
8708 /* Don't abort list traversal, as this would leave ies->vars in an inconsistent state. */
8709 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
8710 } else {
8711 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
8712 }
8713 }
8714 if (prev)
8715 ast_free(prev);
8716 ies->vars = NULL;
8717 ast_channel_datastore_add(p->owner, variablestore);
8718 } else {
8719 if (p->owner)
8720 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
8721 if (variablestore)
8722 ast_datastore_free(variablestore);
8723 if (varlist)
8724 ast_free(varlist);
8725 }
8726 }
8727
8728 if (!res)
8729 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1);
8730 return res;
8731}
8732
8733static int iax2_do_register(struct iax2_registry *reg);
8734
8735static void __iax2_do_register_s(const void *data)
8736{
8737 struct iax2_registry *reg = (struct iax2_registry *)data;
8738
8739 if (ast_sockaddr_isnull(&reg->addr)) {
8740 reg->addr.ss.ss_family = AST_AF_UNSPEC;
8741 ast_dnsmgr_lookup(reg->hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL);
8742 if (!ast_sockaddr_port(&reg->addr)) {
8743 ast_sockaddr_set_port(&reg->addr, reg->port);
8744 } else {
8745 reg->port = ast_sockaddr_port(&reg->addr);
8746 }
8747 }
8748
8749 reg->expire = -1;
8750 iax2_do_register(reg);
8751}
8752
8753static int iax2_do_register_s(const void *data)
8754{
8755#ifdef SCHED_MULTITHREADED
8756 if (schedule_action(__iax2_do_register_s, data))
8757#endif
8758 __iax2_do_register_s(data);
8759 return 0;
8760}
8761
8762static int try_transfer(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
8763{
8764 int newcall = 0;
8765 struct iax_ie_data ied;
8766 struct ast_sockaddr new = { {0,} };
8767
8768 memset(&ied, 0, sizeof(ied));
8769 if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
8770 ast_sockaddr_copy(&new, &ies->apparent_addr);
8771 }
8772 if (ies->callno) {
8773 newcall = ies->callno;
8774 }
8775 if (!newcall || ast_sockaddr_isnull(&new)) {
8776 ast_log(LOG_WARNING, "Invalid transfer request\n");
8777 return -1;
8778 }
8779 pvt->transfercallno = newcall;
8780 ast_sockaddr_copy(&pvt->transfer, &new);
8781 pvt->transferid = ies->transferid;
8782 /* only store by transfercallno if this is a new transfer,
8783 * just in case we get a duplicate TXREQ */
8784 if (pvt->transferring == TRANSFER_NONE) {
8785 store_by_transfercallno(pvt);
8786 }
8787 pvt->transferring = TRANSFER_BEGIN;
8788
8789 if (ies->transferid) {
8790 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, ies->transferid);
8791 }
8792 send_command_transfer(pvt, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos);
8793 return 0;
8794}
8795
8796static int complete_dpreply(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
8797{
8798 char exten[256] = "";
8799 int status = CACHE_FLAG_UNKNOWN, expiry = iaxdefaultdpcache, x, matchmore = 0;
8800 struct iax2_dpcache *dp = NULL;
8801
8802 if (ies->called_number)
8803 ast_copy_string(exten, ies->called_number, sizeof(exten));
8804
8805 if (ies->dpstatus & IAX_DPSTATUS_EXISTS)
8806 status = CACHE_FLAG_EXISTS;
8807 else if (ies->dpstatus & IAX_DPSTATUS_CANEXIST)
8808 status = CACHE_FLAG_CANEXIST;
8809 else if (ies->dpstatus & IAX_DPSTATUS_NONEXISTENT)
8810 status = CACHE_FLAG_NONEXISTENT;
8811
8812 if (ies->refresh)
8813 expiry = ies->refresh;
8814 if (ies->dpstatus & IAX_DPSTATUS_MATCHMORE)
8815 matchmore = CACHE_FLAG_MATCHMORE;
8816
8817 AST_LIST_LOCK(&dpcache);
8818 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, peer_list) {
8819 if (strcmp(dp->exten, exten))
8820 continue;
8821 AST_LIST_REMOVE_CURRENT(peer_list);
8822 dp->callno = 0;
8823 dp->expiry.tv_sec = dp->orig.tv_sec + expiry;
8824 if (dp->flags & CACHE_FLAG_PENDING) {
8825 dp->flags &= ~CACHE_FLAG_PENDING;
8826 dp->flags |= status;
8827 dp->flags |= matchmore;
8828 }
8829 /* Wake up waiters */
8830 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
8831 if (dp->waiters[x] > -1) {
8832 if (write(dp->waiters[x], "asdf", 4) < 0) {
8833 }
8834 }
8835 }
8836 }
8837 AST_LIST_TRAVERSE_SAFE_END;
8838 AST_LIST_UNLOCK(&dpcache);
8839
8840 return 0;
8841}
8842
8843static int complete_transfer(int callno, struct iax_ies *ies)
8844{
8845 int peercallno = 0;
8846 struct chan_iax2_pvt *pvt = iaxs[callno];
8847 struct iax_frame *cur;
8848 jb_frame frame;
8849
8850 if (ies->callno)
8851 peercallno = ies->callno;
8852
8853 if (peercallno < 1) {
8854 ast_log(LOG_WARNING, "Invalid transfer request\n");
8855 return -1;
8856 }
8857 remove_by_transfercallno(pvt);
8858 /* since a transfer has taken place, the address will change.
8859 * This must be accounted for in the peercnts table. Remove
8860 * the old address and add the new one */
8861 peercnt_remove_by_addr(&pvt->addr);
8862 peercnt_add(&pvt->transfer);
8863 /* now copy over the new address */
8864 memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
8865 memset(&pvt->transfer, 0, sizeof(pvt->transfer));
8866 /* Reset sequence numbers */
8867 pvt->oseqno = 0;
8868 pvt->rseqno = 0;
8869 pvt->iseqno = 0;
8870 pvt->aseqno = 0;
8871
8872 if (pvt->peercallno) {
8873 remove_by_peercallno(pvt);
8874 }
8875 pvt->peercallno = peercallno;
8876 /*this is where the transferring call switches hash tables */
8877 store_by_peercallno(pvt);
8878 pvt->transferring = TRANSFER_NONE;
8879 pvt->svoiceformat = -1;
8880 pvt->voiceformat = 0;
8881 pvt->svideoformat = -1;
8882 pvt->videoformat = 0;
8883 pvt->transfercallno = 0;
8884 memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
8885 memset(&pvt->offset, 0, sizeof(pvt->offset));
8886 /* reset jitterbuffer */
8887 while(jb_getall(pvt->jb,&frame) == JB_OK)
8888 iax2_frame_free(frame.data);
8889 jb_reset(pvt->jb);
8890 pvt->lag = 0;
8891 pvt->last = 0;
8892 pvt->lastsent = 0;
8893 pvt->nextpred = 0;
8894 pvt->pingtime = DEFAULT_RETRY_TIME;
8895 AST_LIST_TRAVERSE(&frame_queue[callno], cur, list) {
8896 /* We must cancel any packets that would have been transmitted
8897 because now we're talking to someone new. It's okay, they
8898 were transmitted to someone that didn't care anyway. */
8899 cur->retries = -1;
8900 }
8901 return 0;
8902}
8903
8904static void iax2_publish_registry(const char *username, const char *domain, const char *status, const char *cause)
8905{
8906 ast_system_publish_registry("IAX2", username, domain, status, cause);
8907}
8908
8909/*! \brief Acknowledgment received for OUR registration */
8910static int iax2_ack_registry(struct iax_ies *ies, struct ast_sockaddr *addr, int callno)
8911{
8912 struct iax2_registry *reg;
8913 /* Start pessimistic */
8914 char peer[256] = "";
8915 char msgstatus[60];
8916 int refresh = 60;
8917 char ourip[256] = "<Unspecified>";
8918 struct ast_sockaddr oldus;
8919 struct ast_sockaddr us;
8920 int oldmsgs;
8921
8922 if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
8923 ast_sockaddr_copy(&us, &ies->apparent_addr);
8924 }
8925 if (ies->username) {
8926 ast_copy_string(peer, ies->username, sizeof(peer));
8927 }
8928 if (ies->refresh) {
8929 refresh = ies->refresh;
8930 }
8931 if (ies->calling_number) {
8932 /* We don't do anything with it really, but maybe we should */
8933 }
8934 reg = iaxs[callno]->reg;
8935 if (!reg) {
8936 ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
8937 return -1;
8938 }
8939 ast_sockaddr_copy(&oldus, &reg->us);
8940 oldmsgs = reg->messages;
8941 if (ast_sockaddr_cmp(&reg->addr, addr)) {
8942 ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", ast_sockaddr_stringify(addr));
8943 return -1;
8944 }
8945 ast_sockaddr_copy(&reg->us, &us);
8946 if (ies->msgcount >= 0) {
8947 reg->messages = ies->msgcount & 0xffff; /* only low 16 bits are used in the transmission of the IE */
8948 }
8949 /* always refresh the registration at the interval requested by the server
8950 we are registering to
8951 */
8952 reg->refresh = refresh;
8953 reg->expire = iax2_sched_replace(reg->expire, sched,
8954 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
8955 if (ast_sockaddr_cmp(&oldus, &reg->us) || (reg->messages != oldmsgs)) {
8956
8957 if (reg->messages > 255) {
8958 snprintf(msgstatus, sizeof(msgstatus), " with %d new and %d old messages waiting", reg->messages & 0xff, reg->messages >> 8);
8959 } else if (reg->messages > 1) {
8960 snprintf(msgstatus, sizeof(msgstatus), " with %d new messages waiting", reg->messages);
8961 } else if (reg->messages > 0) {
8962 ast_copy_string(msgstatus, " with 1 new message waiting", sizeof(msgstatus));
8963 } else {
8964 ast_copy_string(msgstatus, " with no messages waiting", sizeof(msgstatus));
8965 }
8966
8967 snprintf(ourip, sizeof(ourip), "%s", ast_sockaddr_stringify(&reg->us));
8968
8969 ast_verb(3, "Registered IAX2 to '%s', who sees us as %s%s\n", ast_sockaddr_stringify(addr), ourip, msgstatus);
8970 iax2_publish_registry(reg->username, ast_sockaddr_stringify(addr), "Registered", NULL);
8971 }
8972 reg->regstate = REG_STATE_REGISTERED;
8973 return 0;
8974}
8975
8976static int iax2_append_register(const char *hostname, const char *username,
8977 const char *secret, const char *porta)
8978{
8979 struct iax2_registry *reg;
8980
8981 if (!(reg = ast_calloc(1, sizeof(*reg) + strlen(hostname) + 1))) {
8982 return -1;
8983 }
8984
8985 reg->addr.ss.ss_family = AST_AF_UNSPEC;
8986 if (ast_dnsmgr_lookup(hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL) < 0) {
8987 ast_free(reg);
8988 return -1;
8989 }
8990
8991 ast_copy_string(reg->username, username, sizeof(reg->username));
8992 strcpy(reg->hostname, hostname); /* Note: This is safe */
8993
8994 if (secret) {
8995 ast_copy_string(reg->secret, secret, sizeof(reg->secret));
8996 }
8997
8998 reg->expire = -1;
8999 reg->refresh = IAX_DEFAULT_REG_EXPIRE;
9000
9001 reg->port = ast_sockaddr_port(&reg->addr);
9002
9003 if (!porta && !reg->port) {
9004 reg->port = IAX_DEFAULT_PORTNO;
9005 } else if (porta) {
9006 sscanf(porta, "%5d", &reg->port);
9007 }
9008
9009 ast_sockaddr_set_port(&reg->addr, reg->port);
9010
9011 AST_LIST_LOCK(&registrations);
9012 AST_LIST_INSERT_HEAD(&registrations, reg, entry);
9013 AST_LIST_UNLOCK(&registrations);
9014
9015 return 0;
9016}
9017
9018static int iax2_register(const char *value, int lineno)
9019{
9020 char copy[256];
9021 char *username, *hostname, *secret;
9022 char *porta;
9023 char *stringp=NULL;
9024
9025 if (!value)
9026 return -1;
9027
9028 ast_copy_string(copy, value, sizeof(copy));
9029 stringp = copy;
9030 username = strsep(&stringp, "@");
9031 hostname = strsep(&stringp, "@");
9032
9033 if (!hostname) {
9034 ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d\n", lineno);
9035 return -1;
9036 }
9037
9038 stringp = username;
9039 username = strsep(&stringp, ":");
9040 secret = strsep(&stringp, ":");
9041 stringp = hostname;
9042 hostname = strsep(&stringp, ":");
9043 porta = strsep(&stringp, ":");
9044
9045 if (porta && !atoi(porta)) {
9046 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
9047 return -1;
9048 }
9049
9050 return iax2_append_register(hostname, username, secret, porta);
9051}
9052
9053
9054static void register_peer_exten(struct iax2_peer *peer, int onoff)
9055{
9056 char multi[256];
9057 char *stringp, *ext;
9058 if (!ast_strlen_zero(regcontext)) {
9059 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
9060 stringp = multi;
9061 while((ext = strsep(&stringp, "&"))) {
9062 if (onoff) {
9063 if (!ast_exists_extension(NULL, regcontext, ext, 1, NULL))
9064 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL,
9065 "Noop", ast_strdup(peer->name), ast_free_ptr, "IAX2");
9066 } else
9067 ast_context_remove_extension(regcontext, ext, 1, NULL);
9068 }
9069 }
9070}
9071static void prune_peers(void);
9072
9073static void unlink_peer(struct iax2_peer *peer)
9074{
9075 if (peer->expire > -1) {
9076 if (!AST_SCHED_DEL(sched, peer->expire)) {
9077 peer->expire = -1;
9078 peer_unref(peer);
9079 }
9080 }
9081
9082 if (peer->pokeexpire > -1) {
9083 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
9084 peer->pokeexpire = -1;
9085 peer_unref(peer);
9086 }
9087 }
9088
9089 ao2_unlink(peers, peer);
9090}
9091
9092static void __expire_registry(const void *data)
9093{
9094 struct iax2_peer *peer = (struct iax2_peer *) data;
9095 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
9096
9097 if (!peer)
9098 return;
9099 if (peer->expire == -1) {
9100 /* Removed already (possibly through CLI), ignore */
9101 return;
9102 }
9103
9104 peer->expire = -1;
9105
9106 ast_debug(1, "Expiring registration for peer '%s'\n", peer->name);
9107 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(peer, IAX_TEMPONLY|IAX_RTCACHEFRIENDS)))
9108 realtime_update_peer(peer->name, &peer->addr, 0);
9109 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
9110 blob = ast_json_pack("{s: s, s: s}",
9111 "peer_status", "Unregistered",
9112 "cause", "Expired");
9113 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
9114 /* modify entry in peercnts table as _not_ registered */
9115 peercnt_modify((unsigned char) 0, 0, &peer->addr);
9116 /* Reset the address */
9117 ast_sockaddr_setnull(&peer->addr);
9118 /* Reset expiry value */
9119 peer->expiry = min_reg_expire;
9120 if (!ast_test_flag64(peer, IAX_TEMPONLY))
9121 ast_db_del("IAX/Registry", peer->name);
9122 register_peer_exten(peer, 0);
9123 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
9124 if (iax2_regfunk)
9125 iax2_regfunk(peer->name, 0);
9126
9127 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR))
9128 unlink_peer(peer);
9129
9130 peer_unref(peer);
9131}
9132
9133static int expire_registry(const void *data)
9134{
9135#ifdef SCHED_MULTITHREADED
9136 if (schedule_action(__expire_registry, data))
9137#endif
9138 __expire_registry(data);
9139 return 0;
9140}
9141
9142static void reg_source_db(struct iax2_peer *p)
9143{
9144 char data[80];
9145 char *expiry;
9146
9147 if (ast_test_flag64(p, IAX_TEMPONLY) || ast_db_get("IAX/Registry", p->name, data, sizeof(data))) {
9148 return;
9149 }
9150
9151 expiry = strrchr(data, ':');
9152 if (!expiry) {
9153 ast_log(LOG_NOTICE, "IAX/Registry astdb entry missing expiry: '%s'\n", data);
9154 return;
9155 }
9156 *expiry++ = '\0';
9157
9158 if (!ast_sockaddr_parse(&p->addr, data, PARSE_PORT_REQUIRE)) {
9159 ast_log(LOG_NOTICE, "IAX/Registry astdb host:port invalid - '%s'\n", data);
9160 return;
9161 }
9162
9163 p->expiry = atoi(expiry);
9164
9165 ast_verb(3, "Seeding '%s' at %s for %d\n", p->name,
9166 ast_sockaddr_stringify(&p->addr), p->expiry);
9167
9168 iax2_poke_peer(p, 0);
9169 if (p->expire > -1) {
9170 if (!AST_SCHED_DEL(sched, p->expire)) {
9171 p->expire = -1;
9172 peer_unref(p);
9173 }
9174 }
9175
9176 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9177
9178 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
9179 if (p->expire == -1) {
9180 peer_unref(p);
9181 }
9182
9183 if (iax2_regfunk) {
9184 iax2_regfunk(p->name, 1);
9185 }
9186
9187 register_peer_exten(p, 1);
9188}
9189
9190/*!
9191 * \pre iaxsl[callno] is locked
9192 *
9193 * \note Since this function calls send_command_final(), the pvt struct for
9194 * the given call number may disappear while executing this function.
9195 */
9196static int update_registry(struct ast_sockaddr *addr, int callno, char *devtype, int fd, unsigned short refresh)
9197{
9198
9199 /* Called from IAX thread only, with proper iaxsl lock */
9200 struct iax_ie_data ied = {
9201 .pos = 0,
9202 };
9203 struct iax2_peer *p;
9204 int msgcount;
9205 char data[80];
9206 uint16_t version;
9207 const char *peer_name;
9208 int res = -1;
9209 char *str_addr;
9210
9211 peer_name = ast_strdupa(iaxs[callno]->peer);
9212
9213 /* SLD: Another find_peer call during registration - this time when we are really updating our registration */
9214 ast_mutex_unlock(&iaxsl[callno]);
9215 if (!(p = find_peer(peer_name, 1))) {
9216 ast_mutex_lock(&iaxsl[callno]);
9217 ast_log(LOG_WARNING, "No such peer '%s'\n", peer_name);
9218 return -1;
9219 }
9220 ast_mutex_lock(&iaxsl[callno]);
9221 if (!iaxs[callno])
9222 goto return_unref;
9223
9224 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(p, IAX_TEMPONLY|IAX_RTCACHEFRIENDS))) {
9225 if (!ast_sockaddr_isnull(addr)) {
9226 time_t nowtime;
9227 time(&nowtime);
9228 realtime_update_peer(peer_name, addr, nowtime);
9229 } else {
9230 realtime_update_peer(peer_name, addr, 0);
9231 }
9232 }
9233
9234 /* treat an unspecified refresh interval as the minimum */
9235 if (!refresh) {
9236 refresh = min_reg_expire;
9237 }
9238 if (refresh > max_reg_expire) {
9239 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
9240 p->name, max_reg_expire, refresh);
9241 p->expiry = max_reg_expire;
9242 } else if (refresh < min_reg_expire) {
9243 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
9244 p->name, min_reg_expire, refresh);
9245 p->expiry = min_reg_expire;
9246 } else {
9247 p->expiry = refresh;
9248 }
9249
9250 if (ast_sockaddr_cmp(&p->addr, addr)) {
9251 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
9252
9253 if (iax2_regfunk) {
9254 iax2_regfunk(p->name, 1);
9255 }
9256
9257 /* modify entry in peercnts table as _not_ registered */
9258 peercnt_modify((unsigned char) 0, 0, &p->addr);
9259
9260 /* Stash the IP address from which they registered */
9261 ast_sockaddr_copy(&p->addr, addr);
9262
9263 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
9264
9265 snprintf(data, sizeof(data), "%s:%d", ast_sockaddr_stringify(addr), p->expiry);
9266
9267 if (!ast_test_flag64(p, IAX_TEMPONLY) && !ast_sockaddr_isnull(addr)) {
9268 ast_db_put("IAX/Registry", p->name, data);
9269 ast_verb(3, "Registered IAX2 '%s' (%s) at %s\n",
9270 p->name,
9271 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED",
9272 ast_sockaddr_stringify(addr));
9273 ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_ONLINE);
9274 blob = ast_json_pack("{s: s, s: s, s: i}",
9275 "peer_status", "Registered",
9276 "address", str_addr,
9277 "port", ast_sockaddr_port(addr));
9278 register_peer_exten(p, 1);
9279 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9280 } else if (!ast_test_flag64(p, IAX_TEMPONLY)) {
9281 ast_verb(3, "Unregistered IAX2 '%s' (%s)\n",
9282 p->name,
9283 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED");
9284 ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_OFFLINE);
9285 blob = ast_json_pack("{s: s}",
9286 "peer_status", "Unregistered");
9287 register_peer_exten(p, 0);
9288 ast_db_del("IAX/Registry", p->name);
9289 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9290 }
9291
9292 ast_endpoint_blob_publish(p->endpoint, ast_endpoint_state_type(), blob);
9293
9294 /* Update the host */
9295 /* Verify that the host is really there */
9296 iax2_poke_peer(p, callno);
9297 }
9298
9299 /* modify entry in peercnts table as registered */
9300 if (p->maxcallno) {
9301 peercnt_modify((unsigned char) 1, p->maxcallno, &p->addr);
9302 }
9303
9304 /* Make sure our call still exists, an INVAL at the right point may make it go away */
9305 if (!iaxs[callno]) {
9306 res = -1;
9307 goto return_unref;
9308 }
9309
9310 /* Store socket fd */
9311 p->sockfd = fd;
9312 /* Setup the expiry */
9313 if (p->expire > -1) {
9314 if (!AST_SCHED_DEL(sched, p->expire)) {
9315 p->expire = -1;
9316 peer_unref(p);
9317 }
9318 }
9319
9320 if (p->expiry && !ast_sockaddr_isnull(addr)) {
9321 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
9322 if (p->expire == -1)
9323 peer_unref(p);
9324 }
9325 iax_ie_append_str(&ied, IAX_IE_USERNAME, p->name);
9326 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(p->zonetag));
9327 if (!ast_sockaddr_isnull(addr)) {
9328 struct ast_sockaddr peer_addr;
9329
9330 ast_sockaddr_copy(&peer_addr, &p->addr);
9331
9332 iax_ie_append_short(&ied, IAX_IE_REFRESH, p->expiry);
9333 iax_ie_append_addr(&ied, IAX_IE_APPARENT_ADDR, &peer_addr);
9334 if (!ast_strlen_zero(p->mailbox)) {
9335 int new, old;
9336 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
9337
9338 msg = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), p->mailbox);
9339 if (msg) {
9340 struct ast_mwi_state *mwi_state = stasis_message_data(msg);
9341 new = mwi_state->new_msgs;
9342 old = mwi_state->old_msgs;
9343 } else { /* Fall back on checking the mailbox directly */
9344 ast_app_inboxcount(p->mailbox, &new, &old);
9345 }
9346
9347 if (new > 255) {
9348 new = 255;
9349 }
9350 if (old > 255) {
9351 old = 255;
9352 }
9353 msgcount = (old << 8) | new;
9354
9355 iax_ie_append_short(&ied, IAX_IE_MSGCOUNT, msgcount);
9356 }
9357 if (ast_test_flag64(p, IAX_HASCALLERID)) {
9358 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, p->cid_num);
9359 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, p->cid_name);
9360 }
9361 }
9362 if (iax_firmware_get_version(devtype, &version)) {
9363 iax_ie_append_short(&ied, IAX_IE_FIRMWAREVER, version);
9364 }
9365
9366 res = 0;
9367
9368return_unref:
9369 peer_unref(p);
9370
9371 return res ? res : send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGACK, 0, ied.buf, ied.pos, -1);
9372}
9373
9374static int registry_authrequest(int callno)
9375{
9376 struct iax_ie_data ied;
9377 struct iax2_peer *p;
9378 char challenge[10];
9379 const char *peer_name;
9380 int sentauthmethod;
9381
9382 peer_name = ast_strdupa(iaxs[callno]->peer);
9383
9384 /* SLD: third call to find_peer in registration */
9385 ast_mutex_unlock(&iaxsl[callno]);
9386 if ((p = find_peer(peer_name, 1))) {
9387 last_authmethod = p->authmethods;
9388 }
9389
9390 ast_mutex_lock(&iaxsl[callno]);
9391 if (!iaxs[callno])
9392 goto return_unref;
9393
9394 memset(&ied, 0, sizeof(ied));
9395 /* The selection of which delayed reject is sent may leak information,
9396 * if it sets a static response. For example, if a host is known to only
9397 * use MD5 authentication, then an RSA response would indicate that the
9398 * peer does not exist, and vice-versa.
9399 * Therefore, we use whatever the last peer used (which may vary over the
9400 * course of a server, which should leak minimal information). */
9401 sentauthmethod = p ? p->authmethods : last_authmethod ? last_authmethod : IAX_AUTH_MD5;
9402 if (!p) {
9403 iaxs[callno]->authmethods = sentauthmethod;
9404 }
9405 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, sentauthmethod);
9406 if (sentauthmethod & (IAX_AUTH_RSA | IAX_AUTH_MD5)) {
9407 /* Build the challenge */
9408 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
9409 ast_string_field_set(iaxs[callno], challenge, challenge);
9410 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, iaxs[callno]->challenge);
9411 }
9412 iax_ie_append_str(&ied, IAX_IE_USERNAME, peer_name);
9413
9414return_unref:
9415 if (p) {
9416 peer_unref(p);
9417 }
9418
9419 return iaxs[callno] ? send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGAUTH, 0, ied.buf, ied.pos, -1) : -1;
9420}
9421
9422static int registry_rerequest(struct iax_ies *ies, int callno, struct ast_sockaddr *addr)
9423{
9424 struct iax2_registry *reg;
9425 /* Start pessimistic */
9426 struct iax_ie_data ied;
9427 char peer[256] = "";
9428 char challenge[256] = "";
9429 int res;
9430 int authmethods = 0;
9431 if (ies->authmethods)
9432 authmethods = ies->authmethods;
9433 if (ies->username)
9434 ast_copy_string(peer, ies->username, sizeof(peer));
9435 if (ies->challenge)
9436 ast_copy_string(challenge, ies->challenge, sizeof(challenge));
9437 memset(&ied, 0, sizeof(ied));
9438 reg = iaxs[callno]->reg;
9439 if (reg) {
9440
9441 if (ast_sockaddr_cmp(&reg->addr, addr)) {
9442 ast_log(LOG_WARNING, "Received unsolicited registry authenticate request from '%s'\n", ast_sockaddr_stringify(addr));
9443 return -1;
9444 }
9445 if (ast_strlen_zero(reg->secret)) {
9446 ast_log(LOG_NOTICE, "No secret associated with peer '%s'\n", reg->username);
9447 reg->regstate = REG_STATE_NOAUTH;
9448 return -1;
9449 }
9450 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
9451 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
9452 if (reg->secret[0] == '[') {
9453 char tmpkey[256];
9454 ast_copy_string(tmpkey, reg->secret + 1, sizeof(tmpkey));
9455 tmpkey[strlen(tmpkey) - 1] = '\0';
9456 res = authenticate(challenge, NULL, tmpkey, authmethods, &ied, addr, NULL);
9457 } else
9458 res = authenticate(challenge, reg->secret, NULL, authmethods, &ied, addr, NULL);
9459 if (!res) {
9460 reg->regstate = REG_STATE_AUTHSENT;
9461 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
9462 return send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
9463 } else
9464 return -1;
9465 ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
9466 } else
9467 ast_log(LOG_NOTICE, "Can't reregister without a reg\n");
9468 return -1;
9469}
9470
9471static void stop_stuff(int callno)
9472{
9473 iax2_destroy_helper(iaxs[callno]);
9474}
9475
9476static void __auth_reject(const void *nothing)
9477{
9478 /* Called from IAX thread only, without iaxs lock */
9479 int callno = (int)(long)(nothing);
9480 struct iax_ie_data ied;
9481 ast_mutex_lock(&iaxsl[callno]);
9482 if (iaxs[callno]) {
9483 memset(&ied, 0, sizeof(ied));
9484 if (iaxs[callno]->authfail == IAX_COMMAND_REGREJ) {
9485 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Registration Refused");
9486 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_REJECTED);
9487 } else if (iaxs[callno]->authfail == IAX_COMMAND_REJECT) {
9488 iax_ie_append_str(&ied, IAX_IE_CAUSE, "No authority found");
9489 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
9490 }
9491 send_command_final(iaxs[callno], AST_FRAME_IAX, iaxs[callno]->authfail, 0, ied.buf, ied.pos, -1);
9492 }
9493 ast_mutex_unlock(&iaxsl[callno]);
9494}
9495
9496static int auth_reject(const void *data)
9497{
9498 int callno = (int)(long)(data);
9499 ast_mutex_lock(&iaxsl[callno]);
9500 if (iaxs[callno])
9501 iaxs[callno]->authid = -1;
9502 ast_mutex_unlock(&iaxsl[callno]);
9503#ifdef SCHED_MULTITHREADED
9504 if (schedule_action(__auth_reject, data))
9505#endif
9506 __auth_reject(data);
9507 return 0;
9508}
9509
9510static int auth_fail(int callno, int failcode)
9511{
9512 /* Schedule sending the authentication failure in one second, to prevent
9513 guessing */
9514 if (iaxs[callno]) {
9515 iaxs[callno]->authfail = failcode;
9516 if (delayreject) {
9517 iaxs[callno]->authid = iax2_sched_replace(iaxs[callno]->authid,
9518 sched, 1000, auth_reject, (void *)(long)callno);
9519 } else
9520 auth_reject((void *)(long)callno);
9521 }
9522 return 0;
9523}
9524
9525static void __auto_hangup(const void *nothing)
9526{
9527 /* Called from IAX thread only, without iaxs lock */
9528 int callno = (int)(long)(nothing);
9529 struct iax_ie_data ied;
9530 ast_mutex_lock(&iaxsl[callno]);
9531 if (iaxs[callno]) {
9532 memset(&ied, 0, sizeof(ied));
9533 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Timeout");
9534 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_NO_USER_RESPONSE);
9535 send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
9536 }
9537 ast_mutex_unlock(&iaxsl[callno]);
9538}
9539
9540static int auto_hangup(const void *data)
9541{
9542 int callno = (int)(long)(data);
9543 ast_mutex_lock(&iaxsl[callno]);
9544 if (iaxs[callno]) {
9545 iaxs[callno]->autoid = -1;
9546 }
9547 ast_mutex_unlock(&iaxsl[callno]);
9548#ifdef SCHED_MULTITHREADED
9549 if (schedule_action(__auto_hangup, data))
9550#endif
9551 __auto_hangup(data);
9552 return 0;
9553}
9554
9555static void iax2_dprequest(struct iax2_dpcache *dp, int callno)
9556{
9557 struct iax_ie_data ied;
9558 /* Auto-hangup with 30 seconds of inactivity */
9559 iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
9560 sched, 30000, auto_hangup, (void *)(long)callno);
9561 memset(&ied, 0, sizeof(ied));
9562 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, dp->exten);
9563 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREQ, 0, ied.buf, ied.pos, -1);
9564 dp->flags |= CACHE_FLAG_TRANSMITTED;
9565}
9566
9567static int iax2_vnak(int callno)
9568{
9569 return send_command_immediate(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_VNAK, 0, NULL, 0, iaxs[callno]->iseqno);
9570}
9571
9572static void vnak_retransmit(int callno, int last)
9573{
9574 struct iax_frame *f;
9575
9576 AST_LIST_TRAVERSE(&frame_queue[callno], f, list) {
9577 /* Send a copy immediately */
9578 if (((unsigned char) (f->oseqno - last) < 128) &&
9579 (f->retries >= 0)) {
9580 send_packet(f);
9581 }
9582 }
9583}
9584
9585static void __iax2_poke_peer_s(const void *data)
9586{
9587 struct iax2_peer *peer = (struct iax2_peer *)data;
9588 iax2_poke_peer(peer, 0);
9589 peer_unref(peer);
9590}
9591
9592static int iax2_poke_peer_s(const void *data)
9593{
9594 struct iax2_peer *peer = (struct iax2_peer *)data;
9595 peer->pokeexpire = -1;
9596#ifdef SCHED_MULTITHREADED
9597 if (schedule_action(__iax2_poke_peer_s, data))
9598#endif
9599 __iax2_poke_peer_s(data);
9600 return 0;
9601}
9602
9603static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now)
9604{
9605 int res = 0;
9606 struct iax_frame *fr;
9607 struct ast_iax2_meta_hdr *meta;
9608 struct ast_iax2_meta_trunk_hdr *mth;
9609 int calls = 0;
9610
9611 /* Point to frame */
9612 fr = (struct iax_frame *)tpeer->trunkdata;
9613 /* Point to meta data */
9614 meta = (struct ast_iax2_meta_hdr *)fr->afdata;
9615 mth = (struct ast_iax2_meta_trunk_hdr *)meta->data;
9616 if (tpeer->trunkdatalen) {
9617 /* We're actually sending a frame, so fill the meta trunk header and meta header */
9618 meta->zeros = 0;
9619 meta->metacmd = IAX_META_TRUNK;
9620 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS))
9621 meta->cmddata = IAX_META_TRUNK_MINI;
9622 else
9623 meta->cmddata = IAX_META_TRUNK_SUPERMINI;
9624 mth->ts = htonl(calc_txpeerstamp(tpeer, trunkfreq, now));
9625 /* And the rest of the ast_iax2 header */
9626 fr->direction = DIRECTION_OUTGRESS;
9627 fr->retrans = -1;
9628 fr->transfer = 0;
9629 /* Any appropriate call will do */
9630 fr->data = fr->afdata;
9631 fr->datalen = tpeer->trunkdatalen + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr);
9632 res = transmit_trunk(fr, &tpeer->addr, tpeer->sockfd);
9633 calls = tpeer->calls;
9634#if 0
9635 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));
9636#endif
9637 /* Reset transmit trunk side data */
9638 tpeer->trunkdatalen = 0;
9639 tpeer->calls = 0;
9640 }
9641 if (res < 0)
9642 return res;
9643 return calls;
9644}
9645
9646static inline int iax2_trunk_expired(struct iax2_trunk_peer *tpeer, struct timeval *now)
9647{
9648 /* Drop when trunk is about 5 seconds idle */
9649 if (now->tv_sec > tpeer->trunkact.tv_sec + 5)
9650 return 1;
9651 return 0;
9652}
9653
9654static int timing_read(int *id, int fd, short events, void *cbdata)
9655{
9656 int res, processed = 0, totalcalls = 0;
9657 struct iax2_trunk_peer *tpeer = NULL, *drop = NULL;
9658 struct timeval now = ast_tvnow();
9659
9660 if (iaxtrunkdebug) {
9661 ast_verbose("Beginning trunk processing. Trunk queue ceiling is %d bytes per host\n", trunkmaxsize);
9662 }
9663
9664 if (timer) {
9665 if (ast_timer_ack(timer, 1) < 0) {
9666 ast_log(LOG_ERROR, "Timer failed acknowledge\n");
9667 return 0;
9668 }
9669 }
9670
9671 /* For each peer that supports trunking... */
9672 AST_LIST_LOCK(&tpeers);
9673 AST_LIST_TRAVERSE_SAFE_BEGIN(&tpeers, tpeer, list) {
9674 processed++;
9675 res = 0;
9676 ast_mutex_lock(&tpeer->lock);
9677 /* We can drop a single tpeer per pass. That makes all this logic
9678 substantially easier */
9679 if (!drop && iax2_trunk_expired(tpeer, &now)) {
9680 /* Take it out of the list, but don't free it yet, because it
9681 could be in use */
9682 AST_LIST_REMOVE_CURRENT(list);
9683 drop = tpeer;
9684 } else {
9685 res = send_trunk(tpeer, &now);
9686 trunk_timed++;
9687 if (iaxtrunkdebug) {
9688 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",
9689 ast_sockaddr_stringify(&tpeer->addr),
9690 res,
9691 (res != 1) ? "s" : "",
9692 tpeer->trunkdatalen,
9693 tpeer->trunkdataalloc);
9694 }
9695 }
9696 totalcalls += res;
9697 res = 0;
9698 ast_mutex_unlock(&tpeer->lock);
9699 }
9700 AST_LIST_TRAVERSE_SAFE_END;
9701 AST_LIST_UNLOCK(&tpeers);
9702
9703 if (drop) {
9704 ast_mutex_lock(&drop->lock);
9705 /* Once we have this lock, we're sure nobody else is using it or could use it once we release it,
9706 because by the time they could get tpeerlock, we've already grabbed it */
9707 ast_debug(1, "Dropping unused iax2 trunk peer '%s'\n", ast_sockaddr_stringify(&drop->addr));
9708 if (drop->trunkdata) {
9709 ast_free(drop->trunkdata);
9710 drop->trunkdata = NULL;
9711 }
9712 ast_mutex_unlock(&drop->lock);
9713 ast_mutex_destroy(&drop->lock);
9714 ast_free(drop);
9715 }
9716
9717 if (iaxtrunkdebug) {
9718 ast_verbose("Ending trunk processing with %d peers and %d call chunks processed\n", processed, totalcalls);
9719 }
9720 iaxtrunkdebug = 0;
9721
9722 return 1;
9723}
9724
9725struct dpreq_data {
9726 int callno;
9727 char context[AST_MAX_EXTENSION];
9728 char callednum[AST_MAX_EXTENSION];
9729 char *callerid;
9730};
9731
9732static void dp_lookup(int callno, const char *context, const char *callednum, const char *callerid, int skiplock)
9733{
9734 unsigned short dpstatus = 0;
9735 struct iax_ie_data ied1;
9736 int mm;
9737
9738 memset(&ied1, 0, sizeof(ied1));
9739 mm = ast_matchmore_extension(NULL, context, callednum, 1, callerid);
9740 /* Must be started */
9741 if (ast_exists_extension(NULL, context, callednum, 1, callerid)) {
9742 dpstatus = IAX_DPSTATUS_EXISTS;
9743 } else if (ast_canmatch_extension(NULL, context, callednum, 1, callerid)) {
9744 dpstatus = IAX_DPSTATUS_CANEXIST;
9745 } else {
9746 dpstatus = IAX_DPSTATUS_NONEXISTENT;
9747 }
9748 if (ast_ignore_pattern(context, callednum))
9749 dpstatus |= IAX_DPSTATUS_IGNOREPAT;
9750 if (mm)
9751 dpstatus |= IAX_DPSTATUS_MATCHMORE;
9752 if (!skiplock)
9753 ast_mutex_lock(&iaxsl[callno]);
9754 if (iaxs[callno]) {
9755 iax_ie_append_str(&ied1, IAX_IE_CALLED_NUMBER, callednum);
9756 iax_ie_append_short(&ied1, IAX_IE_DPSTATUS, dpstatus);
9757 iax_ie_append_short(&ied1, IAX_IE_REFRESH, iaxdefaultdpcache);
9758 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREP, 0, ied1.buf, ied1.pos, -1);
9759 }
9760 if (!skiplock)
9761 ast_mutex_unlock(&iaxsl[callno]);
9762}
9763
9764static void *dp_lookup_thread(void *data)
9765{
9766 /* Look up for dpreq */
9767 struct dpreq_data *dpr = data;
9768 dp_lookup(dpr->callno, dpr->context, dpr->callednum, dpr->callerid, 0);
9769 if (dpr->callerid)
9770 ast_free(dpr->callerid);
9771 ast_free(dpr);
9772 return NULL;
9773}
9774
9775static void spawn_dp_lookup(int callno, const char *context, const char *callednum, const char *callerid)
9776{
9777 pthread_t newthread;
9778 struct dpreq_data *dpr;
9779
9780 if (!(dpr = ast_calloc(1, sizeof(*dpr))))
9781 return;
9782
9783 dpr->callno = callno;
9784 ast_copy_string(dpr->context, context, sizeof(dpr->context));
9785 ast_copy_string(dpr->callednum, callednum, sizeof(dpr->callednum));
9786 if (callerid)
9787 dpr->callerid = ast_strdup(callerid);
9788 if (ast_pthread_create_detached(&newthread, NULL, dp_lookup_thread, dpr)) {
9789 ast_log(LOG_WARNING, "Unable to start lookup thread!\n");
9790 }
9791}
9792
9793static int check_provisioning(struct ast_sockaddr *addr, int sockfd, char *si, unsigned int ver)
9794{
9795 unsigned int ourver;
9796 char rsi[80];
9797 snprintf(rsi, sizeof(rsi), "si-%s", si);
9798 if (iax_provision_version(&ourver, rsi, 1))
9799 return 0;
9800 ast_debug(1, "Service identifier '%s', we think '%08x', they think '%08x'\n", si, ourver, ver);
9801 if (ourver != ver)
9802 iax2_provision(addr, sockfd, NULL, rsi, 1);
9803 return 0;
9804}
9805
9806static void construct_rr(struct chan_iax2_pvt *pvt, struct iax_ie_data *iep)
9807{
9808 jb_info stats;
9809 jb_getinfo(pvt->jb, &stats);
9810
9811 memset(iep, 0, sizeof(*iep));
9812
9813 iax_ie_append_int(iep,IAX_IE_RR_JITTER, stats.jitter);
9814 if(stats.frames_in == 0) stats.frames_in = 1;
9815 iax_ie_append_int(iep,IAX_IE_RR_LOSS, ((0xff & (stats.losspct/1000)) << 24 | (stats.frames_lost & 0x00ffffff)));
9816 iax_ie_append_int(iep,IAX_IE_RR_PKTS, stats.frames_in);
9817 iax_ie_append_short(iep,IAX_IE_RR_DELAY, stats.current - stats.min);
9818 iax_ie_append_int(iep,IAX_IE_RR_DROPPED, stats.frames_dropped);
9819 iax_ie_append_int(iep,IAX_IE_RR_OOO, stats.frames_ooo);
9820}
9821
9822static void save_rr(struct iax_frame *fr, struct iax_ies *ies)
9823{
9824 iaxs[fr->callno]->remote_rr.jitter = ies->rr_jitter;
9825 iaxs[fr->callno]->remote_rr.losspct = ies->rr_loss >> 24;
9826 iaxs[fr->callno]->remote_rr.losscnt = ies->rr_loss & 0xffffff;
9827 iaxs[fr->callno]->remote_rr.packets = ies->rr_pkts;
9828 iaxs[fr->callno]->remote_rr.delay = ies->rr_delay;
9829 iaxs[fr->callno]->remote_rr.dropped = ies->rr_dropped;
9830 iaxs[fr->callno]->remote_rr.ooo = ies->rr_ooo;
9831}
9832
9833static void save_osptoken(struct iax_frame *fr, struct iax_ies *ies)
9834{
9835 int i;
9836 unsigned int length, offset = 0;
9837 char full_osptoken[IAX_MAX_OSPBUFF_SIZE];
9838
9839 for (i = 0; i < IAX_MAX_OSPBLOCK_NUM; i++) {
9840 length = ies->ospblocklength[i];
9841 if (length != 0) {
9842 if (length > IAX_MAX_OSPBLOCK_SIZE) {
9843 /* OSP token block length wrong, clear buffer */
9844 offset = 0;
9845 break;
9846 } else {
9847 memcpy(full_osptoken + offset, ies->osptokenblock[i], length);
9848 offset += length;
9849 }
9850 } else {
9851 break;
9852 }
9853 }
9854 *(full_osptoken + offset) = '\0';
9855 if (strlen(full_osptoken) != offset) {
9856 /* OSP token length wrong, clear buffer */
9857 *full_osptoken = '\0';
9858 }
9859
9860 ast_string_field_set(iaxs[fr->callno], osptoken, full_osptoken);
9861}
9862
9863static void log_jitterstats(unsigned short callno)
9864{
9865 int localjitter = -1, localdelay = 0, locallost = -1, locallosspct = -1, localdropped = 0, localooo = -1, localpackets = -1;
9866 jb_info jbinfo;
9867
9868 ast_mutex_lock(&iaxsl[callno]);
9869 if (iaxs[callno] && iaxs[callno]->owner && ast_channel_name(iaxs[callno]->owner)) {
9870 if(ast_test_flag64(iaxs[callno], IAX_USEJITTERBUF)) {
9871 jb_getinfo(iaxs[callno]->jb, &jbinfo);
9872 localjitter = jbinfo.jitter;
9873 localdelay = jbinfo.current - jbinfo.min;
9874 locallost = jbinfo.frames_lost;
9875 locallosspct = jbinfo.losspct/1000;
9876 localdropped = jbinfo.frames_dropped;
9877 localooo = jbinfo.frames_ooo;
9878 localpackets = jbinfo.frames_in;
9879 }
9880 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",
9881 ast_channel_name(iaxs[callno]->owner),
9882 iaxs[callno]->pingtime,
9883 localjitter,
9884 localdelay,
9885 locallost,
9886 locallosspct,
9887 localdropped,
9888 localooo,
9889 localpackets,
9890 iaxs[callno]->remote_rr.jitter,
9891 iaxs[callno]->remote_rr.delay,
9892 iaxs[callno]->remote_rr.losscnt,
9893 iaxs[callno]->remote_rr.losspct/1000,
9894 iaxs[callno]->remote_rr.dropped,
9895 iaxs[callno]->remote_rr.ooo,
9896 iaxs[callno]->remote_rr.packets);
9897 }
9898 ast_mutex_unlock(&iaxsl[callno]);
9899}
9900
9901static int socket_process(struct iax2_thread *thread);
9902
9903/*!
9904 * \brief Handle any deferred full frames for this thread
9905 */
9906static void handle_deferred_full_frames(struct iax2_thread *thread)
9907{
9908 struct iax2_pkt_buf *pkt_buf;
9909
9910 ast_mutex_lock(&thread->lock);
9911
9912 while ((pkt_buf = AST_LIST_REMOVE_HEAD(&thread->full_frames, entry))) {
9913 ast_mutex_unlock(&thread->lock);
9914
9915 thread->buf = pkt_buf->buf;
9916 thread->buf_len = pkt_buf->len;
9917 thread->buf_size = pkt_buf->len + 1;
9918
9919 socket_process(thread);
9920
9921 thread->buf = NULL;
9922 ast_free(pkt_buf);
9923
9924 ast_mutex_lock(&thread->lock);
9925 }
9926
9927 ast_mutex_unlock(&thread->lock);
9928}
9929
9930/*!
9931 * \brief Queue the last read full frame for processing by a certain thread
9932 *
9933 * If there are already any full frames queued, they are sorted
9934 * by sequence number.
9935 */
9936static void defer_full_frame(struct iax2_thread *from_here, struct iax2_thread *to_here)
9937{
9938 struct iax2_pkt_buf *pkt_buf, *cur_pkt_buf;
9939 struct ast_iax2_full_hdr *fh, *cur_fh;
9940
9941 if (!(pkt_buf = ast_calloc(1, sizeof(*pkt_buf) + from_here->buf_len)))
9942 return;
9943
9944 pkt_buf->len = from_here->buf_len;
9945 memcpy(pkt_buf->buf, from_here->buf, pkt_buf->len);
9946
9947 fh = (struct ast_iax2_full_hdr *) pkt_buf->buf;
9948 ast_mutex_lock(&to_here->lock);
9949 AST_LIST_TRAVERSE_SAFE_BEGIN(&to_here->full_frames, cur_pkt_buf, entry) {
9950 cur_fh = (struct ast_iax2_full_hdr *) cur_pkt_buf->buf;
9951 if (fh->oseqno < cur_fh->oseqno) {
9952 AST_LIST_INSERT_BEFORE_CURRENT(pkt_buf, entry);
9953 break;
9954 }
9955 }
9956 AST_LIST_TRAVERSE_SAFE_END
9957
9958 if (!cur_pkt_buf)
9959 AST_LIST_INSERT_TAIL(&to_here->full_frames, pkt_buf, entry);
9960
9961 to_here->iostate = IAX_IOSTATE_READY;
9962 ast_cond_signal(&to_here->cond);
9963
9964 ast_mutex_unlock(&to_here->lock);
9965}
9966
9967static int socket_read(int *id, int fd, short events, void *cbdata)
9968{
9969 struct iax2_thread *thread;
9970 time_t t;
9971 static time_t last_errtime = 0;
9972 struct ast_iax2_full_hdr *fh;
9973
9974 if (!(thread = find_idle_thread())) {
9975 time(&t);
9976 if (t != last_errtime) {
9977 last_errtime = t;
9978 ast_debug(1, "Out of idle IAX2 threads for I/O, pausing!\n");
9979 }
9980 usleep(1);
9981 return 1;
9982 }
9983
9984 thread->iofd = fd;
9985 thread->buf_len = ast_recvfrom(fd, thread->readbuf, sizeof(thread->readbuf), 0, &thread->ioaddr);
9986 thread->buf_size = sizeof(thread->readbuf);
9987 thread->buf = thread->readbuf;
9988 if (thread->buf_len < 0) {
9989 if (errno != ECONNREFUSED && errno != EAGAIN)
9990 ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
9991 handle_error();
9992 thread->iostate = IAX_IOSTATE_IDLE;
9993 signal_condition(&thread->lock, &thread->cond);
9994 return 1;
9995 }
9996 if (test_losspct && ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_losspct)) { /* simulate random loss condition */
9997 thread->iostate = IAX_IOSTATE_IDLE;
9998 signal_condition(&thread->lock, &thread->cond);
9999 return 1;
10000 }
10001
10002 /* Determine if this frame is a full frame; if so, and any thread is currently
10003 processing a full frame for the same callno from this peer, then drop this
10004 frame (and the peer will retransmit it) */
10005 fh = (struct ast_iax2_full_hdr *) thread->buf;
10006 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
10007 struct iax2_thread *cur = NULL;
10008 uint16_t callno = ntohs(fh->scallno) & ~IAX_FLAG_FULL;
10009
10010 AST_LIST_LOCK(&active_list);
10011 AST_LIST_TRAVERSE(&active_list, cur, list) {
10012 if ((cur->ffinfo.callno == callno) &&
10013 !ast_sockaddr_cmp_addr(&cur->ffinfo.addr, &thread->ioaddr))
10014 break;
10015 }
10016 if (cur) {
10017 /* we found another thread processing a full frame for this call,
10018 so queue it up for processing later. */
10019 defer_full_frame(thread, cur);
10020 AST_LIST_UNLOCK(&active_list);
10021 thread->iostate = IAX_IOSTATE_IDLE;
10022 signal_condition(&thread->lock, &thread->cond);
10023 return 1;
10024 } else {
10025 /* this thread is going to process this frame, so mark it */
10026 thread->ffinfo.callno = callno;
10027 ast_sockaddr_copy(&thread->ffinfo.addr, &thread->ioaddr);
10028 thread->ffinfo.type = fh->type;
10029 thread->ffinfo.csub = fh->csub;
10030 AST_LIST_INSERT_HEAD(&active_list, thread, list);
10031 }
10032 AST_LIST_UNLOCK(&active_list);
10033 }
10034
10035 /* Mark as ready and send on its way */
10036 thread->iostate = IAX_IOSTATE_READY;
10037#ifdef DEBUG_SCHED_MULTITHREAD
10038 ast_copy_string(thread->curfunc, "socket_process", sizeof(thread->curfunc));
10039#endif
10040 signal_condition(&thread->lock, &thread->cond);
10041
10042 return 1;
10043}
10044
10045static int socket_process_meta(int packet_len, struct ast_iax2_meta_hdr *meta, struct ast_sockaddr *addr, int sockfd,
10046 struct iax_frame *fr)
10047{
10048 unsigned char metatype;
10049 struct ast_iax2_meta_trunk_mini *mtm;
10050 struct ast_iax2_meta_trunk_hdr *mth;
10051 struct ast_iax2_meta_trunk_entry *mte;
10052 struct iax2_trunk_peer *tpeer;
10053 unsigned int ts;
10054 void *ptr;
10055 struct timeval rxtrunktime;
10056 struct ast_frame f = { 0, };
10057
10058 if (packet_len < sizeof(*meta)) {
10059 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a meta frame but is too short\n",
10060 ast_sockaddr_stringify(addr));
10061 return 1;
10062 }
10063
10064 if (meta->metacmd != IAX_META_TRUNK)
10065 return 1;
10066
10067 if (packet_len < (sizeof(*meta) + sizeof(*mth))) {
10068 ast_log(LOG_WARNING, "midget meta trunk packet received (%d of %d min)\n", packet_len,
10069 (int) (sizeof(*meta) + sizeof(*mth)));
10070 return 1;
10071 }
10072 mth = (struct ast_iax2_meta_trunk_hdr *)(meta->data);
10073 ts = ntohl(mth->ts);
10074 metatype = meta->cmddata;
10075 packet_len -= (sizeof(*meta) + sizeof(*mth));
10076 ptr = mth->data;
10077 tpeer = find_tpeer(addr, sockfd);
10078 if (!tpeer) {
10079 ast_log(LOG_WARNING, "Unable to accept trunked packet from '%s': No matching peer\n",
10080 ast_sockaddr_stringify(addr));
10081 return 1;
10082 }
10083 tpeer->trunkact = ast_tvnow();
10084 if (!ts || ast_tvzero(tpeer->rxtrunktime))
10085 tpeer->rxtrunktime = tpeer->trunkact;
10086 rxtrunktime = tpeer->rxtrunktime;
10087 ast_mutex_unlock(&tpeer->lock);
10088 while (packet_len >= sizeof(*mte)) {
10089 /* Process channels */
10090 unsigned short callno, trunked_ts, len;
10091
10092 if (metatype == IAX_META_TRUNK_MINI) {
10093 mtm = (struct ast_iax2_meta_trunk_mini *) ptr;
10094 ptr += sizeof(*mtm);
10095 packet_len -= sizeof(*mtm);
10096 len = ntohs(mtm->len);
10097 callno = ntohs(mtm->mini.callno);
10098 trunked_ts = ntohs(mtm->mini.ts);
10099 } else if (metatype == IAX_META_TRUNK_SUPERMINI) {
10100 mte = (struct ast_iax2_meta_trunk_entry *)ptr;
10101 ptr += sizeof(*mte);
10102 packet_len -= sizeof(*mte);
10103 len = ntohs(mte->len);
10104 callno = ntohs(mte->callno);
10105 trunked_ts = 0;
10106 } else {
10107 ast_log(LOG_WARNING, "Unknown meta trunk cmd from '%s': dropping\n", ast_sockaddr_stringify(addr));
10108 break;
10109 }
10110 /* Stop if we don't have enough data */
10111 if (len > packet_len)
10112 break;
10113 fr->callno = find_callno_locked(callno & ~IAX_FLAG_FULL, 0, addr, NEW_PREVENT, sockfd, 0);
10114 if (!fr->callno)
10115 continue;
10116
10117 /* If it's a valid call, deliver the contents. If not, we
10118 drop it, since we don't have a scallno to use for an INVAL */
10119 /* Process as a mini frame */
10120 memset(&f, 0, sizeof(f));
10121 f.frametype = AST_FRAME_VOICE;
10122 if (!iaxs[fr->callno]) {
10123 /* drop it */
10124 } else if (iaxs[fr->callno]->voiceformat == 0) {
10125 ast_log(LOG_WARNING, "Received trunked frame before first full voice frame\n");
10126 iax2_vnak(fr->callno);
10127 } else if ((f.subclass.format = ast_format_compatibility_bitfield2format(
10128 iaxs[fr->callno]->voiceformat))) {
10129 f.datalen = len;
10130 if (f.datalen >= 0) {
10131 if (f.datalen)
10132 f.data.ptr = ptr;
10133 else
10134 f.data.ptr = NULL;
10135 if (trunked_ts)
10136 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
10137 else
10138 fr->ts = fix_peerts(&rxtrunktime, fr->callno, ts);
10139 /* Don't pass any packets until we're started */
10140 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10141 struct iax_frame *duped_fr;
10142
10143 /* Common things */
10144 f.src = "IAX2";
10145 f.mallocd = 0;
10146 f.offset = 0;
10147 if (f.datalen && (f.frametype == AST_FRAME_VOICE))
10148 f.samples = ast_codec_samples_count(&f);
10149 else
10150 f.samples = 0;
10151 fr->outoforder = 0;
10152 iax_frame_wrap(fr, &f);
10153 duped_fr = iaxfrdup2(fr);
10154 if (duped_fr)
10155 schedule_delivery(duped_fr, 1, 1, &fr->ts);
10156 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts)
10157 iaxs[fr->callno]->last = fr->ts;
10158 }
10159 } else {
10160 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
10161 }
10162 }
10163 ast_mutex_unlock(&iaxsl[fr->callno]);
10164 ptr += len;
10165 packet_len -= len;
10166 }
10167
10168 return 1;
10169}
10170
10171static int acf_iaxvar_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
10172{
10173 struct ast_datastore *variablestore;
10174 AST_LIST_HEAD(, ast_var_t) *varlist;
10175 struct ast_var_t *var;
10176
10177 if (!chan) {
10178 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
10179 return -1;
10180 }
10181
10182 variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
10183 if (!variablestore) {
10184 *buf = '\0';
10185 return 0;
10186 }
10187 varlist = variablestore->data;
10188
10189 AST_LIST_LOCK(varlist);
10190 AST_LIST_TRAVERSE(varlist, var, entries) {
10191 if (strcmp(var->name, data) == 0) {
10192 ast_copy_string(buf, var->value, len);
10193 break;
10194 }
10195 }
10196 AST_LIST_UNLOCK(varlist);
10197 return 0;
10198}
10199
10200static int acf_iaxvar_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
10201{
10202 struct ast_datastore *variablestore;
10203 AST_LIST_HEAD(, ast_var_t) *varlist;
10204 struct ast_var_t *var;
10205
10206 if (!chan) {
10207 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
10208 return -1;
10209 }
10210
10211 variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
10212 if (!variablestore) {
10213 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
10214 if (!variablestore) {
10215 ast_log(LOG_ERROR, "Memory allocation error\n");
10216 return -1;
10217 }
10218 varlist = ast_calloc(1, sizeof(*varlist));
10219 if (!varlist) {
10220 ast_datastore_free(variablestore);
10221 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
10222 return -1;
10223 }
10224
10225 AST_LIST_HEAD_INIT(varlist);
10226 variablestore->data = varlist;
10227 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
10228 ast_channel_datastore_add(chan, variablestore);
10229 } else
10230 varlist = variablestore->data;
10231
10232 AST_LIST_LOCK(varlist);
10233 AST_LIST_TRAVERSE_SAFE_BEGIN(varlist, var, entries) {
10234 if (strcmp(var->name, data) == 0) {
10235 AST_LIST_REMOVE_CURRENT(entries);
10236 ast_var_delete(var);
10237 break;
10238 }
10239 }
10240 AST_LIST_TRAVERSE_SAFE_END;
10241 var = ast_var_assign(data, value);
10242 if (var)
10243 AST_LIST_INSERT_TAIL(varlist, var, entries);
10244 else
10245 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
10246 AST_LIST_UNLOCK(varlist);
10247 return 0;
10248}
10249
10250static struct ast_custom_function iaxvar_function = {
10251 .name = "IAXVAR",
10252 .read = acf_iaxvar_read,
10253 .write = acf_iaxvar_write,
10254};
10255
10256static void set_hangup_source_and_cause(int callno, unsigned char causecode)
10257{
10258 iax2_lock_owner(callno);
10259 if (iaxs[callno] && iaxs[callno]->owner) {
10260 struct ast_channel *owner;
10261 const char *name;
10262
10263 owner = iaxs[callno]->owner;
10264 if (causecode) {
10265 ast_channel_hangupcause_set(owner, causecode);
10266 }
10267 name = ast_strdupa(ast_channel_name(owner));
10268 ast_channel_ref(owner);
10269 ast_channel_unlock(owner);
10270 ast_mutex_unlock(&iaxsl[callno]);
10271 ast_set_hangupsource(owner, name, 0);
10272 ast_channel_unref(owner);
10273 ast_mutex_lock(&iaxsl[callno]);
10274 }
10275}
10276
10277static int socket_process_helper(struct iax2_thread *thread)
10278{
10279 struct ast_sockaddr addr;
10280 int res;
10281 int updatehistory=1;
10282 int new = NEW_PREVENT;
10283 int dcallno = 0;
10284 char decrypted = 0;
10285 struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)thread->buf;
10286 struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)thread->buf;
10287 struct ast_iax2_meta_hdr *meta = (struct ast_iax2_meta_hdr *)thread->buf;
10288 struct ast_iax2_video_hdr *vh = (struct ast_iax2_video_hdr *)thread->buf;
10289 struct iax_frame *fr;
10290 struct iax_frame *cur;
10291 struct ast_frame f = { 0, };
10292 struct ast_channel *c = NULL;
10293 struct iax2_dpcache *dp;
10294 struct iax2_peer *peer;
10295 struct iax_ies ies;
10296 struct iax_ie_data ied0, ied1;
10297 iax2_format format;
10298 int fd;
10299 int exists;
10300 int minivid = 0;
10301 char empty[32]=""; /* Safety measure */
10302 struct iax_frame *duped_fr;
10303 char host_pref_buf[128];
10304 char caller_pref_buf[128];
10305 struct iax2_codec_pref pref;
10306 char *using_prefs = "mine";
10307
10308 /* allocate an iax_frame with 4096 bytes of data buffer */
10309 fr = ast_alloca(sizeof(*fr) + 4096);
10310 memset(fr, 0, sizeof(*fr));
10311 fr->afdatalen = 4096; /* From ast_alloca() above */
10312
10313 /* Copy frequently used parameters to the stack */
10314 res = thread->buf_len;
10315 fd = thread->iofd;
10316 ast_sockaddr_copy(&addr, &thread->ioaddr);
10317
10318 if (res < sizeof(*mh)) {
10319 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, (int) sizeof(*mh));
10320 return 1;
10321 }
10322 if ((vh->zeros == 0) && (ntohs(vh->callno) & 0x8000)) {
10323 if (res < sizeof(*vh)) {
10324 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a video frame but is too short\n",
10325 ast_sockaddr_stringify(&addr));
10326 return 1;
10327 }
10328
10329 /* This is a video frame, get call number */
10330 fr->callno = find_callno(ntohs(vh->callno) & ~0x8000, dcallno, &addr, new, fd, 0);
10331 minivid = 1;
10332 } else if ((meta->zeros == 0) && !(ntohs(meta->metacmd) & 0x8000))
10333 return socket_process_meta(res, meta, &addr, fd, fr);
10334
10335#ifdef DEBUG_SUPPORT
10336 if (res >= sizeof(*fh))
10337 iax_outputframe(NULL, fh, 1, &addr, res - sizeof(*fh));
10338#endif
10339 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10340 if (res < sizeof(*fh)) {
10341 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a full frame but is too short\n",
10342 ast_sockaddr_stringify(&addr));
10343 return 1;
10344 }
10345
10346 /* Get the destination call number */
10347 dcallno = ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS;
10348
10349
10350 /* check to make sure this full frame isn't encrypted before we attempt
10351 * to look inside of it. If it is encrypted, decrypt it first. Its ok if the
10352 * callno is not found here, that just means one hasn't been allocated for
10353 * this connection yet. */
10354 if ((dcallno != 1) && (fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, NEW_PREVENT, fd, 1))) {
10355 ast_mutex_lock(&iaxsl[fr->callno]);
10356 if (iaxs[fr->callno] && ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED)) {
10357 if (decrypt_frame(fr->callno, fh, &f, &res)) {
10358 ast_log(LOG_NOTICE, "Packet Decrypt Failed!\n");
10359 ast_mutex_unlock(&iaxsl[fr->callno]);
10360 return 1;
10361 }
10362 decrypted = 1;
10363 }
10364 ast_mutex_unlock(&iaxsl[fr->callno]);
10365 }
10366
10367 /* Retrieve the type and subclass */
10368 f.frametype = fh->type;
10369 if (f.frametype == AST_FRAME_VIDEO) {
10370 f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40));
10371 if (!f.subclass.format) {
10372 return 1;
10373 }
10374 if ((fh->csub >> 6) & 0x1) {
10375 f.subclass.frame_ending = 1;
10376 }
10377 } else if (f.frametype == AST_FRAME_VOICE) {
10378 f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
10379 if (!f.subclass.format) {
10380 return 1;
10381 }
10382 } else {
10383 f.subclass.integer = uncompress_subclass(fh->csub);
10384 }
10385
10386 /* Deal with POKE/PONG without allocating a callno */
10387 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_POKE) {
10388 /* Reply back with a PONG, but don't care about the result. */
10389 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_PONG, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10390 return 1;
10391 } else if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_ACK && dcallno == 1) {
10392 /* Ignore */
10393 return 1;
10394 }
10395
10396 f.datalen = res - sizeof(*fh);
10397 if (f.datalen) {
10398 if (f.frametype == AST_FRAME_IAX) {
10399 if (iax_parse_ies(&ies, thread->buf + sizeof(struct ast_iax2_full_hdr), f.datalen)) {
10400 char subclass[40];
10401 iax_frame_subclass2str(f.subclass.integer, subclass, sizeof(subclass));
10402 ast_log(LOG_WARNING, "Undecodable %s frame received from '%s'\n", subclass, ast_sockaddr_stringify(&addr));
10403 ast_variables_destroy(ies.vars);
10404 return 1;
10405 }
10406 f.data.ptr = NULL;
10407 f.datalen = 0;
10408 } else {
10409 f.data.ptr = thread->buf + sizeof(struct ast_iax2_full_hdr);
10410 memset(&ies, 0, sizeof(ies));
10411 }
10412 } else {
10413 if (f.frametype == AST_FRAME_IAX)
10414 f.data.ptr = NULL;
10415 else
10416 f.data.ptr = empty;
10417 memset(&ies, 0, sizeof(ies));
10418 }
10419
10420 if (!dcallno && iax2_allow_new(f.frametype, f.subclass.integer, 1)) {
10421 /* only set NEW_ALLOW if calltoken checks out */
10422 if (handle_call_token(fh, &ies, &addr, fd)) {
10423 ast_variables_destroy(ies.vars);
10424 return 1;
10425 }
10426
10427 if (ies.calltoken && ies.calltokendata) {
10428 /* if we've gotten this far, and the calltoken ie data exists,
10429 * then calltoken validation _MUST_ have taken place. If calltoken
10430 * data is provided, it is always validated regardless of any
10431 * calltokenoptional or requirecalltoken options */
10432 new = NEW_ALLOW_CALLTOKEN_VALIDATED;
10433 } else {
10434 new = NEW_ALLOW;
10435 }
10436 }
10437 } else {
10438 /* Don't know anything about it yet */
10439 f.frametype = AST_FRAME_NULL;
10440 f.subclass.integer = 0;
10441 memset(&ies, 0, sizeof(ies));
10442 }
10443
10444 if (!fr->callno) {
10445 int check_dcallno = 0;
10446
10447 /*
10448 * We enforce accurate destination call numbers for ACKs. This forces the other
10449 * end to know the destination call number before call setup can complete.
10450 *
10451 * Discussed in the following thread:
10452 * http://lists.digium.com/pipermail/asterisk-dev/2008-May/033217.html
10453 */
10454
10455 if ((ntohs(mh->callno) & IAX_FLAG_FULL) && ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer == IAX_COMMAND_ACK))) {
10456 check_dcallno = 1;
10457 }
10458
10459 if (!(fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, new, fd, check_dcallno))) {
10460 ast_debug(1, "Received frame without existent call number (%d)\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
10461 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_NEW) {
10462 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10463 } else if (f.frametype == AST_FRAME_IAX && (f.subclass.integer == IAX_COMMAND_REGREQ || f.subclass.integer == IAX_COMMAND_REGREL)) {
10464 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10465 } else {
10466 ast_log(LOG_WARNING, "Silently dropping frame without existent call number: %d\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
10467 }
10468 ast_variables_destroy(ies.vars);
10469 return 1;
10470 }
10471 }
10472
10473 if (fr->callno > 0) {
10474 ast_callid mount_callid;
10475 ast_mutex_lock(&iaxsl[fr->callno]);
10476 if (iaxs[fr->callno] && ((mount_callid = iax_pvt_callid_get(fr->callno)))) {
10477 /* Bind to thread */
10478 ast_callid_threadassoc_add(mount_callid);
10479 }
10480 }
10481
10482 if (!fr->callno || !iaxs[fr->callno]) {
10483 /* A call arrived for a nonexistent destination. Unless it's an "inval"
10484 frame, reply with an inval */
10485 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10486 /* We can only raw hangup control frames */
10487 if (((f.subclass.integer != IAX_COMMAND_INVAL) &&
10488 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10489 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10490 (f.subclass.integer != IAX_COMMAND_FWDOWNL))||
10491 (f.frametype != AST_FRAME_IAX))
10492 raw_hangup(&addr, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, ntohs(mh->callno) & ~IAX_FLAG_FULL,
10493 fd);
10494 }
10495 if (fr->callno > 0){
10496 ast_mutex_unlock(&iaxsl[fr->callno]);
10497 }
10498 ast_variables_destroy(ies.vars);
10499 return 1;
10500 }
10501 if (ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED) && !decrypted) {
10502 if (decrypt_frame(fr->callno, fh, &f, &res)) {
10503 ast_log(LOG_WARNING, "Packet Decrypt Failed!\n");
10504 ast_variables_destroy(ies.vars);
10505 ast_mutex_unlock(&iaxsl[fr->callno]);
10506 return 1;
10507 }
10508 decrypted = 1;
10509 }
10510
10511#ifdef DEBUG_SUPPORT
10512 if (decrypted) {
10513 iax_outputframe(NULL, fh, 3, &addr, res - sizeof(*fh));
10514 }
10515#endif
10516
10517 if (iaxs[fr->callno]->owner && fh->type == AST_FRAME_IAX &&
10518 (fh->csub == IAX_COMMAND_HANGUP
10519 || fh->csub == IAX_COMMAND_REJECT
10520 || fh->csub == IAX_COMMAND_REGREJ
10521 || fh->csub == IAX_COMMAND_TXREJ)) {
10522 struct ast_control_pvt_cause_code *cause_code;
10523 int data_size = sizeof(*cause_code);
10524 char subclass[40] = "";
10525
10526 /* get subclass text */
10527 iax_frame_subclass2str(fh->csub, subclass, sizeof(subclass));
10528
10529 /* add length of "IAX2 " */
10530 data_size += 5;
10531 /* for IAX hangup frames, add length of () and number */
10532 data_size += 3;
10533 if (ies.causecode > 9) {
10534 data_size++;
10535 }
10536 if (ies.causecode > 99) {
10537 data_size++;
10538 }
10539 /* add length of subclass */
10540 data_size += strlen(subclass);
10541
10542 cause_code = ast_alloca(data_size);
10543 memset(cause_code, 0, data_size);
10544 ast_copy_string(cause_code->chan_name, ast_channel_name(iaxs[fr->callno]->owner), AST_CHANNEL_NAME);
10545
10546 cause_code->ast_cause = ies.causecode;
10547 snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "IAX2 %s(%d)", subclass, ies.causecode);
10548
10549 iax2_lock_owner(fr->callno);
10550 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
10551 ast_queue_control_data(iaxs[fr->callno]->owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
10552 ast_channel_hangupcause_hash_set(iaxs[fr->callno]->owner, cause_code, data_size);
10553 ast_channel_unlock(iaxs[fr->callno]->owner);
10554 }
10555 if (!iaxs[fr->callno]) {
10556 ast_variables_destroy(ies.vars);
10557 ast_mutex_unlock(&iaxsl[fr->callno]);
10558 return 1;
10559 }
10560 }
10561
10562 /* count this frame */
10563 iaxs[fr->callno]->frames_received++;
10564
10565 if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) && !minivid &&
10566 f.subclass.integer != IAX_COMMAND_TXCNT && /* for attended transfer */
10567 f.subclass.integer != IAX_COMMAND_TXACC) { /* for attended transfer */
10568 unsigned short new_peercallno;
10569
10570 new_peercallno = (unsigned short) (ntohs(mh->callno) & ~IAX_FLAG_FULL);
10571 if (new_peercallno && new_peercallno != iaxs[fr->callno]->peercallno) {
10572 if (iaxs[fr->callno]->peercallno) {
10573 remove_by_peercallno(iaxs[fr->callno]);
10574 }
10575 iaxs[fr->callno]->peercallno = new_peercallno;
10576 store_by_peercallno(iaxs[fr->callno]);
10577 }
10578 }
10579 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10580 if (iaxdebug)
10581 ast_debug(1, "Received packet %d, (%u, %d)\n", fh->oseqno, f.frametype, f.subclass.integer);
10582 /* Check if it's out of order (and not an ACK or INVAL) */
10583 fr->oseqno = fh->oseqno;
10584 fr->iseqno = fh->iseqno;
10585 fr->ts = ntohl(fh->ts);
10586#ifdef IAXTESTS
10587 if (test_resync) {
10588 ast_debug(1, "Simulating frame ts resync, was %u now %u\n", fr->ts, fr->ts + test_resync);
10589 fr->ts += test_resync;
10590 }
10591#endif /* IAXTESTS */
10592#if 0
10593 if ( (ntohs(fh->dcallno) & IAX_FLAG_RETRANS) ||
10594 ( (f.frametype != AST_FRAME_VOICE) && ! (f.frametype == AST_FRAME_IAX &&
10595 (f.subclass == IAX_COMMAND_NEW ||
10596 f.subclass == IAX_COMMAND_AUTHREQ ||
10597 f.subclass == IAX_COMMAND_ACCEPT ||
10598 f.subclass == IAX_COMMAND_REJECT)) ) )
10599#endif
10600 if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) || (f.frametype != AST_FRAME_VOICE))
10601 updatehistory = 0;
10602 if ((iaxs[fr->callno]->iseqno != fr->oseqno) &&
10603 (iaxs[fr->callno]->iseqno ||
10604 ((f.subclass.integer != IAX_COMMAND_TXCNT) &&
10605 (f.subclass.integer != IAX_COMMAND_TXREADY) && /* for attended transfer */
10606 (f.subclass.integer != IAX_COMMAND_TXREL) && /* for attended transfer */
10607 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) && /* for attended transfer */
10608 (f.subclass.integer != IAX_COMMAND_TXACC)) ||
10609 (f.frametype != AST_FRAME_IAX))) {
10610 if (
10611 ((f.subclass.integer != IAX_COMMAND_ACK) &&
10612 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10613 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10614 (f.subclass.integer != IAX_COMMAND_TXREADY) && /* for attended transfer */
10615 (f.subclass.integer != IAX_COMMAND_TXREL) && /* for attended transfer */
10616 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) && /* for attended transfer */
10617 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10618 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10619 (f.frametype != AST_FRAME_IAX)) {
10620 /* If it's not an ACK packet, it's out of order. */
10621 ast_debug(1, "Packet arrived out of order (expecting %d, got %d) (frametype = %u, subclass = %d)\n",
10622 iaxs[fr->callno]->iseqno, fr->oseqno, f.frametype, f.subclass.integer);
10623 /* Check to see if we need to request retransmission,
10624 * and take sequence number wraparound into account */
10625 if ((unsigned char) (iaxs[fr->callno]->iseqno - fr->oseqno) < 128) {
10626 /* If we've already seen it, ack it XXX There's a border condition here XXX */
10627 if ((f.frametype != AST_FRAME_IAX) ||
10628 ((f.subclass.integer != IAX_COMMAND_ACK) && (f.subclass.integer != IAX_COMMAND_INVAL))) {
10629 ast_debug(1, "Acking anyway\n");
10630 /* XXX Maybe we should handle its ack to us, but then again, it's probably outdated anyway, and if
10631 we have anything to send, we'll retransmit and get an ACK back anyway XXX */
10632 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10633 }
10634 } else {
10635 /* Send a VNAK requesting retransmission */
10636 iax2_vnak(fr->callno);
10637 }
10638 ast_variables_destroy(ies.vars);
10639 ast_mutex_unlock(&iaxsl[fr->callno]);
10640 return 1;
10641 }
10642 } else {
10643 /* Increment unless it's an ACK or VNAK */
10644 if (((f.subclass.integer != IAX_COMMAND_ACK) &&
10645 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10646 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10647 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10648 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10649 (f.frametype != AST_FRAME_IAX))
10650 iaxs[fr->callno]->iseqno++;
10651 }
10652 /* Ensure text frames are NULL-terminated */
10653 if (f.frametype == AST_FRAME_TEXT && thread->buf[res - 1] != '\0') {
10654 if (res < thread->buf_size)
10655 thread->buf[res++] = '\0';
10656 else /* Trims one character from the text message, but that's better than overwriting the end of the buffer. */
10657 thread->buf[res - 1] = '\0';
10658 }
10659
10660 /* Handle implicit ACKing unless this is an INVAL, and only if this is
10661 from the real peer, not the transfer peer */
10662 if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
10663 ((f.subclass.integer != IAX_COMMAND_INVAL) ||
10664 (f.frametype != AST_FRAME_IAX))) {
10665 unsigned char x;
10666 int call_to_destroy;
10667 /* First we have to qualify that the ACKed value is within our window */
10668 if (iaxs[fr->callno]->rseqno >= iaxs[fr->callno]->oseqno || (fr->iseqno >= iaxs[fr->callno]->rseqno && fr->iseqno < iaxs[fr->callno]->oseqno))
10669 x = fr->iseqno;
10670 else
10671 x = iaxs[fr->callno]->oseqno;
10672 if ((x != iaxs[fr->callno]->oseqno) || (iaxs[fr->callno]->oseqno == fr->iseqno)) {
10673 /* The acknowledgement is within our window. Time to acknowledge everything
10674 that it says to */
10675 for (x=iaxs[fr->callno]->rseqno; x != fr->iseqno; x++) {
10676 /* Ack the packet with the given timestamp */
10677 if (iaxdebug)
10678 ast_debug(1, "Cancelling transmission of packet %d\n", x);
10679 call_to_destroy = 0;
10680 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10681 /* If it's our call, and our timestamp, mark -1 retries */
10682 if (x == cur->oseqno) {
10683 cur->retries = -1;
10684 /* Destroy call if this is the end */
10685 if (cur->final)
10686 call_to_destroy = fr->callno;
10687 }
10688 }
10689 if (call_to_destroy) {
10690 if (iaxdebug)
10691 ast_debug(1, "Really destroying %d, having been acked on final message\n", call_to_destroy);
10692 ast_mutex_lock(&iaxsl[call_to_destroy]);
10693 iax2_destroy(call_to_destroy);
10694 ast_mutex_unlock(&iaxsl[call_to_destroy]);
10695 }
10696 }
10697 /* Note how much we've received acknowledgement for */
10698 if (iaxs[fr->callno])
10699 iaxs[fr->callno]->rseqno = fr->iseqno;
10700 else {
10701 /* Stop processing now */
10702 ast_variables_destroy(ies.vars);
10703 ast_mutex_unlock(&iaxsl[fr->callno]);
10704 return 1;
10705 }
10706 } else {
10707 ast_debug(1, "Received iseqno %d not within window %d->%d\n", fr->iseqno, iaxs[fr->callno]->rseqno, iaxs[fr->callno]->oseqno);
10708 }
10709 }
10710 if (ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
10711 ((f.frametype != AST_FRAME_IAX) ||
10712 ((f.subclass.integer != IAX_COMMAND_TXACC) &&
10713 (f.subclass.integer != IAX_COMMAND_TXCNT)))) {
10714 /* Only messages we accept from a transfer host are TXACC and TXCNT */
10715 ast_variables_destroy(ies.vars);
10716 ast_mutex_unlock(&iaxsl[fr->callno]);
10717 return 1;
10718 }
10719
10720 /* when we receive the first full frame for a new incoming channel,
10721 it is safe to start the PBX on the channel because we have now
10722 completed a 3-way handshake with the peer */
10723 if ((f.frametype == AST_FRAME_VOICE) ||
10724 (f.frametype == AST_FRAME_VIDEO) ||
10725 (f.frametype == AST_FRAME_IAX)) {
10726 if (ast_test_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART)) {
10727 ast_clear_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
10728 if (!ast_iax2_new(fr->callno, AST_STATE_RING,
10729 iaxs[fr->callno]->chosenformat, &iaxs[fr->callno]->rprefs, NULL, NULL,
10730 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
10731 ast_variables_destroy(ies.vars);
10732 ast_mutex_unlock(&iaxsl[fr->callno]);
10733 return 1;
10734 }
10735 }
10736
10737 if (ies.vars) {
10738 struct ast_datastore *variablestore = NULL;
10739 struct ast_variable *var, *prev = NULL;
10740 AST_LIST_HEAD(, ast_var_t) *varlist;
10741
10742 iax2_lock_owner(fr->callno);
10743 if (!iaxs[fr->callno]) {
10744 ast_variables_destroy(ies.vars);
10745 ast_mutex_unlock(&iaxsl[fr->callno]);
10746 return 1;
10747 }
10748 if ((c = iaxs[fr->callno]->owner)) {
10749 varlist = ast_calloc(1, sizeof(*varlist));
10750 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
10751
10752 if (variablestore && varlist) {
10753 variablestore->data = varlist;
10754 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
10755 AST_LIST_HEAD_INIT(varlist);
10756 ast_debug(1, "I can haz IAX vars?\n");
10757 for (var = ies.vars; var; var = var->next) {
10758 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
10759 if (prev) {
10760 ast_free(prev);
10761 }
10762 prev = var;
10763 if (!newvar) {
10764 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
10765 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10766 } else {
10767 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
10768 }
10769 }
10770 if (prev) {
10771 ast_free(prev);
10772 }
10773 ies.vars = NULL;
10774 ast_channel_datastore_add(c, variablestore);
10775 } else {
10776 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10777 if (variablestore) {
10778 ast_datastore_free(variablestore);
10779 }
10780 if (varlist) {
10781 ast_free(varlist);
10782 }
10783 }
10784 ast_channel_unlock(c);
10785 } else {
10786 /* No channel yet, so transfer the variables directly over to the pvt,
10787 * for later inheritance. */
10788 ast_debug(1, "No channel, so populating IAXVARs to the pvt, as an intermediate step.\n");
10789 for (var = ies.vars; var && var->next; var = var->next);
10790 if (var) {
10791 var->next = iaxs[fr->callno]->iaxvars;
10792 iaxs[fr->callno]->iaxvars = ies.vars;
10793 ies.vars = NULL;
10794 }
10795 }
10796 }
10797
10798 if (ies.vars) {
10799 ast_debug(1, "I have IAX variables, but they were not processed\n");
10800 }
10801 }
10802
10803 /* once we receive our first IAX Full Frame that is not CallToken related, send all
10804 * queued signaling frames that were being held. */
10805 if ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer != IAX_COMMAND_CALLTOKEN) && iaxs[fr->callno]->hold_signaling) {
10806 send_signaling(iaxs[fr->callno]);
10807 }
10808
10809 if (f.frametype == AST_FRAME_VOICE) {
10810 if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->voiceformat) {
10811 iaxs[fr->callno]->voiceformat = ast_format_compatibility_format2bitfield(f.subclass.format);
10812 ast_debug(1, "Ooh, voice format changed to '%s'\n", ast_format_get_name(f.subclass.format));
10813 if (iaxs[fr->callno]->owner) {
10814 iax2_lock_owner(fr->callno);
10815 if (iaxs[fr->callno]) {
10816 if (iaxs[fr->callno]->owner) {
10817 struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
10818 if (native) {
10819 ast_format_cap_append(native, f.subclass.format, 0);
10820 ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
10821 if (ast_channel_readformat(iaxs[fr->callno]->owner)) {
10822 ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
10823 }
10824 ao2_ref(native, -1);
10825 }
10826 ast_channel_unlock(iaxs[fr->callno]->owner);
10827 }
10828 } else {
10829 ast_debug(1, "Neat, somebody took away the channel at a magical time but i found it!\n");
10830 /* Free remote variables (if any) */
10831 if (ies.vars) {
10832 ast_variables_destroy(ies.vars);
10833 ast_debug(1, "I can haz iaxvars, but they is no good. :-(\n");
10834 ies.vars = NULL;
10835 }
10836 ast_mutex_unlock(&iaxsl[fr->callno]);
10837 return 1;
10838 }
10839 }
10840 }
10841 }
10842 if (f.frametype == AST_FRAME_VIDEO) {
10843 if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->videoformat) {
10844 ast_debug(1, "Ooh, video format changed to %s\n", ast_format_get_name(f.subclass.format));
10845 iaxs[fr->callno]->videoformat = ast_format_compatibility_format2bitfield(f.subclass.format);
10846 }
10847 }
10848 if (f.frametype == AST_FRAME_IAX) {
10849 AST_SCHED_DEL(sched, iaxs[fr->callno]->initid);
10850 /* Handle the IAX pseudo frame itself */
10851 if (iaxdebug)
10852 ast_debug(1, "IAX subclass %d received\n", f.subclass.integer);
10853
10854 /* Update last ts unless the frame's timestamp originated with us. */
10855 if (iaxs[fr->callno]->last < fr->ts &&
10856 f.subclass.integer != IAX_COMMAND_ACK &&
10857 f.subclass.integer != IAX_COMMAND_PONG &&
10858 f.subclass.integer != IAX_COMMAND_LAGRP) {
10859 iaxs[fr->callno]->last = fr->ts;
10860 if (iaxdebug)
10861 ast_debug(1, "For call=%d, set last=%u\n", fr->callno, fr->ts);
10862 }
10863 iaxs[fr->callno]->last_iax_message = f.subclass.integer;
10864 if (!iaxs[fr->callno]->first_iax_message) {
10865 iaxs[fr->callno]->first_iax_message = f.subclass.integer;
10866 }
10867 switch(f.subclass.integer) {
10868 case IAX_COMMAND_ACK:
10869 /* Do nothing */
10870 break;
10871 case IAX_COMMAND_QUELCH:
10872 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10873 ast_set_flag64(iaxs[fr->callno], IAX_QUELCH);
10874 if (ies.musiconhold) {
10875 const char *moh_suggest;
10876
10877 iax2_lock_owner(fr->callno);
10878 if (!iaxs[fr->callno] || !iaxs[fr->callno]->owner) {
10879 break;
10880 }
10881
10882 /*
10883 * We already hold the owner lock so we do not
10884 * need to check iaxs[fr->callno] after it returns.
10885 */
10886 moh_suggest = iaxs[fr->callno]->mohsuggest;
10887 iax2_queue_hold(fr->callno, moh_suggest);
10888 ast_channel_unlock(iaxs[fr->callno]->owner);
10889 }
10890 }
10891 break;
10892 case IAX_COMMAND_UNQUELCH:
10893 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10894 iax2_lock_owner(fr->callno);
10895 if (!iaxs[fr->callno]) {
10896 break;
10897 }
10898
10899 ast_clear_flag64(iaxs[fr->callno], IAX_QUELCH);
10900 if (!iaxs[fr->callno]->owner) {
10901 break;
10902 }
10903
10904 /*
10905 * We already hold the owner lock so we do not
10906 * need to check iaxs[fr->callno] after it returns.
10907 */
10908 iax2_queue_unhold(fr->callno);
10909 ast_channel_unlock(iaxs[fr->callno]->owner);
10910 }
10911 break;
10912 case IAX_COMMAND_TXACC:
10913 if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
10914 /* Ack the packet with the given timestamp */
10915 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10916 /* Cancel any outstanding txcnt's */
10917 if (cur->transfer) {
10918 cur->retries = -1;
10919 }
10920 }
10921 memset(&ied1, 0, sizeof(ied1));
10922 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
10923 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
10924 iaxs[fr->callno]->transferring = TRANSFER_READY;
10925 }
10926 break;
10927 case IAX_COMMAND_NEW:
10928 /* Ignore if it's already up */
10929 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD))
10930 break;
10931 if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
10932 ast_mutex_unlock(&iaxsl[fr->callno]);
10933 check_provisioning(&addr, fd, ies.serviceident, ies.provver);
10934 ast_mutex_lock(&iaxsl[fr->callno]);
10935 if (!iaxs[fr->callno]) {
10936 break;
10937 }
10938 }
10939 /* If we're in trunk mode, do it now, and update the trunk number in our frame before continuing */
10940 if (ast_test_flag64(iaxs[fr->callno], IAX_TRUNK)) {
10941 int new_callno;
10942 if ((new_callno = make_trunk(fr->callno, 1)) != -1)
10943 fr->callno = new_callno;
10944 }
10945 /* For security, always ack immediately */
10946 if (delayreject)
10947 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10948 if (check_access(fr->callno, &addr, &ies)) {
10949 /* They're not allowed on */
10950 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10951 if (authdebug) {
10952 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, who was trying to reach '%s@%s'\n",
10953 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10954 }
10955 break;
10956 }
10957 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_test_flag64(iaxs[fr->callno], IAX_FORCE_ENCRYPT)) {
10958 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10959 ast_log(LOG_WARNING, "Rejected connect attempt. No secret present while force encrypt enabled.\n");
10960 break;
10961 }
10962 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
10963 const char *context, *exten, *cid_num;
10964
10965 context = ast_strdupa(iaxs[fr->callno]->context);
10966 exten = ast_strdupa(iaxs[fr->callno]->exten);
10967 cid_num = ast_strdupa(iaxs[fr->callno]->cid_num);
10968
10969 /* This might re-enter the IAX code and need the lock */
10970 ast_mutex_unlock(&iaxsl[fr->callno]);
10971 exists = ast_exists_extension(NULL, context, exten, 1, cid_num);
10972 ast_mutex_lock(&iaxsl[fr->callno]);
10973
10974 if (!iaxs[fr->callno]) {
10975 break;
10976 }
10977 } else
10978 exists = 0;
10979 /* Get OSP token if it does exist */
10980 save_osptoken(fr, &ies);
10981 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) {
10982 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
10983 memset(&ied0, 0, sizeof(ied0));
10984 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
10985 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
10986 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10987 if (!iaxs[fr->callno]) {
10988 break;
10989 }
10990 if (authdebug) {
10991 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
10992 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10993 }
10994 } else {
10995 /* Select an appropriate format */
10996
10997 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
10998 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
10999 using_prefs = "reqonly";
11000 } else {
11001 using_prefs = "disabled";
11002 }
11003 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
11004 memset(&pref, 0, sizeof(pref));
11005 strcpy(caller_pref_buf, "disabled");
11006 strcpy(host_pref_buf, "disabled");
11007 } else {
11008 struct ast_format *tmpfmt;
11009 using_prefs = "mine";
11010 /* If the information elements are in here... use them */
11011 if (ies.codec_prefs)
11012 iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
11013 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11014 /* If we are codec_first_choice we let the caller have the 1st shot at picking the codec.*/
11015 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11016 pref = iaxs[fr->callno]->rprefs;
11017 using_prefs = "caller";
11018 } else {
11019 pref = iaxs[fr->callno]->prefs;
11020 }
11021 } else
11022 pref = iaxs[fr->callno]->prefs;
11023
11024 format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
11025 iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
11026 iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
11027 }
11028 if (!format) {
11029 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP))
11030 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
11031 if (!format) {
11032 memset(&ied0, 0, sizeof(ied0));
11033 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11034 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11035 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11036 if (!iaxs[fr->callno]) {
11037 break;
11038 }
11039 if (authdebug) {
11040 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11041 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11042 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11043
11044 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11045 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11046 ast_sockaddr_stringify(&addr),
11047 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11048 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11049 } else {
11050 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11051 ast_sockaddr_stringify(&addr),
11052 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11053 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11054 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11055 }
11056 }
11057 } else {
11058 /* Pick one... */
11059 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11060 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
11061 format = 0;
11062 } else {
11063 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11064 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
11065 memset(&pref, 0, sizeof(pref));
11066 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11067 strcpy(caller_pref_buf,"disabled");
11068 strcpy(host_pref_buf,"disabled");
11069 } else {
11070 struct ast_format *tmpfmt;
11071 using_prefs = "mine";
11072 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11073 /* Do the opposite of what we tried above. */
11074 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11075 pref = iaxs[fr->callno]->prefs;
11076 } else {
11077 pref = iaxs[fr->callno]->rprefs;
11078 using_prefs = "caller";
11079 }
11080 format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11081 } else /* if no codec_prefs IE do it the old way */
11082 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11083 }
11084 }
11085
11086 if (!format) {
11087 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11088 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11089 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11090
11091 memset(&ied0, 0, sizeof(ied0));
11092 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11093 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11094 ast_log(LOG_ERROR, "No best format in '%s'???\n", iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
11095 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11096 if (!iaxs[fr->callno]) {
11097 break;
11098 }
11099 if (authdebug) {
11100 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11101 ast_sockaddr_stringify(&addr),
11102 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11103 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11104 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11105 }
11106 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11107 break;
11108 }
11109 }
11110 }
11111 if (format) {
11112 /* No authentication required, let them in */
11113 memset(&ied1, 0, sizeof(ied1));
11114 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
11115 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
11116 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
11117 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
11118 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11119 ast_verb(3, "Accepting UNAUTHENTICATED call from %s:\n"
11120 "%srequested format = %s,\n"
11121 "%srequested prefs = %s,\n"
11122 "%sactual format = %s,\n"
11123 "%shost prefs = %s,\n"
11124 "%spriority = %s\n",
11125 ast_sockaddr_stringify(&addr),
11126 VERBOSE_PREFIX_4,
11127 iax2_getformatname(iaxs[fr->callno]->peerformat),
11128 VERBOSE_PREFIX_4,
11129 caller_pref_buf,
11130 VERBOSE_PREFIX_4,
11131 iax2_getformatname(format),
11132 VERBOSE_PREFIX_4,
11133 host_pref_buf,
11134 VERBOSE_PREFIX_4,
11135 using_prefs);
11136
11137 iaxs[fr->callno]->chosenformat = format;
11138
11139 /* Since this is a new call, we should go ahead and set the callid for it. */
11140 iax_pvt_callid_new(fr->callno);
11141 ast_set_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
11142 } else {
11143 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11144 /* If this is a TBD call, we're ready but now what... */
11145 ast_verb(3, "Accepted unauthenticated TBD call from %s\n", ast_sockaddr_stringify(&addr));
11146 }
11147 }
11148 }
11149 break;
11150 }
11151 if (iaxs[fr->callno]->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA))
11152 merge_encryption(iaxs[fr->callno], ies.encmethods);
11153 else
11154 iaxs[fr->callno]->encmethods = 0;
11155 if (!authenticate_request(fr->callno) && iaxs[fr->callno])
11156 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED);
11157 break;
11158 case IAX_COMMAND_DPREQ:
11159 /* Request status in the dialplan */
11160 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD) &&
11161 !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED) && ies.called_number) {
11162 if (iaxcompat) {
11163 /* Spawn a thread for the lookup */
11164 spawn_dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num);
11165 } else {
11166 /* Just look it up */
11167 dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num, 1);
11168 }
11169 }
11170 break;
11171 case IAX_COMMAND_HANGUP:
11172 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11173 ast_debug(1, "Immediately destroying %d, having received hangup\n", fr->callno);
11174 /* Set hangup cause according to remote and hangupsource */
11175 if (iaxs[fr->callno]->owner) {
11176 set_hangup_source_and_cause(fr->callno, ies.causecode);
11177 if (!iaxs[fr->callno]) {
11178 break;
11179 }
11180 }
11181
11182 /* Send ack immediately, before we destroy */
11183 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11184 iax2_destroy(fr->callno);
11185 break;
11186 case IAX_COMMAND_REJECT:
11187 /* Set hangup cause according to remote and hangup source */
11188 if (iaxs[fr->callno]->owner) {
11189 set_hangup_source_and_cause(fr->callno, ies.causecode);
11190 if (!iaxs[fr->callno]) {
11191 break;
11192 }
11193 }
11194
11195 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
11196 if (iaxs[fr->callno]->owner && authdebug)
11197 ast_log(LOG_WARNING, "Call rejected by %s: %s\n",
11198 ast_sockaddr_stringify(&addr),
11199 ies.cause ? ies.cause : "<Unknown>");
11200 ast_debug(1, "Immediately destroying %d, having received reject\n",
11201 fr->callno);
11202 }
11203 /* Send ack immediately, before we destroy */
11204 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK,
11205 fr->ts, NULL, 0, fr->iseqno);
11206 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION))
11207 iaxs[fr->callno]->error = EPERM;
11208 iax2_destroy(fr->callno);
11209 break;
11210 case IAX_COMMAND_TRANSFER:
11211 {
11212 iax2_lock_owner(fr->callno);
11213 if (!iaxs[fr->callno]) {
11214 /* Initiating call went away before we could transfer. */
11215 break;
11216 }
11217 if (iaxs[fr->callno]->owner) {
11218 struct ast_channel *owner = iaxs[fr->callno]->owner;
11219 char *context = ast_strdupa(iaxs[fr->callno]->context);
11220
11221 ast_channel_ref(owner);
11222 ast_channel_unlock(owner);
11223 ast_mutex_unlock(&iaxsl[fr->callno]);
11224
11225 if (ast_bridge_transfer_blind(1, owner, ies.called_number,
11226 context, NULL, NULL) != AST_BRIDGE_TRANSFER_SUCCESS) {
11227 ast_log(LOG_WARNING, "Blind transfer of '%s' to '%s@%s' failed\n",
11228 ast_channel_name(owner), ies.called_number,
11229 context);
11230 }
11231
11232 ast_channel_unref(owner);
11233 ast_mutex_lock(&iaxsl[fr->callno]);
11234 }
11235
11236 break;
11237 }
11238 case IAX_COMMAND_ACCEPT:
11239 /* Ignore if call is already up or needs authentication or is a TBD */
11240 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD | IAX_STATE_AUTHENTICATED))
11241 break;
11242 if (ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
11243 /* Send ack immediately, before we destroy */
11244 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11245 iax2_destroy(fr->callno);
11246 break;
11247 }
11248 if (ies.format) {
11249 iaxs[fr->callno]->peerformat = ies.format;
11250 } else {
11251 if (iaxs[fr->callno]->owner)
11252 iaxs[fr->callno]->peerformat = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(iaxs[fr->callno]->owner));
11253 else
11254 iaxs[fr->callno]->peerformat = iaxs[fr->callno]->capability;
11255 }
11256 ast_verb(3, "Call accepted by %s (format %s)\n", ast_sockaddr_stringify(&addr),
11257 iax2_getformatname(iaxs[fr->callno]->peerformat));
11258 if (!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability)) {
11259 memset(&ied0, 0, sizeof(ied0));
11260 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11261 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11262 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11263 if (!iaxs[fr->callno]) {
11264 break;
11265 }
11266 if (authdebug) {
11267 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11268 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11269
11270 ast_log(LOG_NOTICE, "Rejected call to %s, format %s incompatible with our capability %s.\n",
11271 ast_sockaddr_stringify(&addr),
11272 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_buf),
11273 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11274 }
11275 } else {
11276 struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
11277
11278 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11279 iax2_lock_owner(fr->callno);
11280 if (iaxs[fr->callno] && iaxs[fr->callno]->owner && native) {
11281 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11282
11283 /* Switch us to use a compatible format */
11284 iax2_codec_pref_best_bitfield2cap(
11285 iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
11286 native);
11287 ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
11288 ast_verb(3, "Format for call is %s\n", ast_format_cap_get_names(ast_channel_nativeformats(iaxs[fr->callno]->owner), &cap_buf));
11289
11290 /* Setup read/write formats properly. */
11291 if (ast_channel_writeformat(iaxs[fr->callno]->owner))
11292 ast_set_write_format(iaxs[fr->callno]->owner, ast_channel_writeformat(iaxs[fr->callno]->owner));
11293 if (ast_channel_readformat(iaxs[fr->callno]->owner))
11294 ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
11295 ast_channel_unlock(iaxs[fr->callno]->owner);
11296 }
11297
11298 ao2_cleanup(native);
11299 }
11300 if (iaxs[fr->callno]) {
11301 AST_LIST_LOCK(&dpcache);
11302 AST_LIST_TRAVERSE(&iaxs[fr->callno]->dpentries, dp, peer_list)
11303 if (!(dp->flags & CACHE_FLAG_TRANSMITTED))
11304 iax2_dprequest(dp, fr->callno);
11305 AST_LIST_UNLOCK(&dpcache);
11306 }
11307 break;
11308 case IAX_COMMAND_POKE:
11309 /* Send back a pong packet with the original timestamp */
11310 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, NULL, 0, -1);
11311 break;
11312 case IAX_COMMAND_PING:
11313 {
11314 struct iax_ie_data pingied;
11315 construct_rr(iaxs[fr->callno], &pingied);
11316 /* Send back a pong packet with the original timestamp */
11317 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, pingied.buf, pingied.pos, -1);
11318 }
11319 break;
11320 case IAX_COMMAND_PONG:
11321 /* Calculate ping time */
11322 iaxs[fr->callno]->pingtime = calc_timestamp(iaxs[fr->callno], 0, &f) - fr->ts;
11323 /* save RR info */
11324 save_rr(fr, &ies);
11325
11326 /* Good time to write jb stats for this call */
11327 log_jitterstats(fr->callno);
11328
11329 if (iaxs[fr->callno]->peerpoke) {
11330 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
11331 peer = iaxs[fr->callno]->peerpoke;
11332 if ((peer->lastms < 0) || (peer->historicms > peer->maxms)) {
11333 if (iaxs[fr->callno]->pingtime <= peer->maxms) {
11334 ast_log(LOG_NOTICE, "Peer '%s' is now REACHABLE! Time: %u\n", peer->name, iaxs[fr->callno]->pingtime);
11335 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
11336 blob = ast_json_pack("{s: s, s: I}",
11337 "peer_status", "Reachable",
11338 "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
11339 ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
11340 }
11341 } else if ((peer->historicms > 0) && (peer->historicms <= peer->maxms)) {
11342 if (iaxs[fr->callno]->pingtime > peer->maxms) {
11343 ast_log(LOG_NOTICE, "Peer '%s' is now TOO LAGGED (%u ms)!\n", peer->name, iaxs[fr->callno]->pingtime);
11344 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
11345 blob = ast_json_pack("{s: s, s: I}",
11346 "peer_status", "Lagged",
11347 "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
11348 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
11349 }
11350 }
11351 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
11352 peer->lastms = iaxs[fr->callno]->pingtime;
11353 if (peer->smoothing && (peer->lastms > -1))
11354 peer->historicms = (iaxs[fr->callno]->pingtime + peer->historicms) / 2;
11355 else if (peer->smoothing && peer->lastms < 0)
11356 peer->historicms = (0 + peer->historicms) / 2;
11357 else
11358 peer->historicms = iaxs[fr->callno]->pingtime;
11359
11360 /* Remove scheduled iax2_poke_noanswer */
11361 if (peer->pokeexpire > -1) {
11362 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
11363 peer_unref(peer);
11364 peer->pokeexpire = -1;
11365 }
11366 }
11367 /* Schedule the next cycle */
11368 if ((peer->lastms < 0) || (peer->historicms > peer->maxms))
11369 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
11370 else
11371 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqok, iax2_poke_peer_s, peer_ref(peer));
11372 if (peer->pokeexpire == -1)
11373 peer_unref(peer);
11374 /* and finally send the ack */
11375 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11376 /* And wrap up the qualify call */
11377 iax2_destroy(fr->callno);
11378 peer->callno = 0;
11379 ast_debug(1, "Peer %s: got pong, lastms %d, historicms %d, maxms %d\n", peer->name, peer->lastms, peer->historicms, peer->maxms);
11380 }
11381 break;
11382 case IAX_COMMAND_LAGRQ:
11383 case IAX_COMMAND_LAGRP:
11384 f.src = "LAGRQ";
11385 f.mallocd = 0;
11386 f.offset = 0;
11387 f.samples = 0;
11388 iax_frame_wrap(fr, &f);
11389 if (f.subclass.integer == IAX_COMMAND_LAGRQ) {
11390 /* Received a LAGRQ - echo back a LAGRP */
11391 fr->af.subclass.integer = IAX_COMMAND_LAGRP;
11392 iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
11393 } else {
11394 /* Received LAGRP in response to our LAGRQ */
11395 unsigned int ts;
11396 /* This is a reply we've been given, actually measure the difference */
11397 ts = calc_timestamp(iaxs[fr->callno], 0, &fr->af);
11398 iaxs[fr->callno]->lag = ts - fr->ts;
11399 if (iaxdebug)
11400 ast_debug(1, "Peer %s lag measured as %dms\n",
11401 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->lag);
11402 }
11403 break;
11404 case IAX_COMMAND_AUTHREQ:
11405 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
11406 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>");
11407 break;
11408 }
11409 if (authenticate_reply(iaxs[fr->callno], &iaxs[fr->callno]->addr, &ies, iaxs[fr->callno]->secret, iaxs[fr->callno]->outkey)) {
11410 struct ast_frame hangup_fr = { .frametype = AST_FRAME_CONTROL,
11411 .subclass.integer = AST_CONTROL_HANGUP,
11412 };
11413 ast_log(LOG_WARNING,
11414 "I don't know how to authenticate %s to %s\n",
11415 ies.username ? ies.username : "<unknown>", ast_sockaddr_stringify(&addr));
11416 iax2_queue_frame(fr->callno, &hangup_fr);
11417 }
11418 break;
11419 case IAX_COMMAND_AUTHREP:
11420 /* For security, always ack immediately */
11421 if (delayreject)
11422 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11423 /* Ignore once we've started */
11424 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
11425 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>");
11426 break;
11427 }
11428 if (authenticate_verify(iaxs[fr->callno], &ies)) {
11429 if (authdebug)
11430 ast_log(LOG_WARNING, "Host %s failed to authenticate as %s\n", ast_sockaddr_stringify(&addr),
11431 iaxs[fr->callno]->username);
11432 memset(&ied0, 0, sizeof(ied0));
11433 auth_fail(fr->callno, IAX_COMMAND_REJECT);
11434 break;
11435 }
11436 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
11437 /* This might re-enter the IAX code and need the lock */
11438 exists = ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num);
11439 } else
11440 exists = 0;
11441 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
11442 if (authdebug)
11443 ast_log(LOG_WARNING, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
11444 ast_sockaddr_stringify(&addr),
11445 iaxs[fr->callno]->exten,
11446 iaxs[fr->callno]->context);
11447 memset(&ied0, 0, sizeof(ied0));
11448 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11449 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11450 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11451 if (!iaxs[fr->callno]) {
11452 break;
11453 }
11454 } else {
11455 /* Select an appropriate format */
11456 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11457 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11458 using_prefs = "reqonly";
11459 } else {
11460 using_prefs = "disabled";
11461 }
11462 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
11463 memset(&pref, 0, sizeof(pref));
11464 strcpy(caller_pref_buf, "disabled");
11465 strcpy(host_pref_buf, "disabled");
11466 } else {
11467 struct ast_format *tmpfmt;
11468 using_prefs = "mine";
11469 if (ies.codec_prefs)
11470 iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
11471 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11472 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11473 pref = iaxs[fr->callno]->rprefs;
11474 using_prefs = "caller";
11475 } else {
11476 pref = iaxs[fr->callno]->prefs;
11477 }
11478 } else /* if no codec_prefs IE do it the old way */
11479 pref = iaxs[fr->callno]->prefs;
11480 format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
11481 iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
11482 iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
11483 }
11484 if (!format) {
11485 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11486 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11487 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11488
11489 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11490 ast_debug(1, "We don't do requested format %s, falling back to peer capability '%s'\n",
11491 iax2_getformatname(iaxs[fr->callno]->peerformat),
11492 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf));
11493 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
11494 }
11495 if (!format) {
11496 if (authdebug) {
11497 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11498 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11499 ast_sockaddr_stringify(&addr),
11500 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11501 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11502 } else {
11503 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11504 ast_sockaddr_stringify(&addr),
11505 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11506 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11507 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11508 }
11509 }
11510 memset(&ied0, 0, sizeof(ied0));
11511 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11512 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11513 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11514 if (!iaxs[fr->callno]) {
11515 break;
11516 }
11517 } else {
11518 /* Pick one... */
11519 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11520 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
11521 format = 0;
11522 } else {
11523 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11524 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
11525 memset(&pref, 0, sizeof(pref));
11526 format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)
11527 ? iaxs[fr->callno]->peerformat
11528 : iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11529 strcpy(caller_pref_buf,"disabled");
11530 strcpy(host_pref_buf,"disabled");
11531 } else {
11532 struct ast_format *tmpfmt;
11533 using_prefs = "mine";
11534 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11535 /* Do the opposite of what we tried above. */
11536 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11537 pref = iaxs[fr->callno]->prefs;
11538 } else {
11539 pref = iaxs[fr->callno]->rprefs;
11540 using_prefs = "caller";
11541 }
11542 format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11543 } else /* if no codec_prefs IE do it the old way */
11544 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11545 }
11546 }
11547 if (!format) {
11548 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11549 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11550 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11551
11552 ast_log(LOG_ERROR, "No best format in %s???\n",
11553 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
11554 if (authdebug) {
11555 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11556 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11557 ast_sockaddr_stringify(&addr),
11558 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11559 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11560 } else {
11561 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11562 ast_sockaddr_stringify(&addr),
11563 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11564 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11565 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11566 }
11567 }
11568 memset(&ied0, 0, sizeof(ied0));
11569 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11570 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11571 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11572 if (!iaxs[fr->callno]) {
11573 break;
11574 }
11575 }
11576 }
11577 }
11578 if (format) {
11579 /* Authentication received */
11580 memset(&ied1, 0, sizeof(ied1));
11581 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
11582 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
11583 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
11584 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
11585 char authmethodnames[AUTH_METHOD_NAMES_BUFSIZE];
11586 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11587 ast_verb(3, "Accepting AUTHENTICATED call from %s:\n"
11588 "%srequested auth methods = (%s),\n"
11589 "%sactual auth method = %s,\n"
11590 "%sencrypted = %s,\n"
11591 "%srequested format = %s,\n"
11592 "%srequested prefs = %s,\n"
11593 "%sactual format = %s,\n"
11594 "%shost prefs = %s,\n"
11595 "%spriority = %s\n",
11596 ast_sockaddr_stringify(&addr),
11597 VERBOSE_PREFIX_4,
11598 auth_method_names(iaxs[fr->callno]->authmethods, authmethodnames),
11599 VERBOSE_PREFIX_4,
11600 auth_method_labels[iaxs[fr->callno]->eff_auth_method],
11601 VERBOSE_PREFIX_4,
11602 IAX_CALLENCRYPTED(iaxs[fr->callno]) ? "yes" : "no",
11603 VERBOSE_PREFIX_4,
11604 iax2_getformatname(iaxs[fr->callno]->peerformat),
11605 VERBOSE_PREFIX_4,
11606 caller_pref_buf,
11607 VERBOSE_PREFIX_4,
11608 iax2_getformatname(format),
11609 VERBOSE_PREFIX_4,
11610 host_pref_buf,
11611 VERBOSE_PREFIX_4,
11612 using_prefs);
11613
11614 /* Unlike unauthenticated calls, we don't need to store
11615 * the chosen format for channel creation.
11616 * However, this is helpful for __get_from_jb. */
11617 iaxs[fr->callno]->chosenformat = format;
11618
11619 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11620 c = ast_iax2_new(fr->callno, AST_STATE_RING, format,
11621 &iaxs[fr->callno]->rprefs, NULL, NULL, 1);
11622 if (!c) {
11623 iax2_destroy(fr->callno);
11624 } else if (ies.vars) {
11625 struct ast_datastore *variablestore;
11626 struct ast_variable *var, *prev = NULL;
11627 AST_LIST_HEAD(, ast_var_t) *varlist;
11628 varlist = ast_calloc(1, sizeof(*varlist));
11629 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11630 if (variablestore && varlist) {
11631 variablestore->data = varlist;
11632 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11633 AST_LIST_HEAD_INIT(varlist);
11634 ast_debug(1, "I can haz IAX vars? w00t\n");
11635 for (var = ies.vars; var; var = var->next) {
11636 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11637 if (prev)
11638 ast_free(prev);
11639 prev = var;
11640 if (!newvar) {
11641 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
11642 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11643 } else {
11644 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11645 }
11646 }
11647 if (prev)
11648 ast_free(prev);
11649 ies.vars = NULL;
11650 ast_channel_datastore_add(c, variablestore);
11651 } else {
11652 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11653 if (variablestore)
11654 ast_datastore_free(variablestore);
11655 if (varlist)
11656 ast_free(varlist);
11657 }
11658 }
11659 } else {
11660 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11661 /* If this is a TBD call, we're ready but now what... */
11662 ast_verb(3, "Accepted AUTHENTICATED TBD call from %s\n", ast_sockaddr_stringify(&addr));
11663 if (ast_test_flag64(iaxs[fr->callno], IAX_IMMEDIATE)) {
11664 goto immediatedial;
11665 }
11666 }
11667 }
11668 }
11669 break;
11670 case IAX_COMMAND_DIAL:
11671immediatedial:
11672 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD)) {
11673 ast_clear_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11674 ast_string_field_set(iaxs[fr->callno], exten, ies.called_number ? ies.called_number : "s");
11675 if (!ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num)) {
11676 if (authdebug)
11677 ast_log(LOG_WARNING, "Rejected dial attempt from %s, request '%s@%s' does not exist\n",
11678 ast_sockaddr_stringify(&addr),
11679 iaxs[fr->callno]->exten,
11680 iaxs[fr->callno]->context);
11681 memset(&ied0, 0, sizeof(ied0));
11682 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11683 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11684 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11685 if (!iaxs[fr->callno]) {
11686 break;
11687 }
11688 } else {
11689 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11690 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11691 ast_verb(3, "Accepting DIAL from %s, formats = %s\n",
11692 ast_sockaddr_stringify(&addr),
11693 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &cap_buf));
11694 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11695 send_command(iaxs[fr->callno], AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, 0, NULL, 0, -1);
11696 c = ast_iax2_new(fr->callno, AST_STATE_RING,
11697 iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
11698 NULL, NULL, 1);
11699 if (!c) {
11700 iax2_destroy(fr->callno);
11701 } else if (ies.vars) {
11702 struct ast_datastore *variablestore;
11703 struct ast_variable *var, *prev = NULL;
11704 AST_LIST_HEAD(, ast_var_t) *varlist;
11705 varlist = ast_calloc(1, sizeof(*varlist));
11706 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11707 ast_debug(1, "I can haz IAX vars? w00t\n");
11708 if (variablestore && varlist) {
11709 variablestore->data = varlist;
11710 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11711 AST_LIST_HEAD_INIT(varlist);
11712 for (var = ies.vars; var; var = var->next) {
11713 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11714 if (prev)
11715 ast_free(prev);
11716 prev = var;
11717 if (!newvar) {
11718 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
11719 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11720 } else {
11721 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11722 }
11723 }
11724 if (prev)
11725 ast_free(prev);
11726 ies.vars = NULL;
11727 ast_channel_datastore_add(c, variablestore);
11728 } else {
11729 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11730 if (variablestore)
11731 ast_datastore_free(variablestore);
11732 if (varlist)
11733 ast_free(varlist);
11734 }
11735 }
11736 }
11737 }
11738 break;
11739 case IAX_COMMAND_INVAL:
11740 iaxs[fr->callno]->error = ENOTCONN;
11741 ast_debug(1, "Immediately destroying %d, having received INVAL\n", fr->callno);
11742 iax2_destroy(fr->callno);
11743 ast_debug(1, "Destroying call %d\n", fr->callno);
11744 break;
11745 case IAX_COMMAND_VNAK:
11746 ast_debug(1, "Received VNAK: resending outstanding frames\n");
11747 /* Force retransmission */
11748 vnak_retransmit(fr->callno, fr->iseqno);
11749 break;
11750 case IAX_COMMAND_REGREQ:
11751 case IAX_COMMAND_REGREL:
11752 /* For security, always ack immediately */
11753 if (delayreject)
11754 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11755 if (register_verify(fr->callno, &addr, &ies)) {
11756 if (!iaxs[fr->callno]) {
11757 break;
11758 }
11759 /* Send delayed failure */
11760 auth_fail(fr->callno, IAX_COMMAND_REGREJ);
11761 break;
11762 }
11763 if (!iaxs[fr->callno]) {
11764 break;
11765 }
11766 if ((ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) ||
11767 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED)) {
11768
11769 if (f.subclass.integer == IAX_COMMAND_REGREL) {
11770 ast_sockaddr_setnull(&addr);
11771 }
11772 if (update_registry(&addr, fr->callno, ies.devicetype, fd, ies.refresh)) {
11773 ast_log(LOG_WARNING, "Registry error\n");
11774 }
11775 if (!iaxs[fr->callno]) {
11776 break;
11777 }
11778 if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
11779 ast_mutex_unlock(&iaxsl[fr->callno]);
11780 check_provisioning(&addr, fd, ies.serviceident, ies.provver);
11781 ast_mutex_lock(&iaxsl[fr->callno]);
11782 }
11783 break;
11784 }
11785 registry_authrequest(fr->callno);
11786 break;
11787 case IAX_COMMAND_REGACK:
11788 if (iax2_ack_registry(&ies, &addr, fr->callno)) {
11789 ast_log(LOG_WARNING, "Registration failure\n");
11790 }
11791 /* Send ack immediately, before we destroy */
11792 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11793 iax2_destroy(fr->callno);
11794 break;
11795 case IAX_COMMAND_REGREJ:
11796 if (iaxs[fr->callno]->reg) {
11797 if (authdebug) {
11798 ast_log(LOG_NOTICE, "Registration of '%s' rejected: '%s' from: '%s'\n",
11799 iaxs[fr->callno]->reg->username, ies.cause ? ies.cause : "<unknown>",
11800 ast_sockaddr_stringify(&addr));
11801 }
11802 iax2_publish_registry(iaxs[fr->callno]->reg->username, ast_sockaddr_stringify(&addr), "Rejected", S_OR(ies.cause, "<unknown>"));
11803 iaxs[fr->callno]->reg->regstate = REG_STATE_REJECTED;
11804 }
11805 /* Send ack immediately, before we destroy */
11806 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11807 iax2_destroy(fr->callno);
11808 break;
11809 case IAX_COMMAND_REGAUTH:
11810 /* Authentication request */
11811 if (registry_rerequest(&ies, fr->callno, &addr)) {
11812 memset(&ied0, 0, sizeof(ied0));
11813 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No authority found");
11814 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
11815 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11816 }
11817 break;
11818 case IAX_COMMAND_TXREJ:
11819 while (iaxs[fr->callno]
11820 && iaxs[fr->callno]->bridgecallno
11821 && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
11822 DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
11823 }
11824 if (!iaxs[fr->callno]) {
11825 break;
11826 }
11827
11828 iaxs[fr->callno]->transferring = TRANSFER_NONE;
11829 ast_verb(3, "Channel '%s' unable to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
11830 memset(&iaxs[fr->callno]->transfer, 0, sizeof(iaxs[fr->callno]->transfer));
11831
11832 if (!iaxs[fr->callno]->bridgecallno) {
11833 break;
11834 }
11835
11836 if (iaxs[iaxs[fr->callno]->bridgecallno]
11837 && iaxs[iaxs[fr->callno]->bridgecallno]->transferring) {
11838 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_NONE;
11839 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
11840 }
11841 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11842 break;
11843 case IAX_COMMAND_TXREADY:
11844 while (iaxs[fr->callno]
11845 && iaxs[fr->callno]->bridgecallno
11846 && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
11847 DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
11848 }
11849 if (!iaxs[fr->callno]) {
11850 break;
11851 }
11852
11853 if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
11854 iaxs[fr->callno]->transferring = TRANSFER_READY;
11855 } else if (iaxs[fr->callno]->transferring == TRANSFER_MBEGIN) {
11856 iaxs[fr->callno]->transferring = TRANSFER_MREADY;
11857 } else {
11858 if (iaxs[fr->callno]->bridgecallno) {
11859 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11860 }
11861 break;
11862 }
11863 ast_verb(3, "Channel '%s' ready to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
11864
11865 if (!iaxs[fr->callno]->bridgecallno) {
11866 break;
11867 }
11868
11869 if (!iaxs[iaxs[fr->callno]->bridgecallno]
11870 || (iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_READY
11871 && iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_MREADY)) {
11872 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11873 break;
11874 }
11875
11876 /* Both sides are ready */
11877
11878 /* XXX what isn't checked here is that both sides match transfer types. */
11879
11880 if (iaxs[fr->callno]->transferring == TRANSFER_MREADY) {
11881 ast_verb(3, "Attempting media bridge of %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
11882 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
11883
11884 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_MEDIA;
11885 iaxs[fr->callno]->transferring = TRANSFER_MEDIA;
11886
11887 memset(&ied0, 0, sizeof(ied0));
11888 memset(&ied1, 0, sizeof(ied1));
11889 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11890 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11891 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied0.buf, ied0.pos, -1);
11892 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied1.buf, ied1.pos, -1);
11893 } else {
11894 ast_verb(3, "Releasing %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
11895 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
11896
11897 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_RELEASED;
11898 iaxs[fr->callno]->transferring = TRANSFER_RELEASED;
11899 ast_set_flag64(iaxs[iaxs[fr->callno]->bridgecallno], IAX_ALREADYGONE);
11900 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11901
11902 /* Stop doing lag & ping requests */
11903 stop_stuff(fr->callno);
11904 stop_stuff(iaxs[fr->callno]->bridgecallno);
11905
11906 memset(&ied0, 0, sizeof(ied0));
11907 memset(&ied1, 0, sizeof(ied1));
11908 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11909 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11910 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied0.buf, ied0.pos, -1);
11911 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied1.buf, ied1.pos, -1);
11912 }
11913 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11914 break;
11915 case IAX_COMMAND_TXREQ:
11916 try_transfer(iaxs[fr->callno], &ies);
11917 break;
11918 case IAX_COMMAND_TXCNT:
11919 if (iaxs[fr->callno]->transferring)
11920 send_command_transfer(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, NULL, 0);
11921 break;
11922 case IAX_COMMAND_TXREL:
11923 /* Send ack immediately, rather than waiting until we've changed addresses */
11924 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11925 complete_transfer(fr->callno, &ies);
11926 stop_stuff(fr->callno); /* for attended transfer to work with libiax */
11927 break;
11928 case IAX_COMMAND_TXMEDIA:
11929 if (iaxs[fr->callno]->transferring == TRANSFER_READY) {
11930 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
11931 /* Cancel any outstanding frames and start anew */
11932 if (cur->transfer) {
11933 cur->retries = -1;
11934 }
11935 }
11936 /* Start sending our media to the transfer address, but otherwise leave the call as-is */
11937 iaxs[fr->callno]->transferring = TRANSFER_MEDIAPASS;
11938 }
11939 break;
11940 case IAX_COMMAND_RTKEY:
11941 if (!IAX_CALLENCRYPTED(iaxs[fr->callno])) {
11942 ast_log(LOG_WARNING,
11943 "we've been told to rotate our encryption key, "
11944 "but this isn't an encrypted call. bad things will happen.\n"
11945 );
11946 break;
11947 }
11948
11949 IAX_DEBUGDIGEST("Receiving", ies.challenge);
11950
11951 ast_aes_set_decrypt_key((unsigned char *) ies.challenge, &iaxs[fr->callno]->dcx);
11952 break;
11953 case IAX_COMMAND_DPREP:
11954 complete_dpreply(iaxs[fr->callno], &ies);
11955 break;
11956 case IAX_COMMAND_UNSUPPORT:
11957 ast_log(LOG_NOTICE, "Peer did not understand our iax command '%d'\n", ies.iax_unknown);
11958 break;
11959 case IAX_COMMAND_FWDOWNL:
11960 /* Firmware download */
11961 if (!ast_test_flag64(&globalflags, IAX_ALLOWFWDOWNLOAD)) {
11962 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, NULL, 0, -1);
11963 break;
11964 }
11965 memset(&ied0, 0, sizeof(ied0));
11966 res = iax_firmware_append(&ied0, ies.devicetype, ies.fwdesc);
11967 if (res < 0)
11968 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11969 else if (res > 0)
11970 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11971 else
11972 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11973 break;
11974 case IAX_COMMAND_CALLTOKEN:
11975 {
11976 struct iax_frame *cur;
11977 /* find last sent frame */
11978 if ((cur = AST_LIST_LAST(&frame_queue[fr->callno])) && ies.calltoken && ies.calltokendata) {
11979 resend_with_token(fr->callno, cur, (char *) ies.calltokendata);
11980 }
11981 break;
11982 }
11983 default:
11984 ast_debug(1, "Unknown IAX command %d on %d/%d\n", f.subclass.integer, fr->callno, iaxs[fr->callno]->peercallno);
11985 memset(&ied0, 0, sizeof(ied0));
11986 iax_ie_append_byte(&ied0, IAX_IE_IAX_UNKNOWN, f.subclass.integer);
11987 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, ied0.buf, ied0.pos, -1);
11988 }
11989 /* Free remote variables (if any) */
11990 if (ies.vars) {
11991 ast_variables_destroy(ies.vars);
11992 ast_debug(1, "I can haz IAX vars, but they is no good :-(\n");
11993 ies.vars = NULL;
11994 }
11995
11996 /* Don't actually pass these frames along */
11997 if ((f.subclass.integer != IAX_COMMAND_ACK) &&
11998 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
11999 (f.subclass.integer != IAX_COMMAND_TXACC) &&
12000 (f.subclass.integer != IAX_COMMAND_INVAL) &&
12001 (f.subclass.integer != IAX_COMMAND_VNAK)) {
12002 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno) {
12003 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
12004 }
12005 }
12006 ast_mutex_unlock(&iaxsl[fr->callno]);
12007 return 1;
12008 }
12009 /* Unless this is an ACK or INVAL frame, ack it */
12010 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno)
12011 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
12012 } else if (minivid) {
12013 f.frametype = AST_FRAME_VIDEO;
12014 if (iaxs[fr->callno]->videoformat > 0) {
12015 if (ntohs(vh->ts) & 0x8000LL) {
12016 f.subclass.frame_ending = 1;
12017 }
12018 f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->videoformat);
12019 if (!f.subclass.format) {
12020 ast_variables_destroy(ies.vars);
12021 ast_mutex_unlock(&iaxsl[fr->callno]);
12022 return 1;
12023 }
12024 } else {
12025 ast_log(LOG_WARNING, "Received mini frame before first full video frame\n");
12026 iax2_vnak(fr->callno);
12027 ast_variables_destroy(ies.vars);
12028 ast_mutex_unlock(&iaxsl[fr->callno]);
12029 return 1;
12030 }
12031 f.datalen = res - sizeof(*vh);
12032 if (f.datalen < 0) {
12033 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12034 ast_variables_destroy(ies.vars);
12035 ast_mutex_unlock(&iaxsl[fr->callno]);
12036 return 1;
12037 }
12038 if (f.datalen)
12039 f.data.ptr = thread->buf + sizeof(*vh);
12040 else
12041 f.data.ptr = NULL;
12042#ifdef IAXTESTS
12043 if (test_resync) {
12044 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
12045 } else
12046#endif /* IAXTESTS */
12047 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | (ntohs(vh->ts) & 0x7fff);
12048 } else {
12049 /* A mini frame */
12050 f.frametype = AST_FRAME_VOICE;
12051 if (iaxs[fr->callno]->voiceformat > 0) {
12052 f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->voiceformat);
12053 if (!f.subclass.format) {
12054 ast_variables_destroy(ies.vars);
12055 ast_mutex_unlock(&iaxsl[fr->callno]);
12056 return 1;
12057 }
12058 } else {
12059 ast_debug(1, "Received mini frame before first full voice frame\n");
12060 iax2_vnak(fr->callno);
12061 ast_variables_destroy(ies.vars);
12062 ast_mutex_unlock(&iaxsl[fr->callno]);
12063 return 1;
12064 }
12065 f.datalen = res - sizeof(struct ast_iax2_mini_hdr);
12066 if (f.datalen < 0) {
12067 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12068 ast_variables_destroy(ies.vars);
12069 ast_mutex_unlock(&iaxsl[fr->callno]);
12070 return 1;
12071 }
12072 if (f.datalen)
12073 f.data.ptr = thread->buf + sizeof(*mh);
12074 else
12075 f.data.ptr = NULL;
12076#ifdef IAXTESTS
12077 if (test_resync) {
12078 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
12079 } else
12080#endif /* IAXTESTS */
12081 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
12082 /* FIXME? Surely right here would be the right place to undo timestamp wraparound? */
12083 }
12084
12085 /* Don't pass any packets until we're started */
12086 if (!iaxs[fr->callno]
12087 || !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
12088 ast_variables_destroy(ies.vars);
12089 ast_mutex_unlock(&iaxsl[fr->callno]);
12090 return 1;
12091 }
12092
12093 if (f.frametype == AST_FRAME_CONTROL) {
12094 if (!iax2_is_control_frame_allowed(f.subclass.integer)) {
12095 /* Control frame not allowed to come from the wire. */
12096 ast_debug(2, "Callno %d: Blocked receiving control frame %d.\n",
12097 fr->callno, f.subclass.integer);
12098 ast_variables_destroy(ies.vars);
12099 ast_mutex_unlock(&iaxsl[fr->callno]);
12100 return 1;
12101 }
12102 if (f.subclass.integer == AST_CONTROL_CONNECTED_LINE
12103 || f.subclass.integer == AST_CONTROL_REDIRECTING) {
12104 if (iaxs[fr->callno]
12105 && !ast_test_flag64(iaxs[fr->callno], IAX_RECVCONNECTEDLINE)) {
12106 /* We are not configured to allow receiving these updates. */
12107 ast_debug(2, "Callno %d: Config blocked receiving control frame %d.\n",
12108 fr->callno, f.subclass.integer);
12109 ast_variables_destroy(ies.vars);
12110 ast_mutex_unlock(&iaxsl[fr->callno]);
12111 return 1;
12112 }
12113 }
12114
12115 iax2_lock_owner(fr->callno);
12116 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
12117 if (f.subclass.integer == AST_CONTROL_BUSY) {
12118 ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_BUSY);
12119 } else if (f.subclass.integer == AST_CONTROL_CONGESTION) {
12120 ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_CONGESTION);
12121 }
12122 ast_channel_unlock(iaxs[fr->callno]->owner);
12123 }
12124 }
12125
12126 if (f.frametype == AST_FRAME_CONTROL
12127 && f.subclass.integer == AST_CONTROL_CONNECTED_LINE
12128 && iaxs[fr->callno]) {
12129 struct ast_party_connected_line connected;
12130
12131 /*
12132 * Process a received connected line update.
12133 *
12134 * Initialize defaults.
12135 */
12136 ast_party_connected_line_init(&connected);
12137 connected.id.number.presentation = iaxs[fr->callno]->calling_pres;
12138 connected.id.name.presentation = iaxs[fr->callno]->calling_pres;
12139
12140 if (!ast_connected_line_parse_data(f.data.ptr, f.datalen, &connected)) {
12141 ast_string_field_set(iaxs[fr->callno], cid_num, connected.id.number.str);
12142 ast_string_field_set(iaxs[fr->callno], cid_name, connected.id.name.str);
12143 iaxs[fr->callno]->calling_pres = ast_party_id_presentation(&connected.id);
12144
12145 iax2_lock_owner(fr->callno);
12146 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
12147 ast_set_callerid(iaxs[fr->callno]->owner,
12148 S_COR(connected.id.number.valid, connected.id.number.str, ""),
12149 S_COR(connected.id.name.valid, connected.id.name.str, ""),
12150 NULL);
12151 ast_channel_caller(iaxs[fr->callno]->owner)->id.number.presentation = connected.id.number.presentation;
12152 ast_channel_caller(iaxs[fr->callno]->owner)->id.name.presentation = connected.id.name.presentation;
12153 ast_channel_unlock(iaxs[fr->callno]->owner);
12154 }
12155 }
12156 ast_party_connected_line_free(&connected);
12157 }
12158
12159 /* Common things */
12160 f.src = "IAX2";
12161 f.mallocd = 0;
12162 f.offset = 0;
12163 f.len = 0;
12164 if (f.datalen && (f.frametype == AST_FRAME_VOICE)) {
12165 f.samples = ast_codec_samples_count(&f);
12166 /* We need to byteswap incoming slinear samples from network byte order */
12167 if (ast_format_cmp(f.subclass.format, ast_format_slin) == AST_FORMAT_CMP_EQUAL)
12168 ast_frame_byteswap_be(&f);
12169 } else
12170 f.samples = 0;
12171
12172 if (f.datalen < 0) {
12173 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12174 ast_variables_destroy(ies.vars);
12175 ast_mutex_unlock(&iaxsl[fr->callno]);
12176 return 1;
12177 }
12178
12179 iax_frame_wrap(fr, &f);
12180
12181 /* If this is our most recent packet, use it as our basis for timestamping */
12182 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
12183 /*iaxs[fr->callno]->last = fr->ts; (do it afterwards cos schedule/forward_delivery needs the last ts too)*/
12184 fr->outoforder = 0;
12185 } else {
12186 if (iaxdebug && iaxs[fr->callno]) {
12187 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);
12188 }
12189 fr->outoforder = 1;
12190 }
12191 fr->cacheable = ((f.frametype == AST_FRAME_VOICE) || (f.frametype == AST_FRAME_VIDEO));
12192 if (iaxs[fr->callno]) {
12193 duped_fr = iaxfrdup2(fr);
12194 if (duped_fr) {
12195 schedule_delivery(duped_fr, updatehistory, 0, &fr->ts);
12196 }
12197 }
12198 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
12199 iaxs[fr->callno]->last = fr->ts;
12200#if 1
12201 if (iaxdebug)
12202 ast_debug(8, "For call=%d, set last=%u\n", fr->callno, fr->ts);
12203#endif
12204 }
12205
12206 /* Always run again */
12207 ast_variables_destroy(ies.vars);
12208 ast_mutex_unlock(&iaxsl[fr->callno]);
12209 return 1;
12210}
12211
12212static int socket_process(struct iax2_thread *thread)
12213{
12214 int res = socket_process_helper(thread);
12215 if (ast_read_threadstorage_callid()) {
12216 ast_callid_threadassoc_remove();
12217 }
12218 return res;
12219}
12220
12221/* Function to clean up process thread if it is cancelled */
12222static void iax2_process_thread_cleanup(void *data)
12223{
12224 struct iax2_thread *thread = data;
12225 ast_mutex_destroy(&thread->lock);
12226 ast_cond_destroy(&thread->cond);
12227 ast_mutex_destroy(&thread->init_lock);
12228 ast_cond_destroy(&thread->init_cond);
12229 ast_free(thread);
12230 /* Ignore check_return warning from Coverity for ast_atomic_dec_and_test below */
12231 ast_atomic_dec_and_test(&iaxactivethreadcount);
12232}
12233
12234static void *iax2_process_thread(void *data)
12235{
12236 struct iax2_thread *thread = data;
12237 struct timeval wait;
12238 struct timespec ts;
12239 int put_into_idle = 0;
12240 int first_time = 1;
12241 int old_state;
12242
12243 ast_atomic_fetchadd_int(&iaxactivethreadcount, 1);
12244
12245 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
12246 pthread_cleanup_push(iax2_process_thread_cleanup, data);
12247
12248 for (;;) {
12249 /* Wait for something to signal us to be awake */
12250 ast_mutex_lock(&thread->lock);
12251
12252 if (thread->stop) {
12253 ast_mutex_unlock(&thread->lock);
12254 break;
12255 }
12256
12257 /* Flag that we're ready to accept signals */
12258 if (first_time) {
12259 signal_condition(&thread->init_lock, &thread->init_cond);
12260 first_time = 0;
12261 }
12262
12263 /* Put into idle list if applicable */
12264 if (put_into_idle) {
12265 insert_idle_thread(thread);
12266 }
12267
12268 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
12269 struct iax2_thread *t = NULL;
12270 /* Wait to be signalled or time out */
12271 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
12272 ts.tv_sec = wait.tv_sec;
12273 ts.tv_nsec = wait.tv_usec * 1000;
12274 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
12275 /* This thread was never put back into the available dynamic
12276 * thread list, so just go away. */
12277 if (!put_into_idle || thread->stop) {
12278 ast_mutex_unlock(&thread->lock);
12279 break;
12280 }
12281 AST_LIST_LOCK(&dynamic_list);
12282 /* Account for the case where this thread is acquired *right* after a timeout */
12283 if ((t = AST_LIST_REMOVE(&dynamic_list, thread, list)))
12284 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, -1);
12285 AST_LIST_UNLOCK(&dynamic_list);
12286 if (t) {
12287 /* This dynamic thread timed out waiting for a task and was
12288 * not acquired immediately after the timeout,
12289 * so it's time to go away. */
12290 ast_mutex_unlock(&thread->lock);
12291 break;
12292 }
12293 /* Someone grabbed our thread *right* after we timed out.
12294 * Wait for them to set us up with something to do and signal
12295 * us to continue. */
12296 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
12297 ts.tv_sec = wait.tv_sec;
12298 ts.tv_nsec = wait.tv_usec * 1000;
12299 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
12300 ast_mutex_unlock(&thread->lock);
12301 break;
12302 }
12303 }
12304 } else {
12305 ast_cond_wait(&thread->cond, &thread->lock);
12306 }
12307
12308 /* Go back into our respective list */
12309 put_into_idle = 1;
12310
12311 ast_mutex_unlock(&thread->lock);
12312
12313 if (thread->stop) {
12314 break;
12315 }
12316
12317 /* See what we need to do */
12318 switch (thread->iostate) {
12319 case IAX_IOSTATE_IDLE:
12320 continue;
12321 case IAX_IOSTATE_READY:
12322 thread->actions++;
12323 thread->iostate = IAX_IOSTATE_PROCESSING;
12324 socket_process(thread);
12325 handle_deferred_full_frames(thread);
12326 break;
12327 case IAX_IOSTATE_SCHEDREADY:
12328 thread->actions++;
12329 thread->iostate = IAX_IOSTATE_PROCESSING;
12330#ifdef SCHED_MULTITHREADED
12331 thread->schedfunc(thread->scheddata);
12332#endif
12333 break;
12334 default:
12335 break;
12336 }
12337
12338 /* The network thread added us to the active_thread list when we were given
12339 * frames to process, Now that we are done, we must remove ourselves from
12340 * the active list, and return to the idle list */
12341 AST_LIST_LOCK(&active_list);
12342 AST_LIST_REMOVE(&active_list, thread, list);
12343 AST_LIST_UNLOCK(&active_list);
12344
12345 /* Make sure another frame didn't sneak in there after we thought we were done. */
12346 handle_deferred_full_frames(thread);
12347
12348 time(&thread->checktime);
12349 thread->iostate = IAX_IOSTATE_IDLE;
12350#ifdef DEBUG_SCHED_MULTITHREAD
12351 thread->curfunc[0]='\0';
12352#endif
12353 }
12354
12355 /*!
12356 * \note For some reason, idle threads are exiting without being
12357 * removed from an idle list, which is causing memory
12358 * corruption. Forcibly remove it from the list, if it's there.
12359 */
12360 AST_LIST_LOCK(&idle_list);
12361 AST_LIST_REMOVE(&idle_list, thread, list);
12362 AST_LIST_UNLOCK(&idle_list);
12363
12364 AST_LIST_LOCK(&dynamic_list);
12365 AST_LIST_REMOVE(&dynamic_list, thread, list);
12366 AST_LIST_UNLOCK(&dynamic_list);
12367
12368 if (!thread->stop) {
12369 /* Nobody asked me to stop so nobody is waiting to join me. */
12370 pthread_detach(pthread_self());
12371 }
12372
12373 /* I am exiting here on my own volition, I need to clean up my own data structures
12374 * Assume that I am no longer in any of the lists (idle, active, or dynamic)
12375 */
12376 pthread_cleanup_pop(1);
12377 return NULL;
12378}
12379
12380static int iax2_do_register(struct iax2_registry *reg)
12381{
12382 struct iax_ie_data ied;
12383 if (iaxdebug)
12384 ast_debug(1, "Sending registration request for '%s'\n", reg->username);
12385
12386 if (reg->dnsmgr &&
12387 ((reg->regstate == REG_STATE_TIMEOUT) || ast_sockaddr_isnull(&reg->addr))) {
12388 /* Maybe the IP has changed, force DNS refresh */
12389 ast_dnsmgr_refresh(reg->dnsmgr);
12390 }
12391
12392 /*
12393 * if IP has Changed, free allocated call to create a new one with new IP
12394 * call has the pointer to IP and must be updated to the new one
12395 */
12396 if (reg->dnsmgr && ast_dnsmgr_changed(reg->dnsmgr) && (reg->callno > 0)) {
12397 int callno = reg->callno;
12398 ast_mutex_lock(&iaxsl[callno]);
12399 iax2_destroy(callno);
12400 ast_mutex_unlock(&iaxsl[callno]);
12401 reg->callno = 0;
12402 }
12403 if (ast_sockaddr_isnull(&reg->addr)) {
12404 if (iaxdebug)
12405 ast_debug(1, "Unable to send registration request for '%s' without IP address\n", reg->username);
12406 /* Setup the next registration attempt */
12407 reg->expire = iax2_sched_replace(reg->expire, sched,
12408 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
12409 return -1;
12410 }
12411 if (!ast_sockaddr_port(&reg->addr) && reg->port) {
12412 ast_sockaddr_set_port(&reg->addr, reg->port);
12413 }
12414
12415 if (!reg->callno) {
12416
12417 ast_debug(3, "Allocate call number\n");
12418
12419 reg->callno = find_callno_locked(0, 0, &reg->addr, NEW_FORCE, defaultsockfd, 0);
12420 if (reg->callno < 1) {
12421 ast_log(LOG_WARNING, "Unable to create call for registration\n");
12422 return -1;
12423 } else
12424 ast_debug(3, "Registration created on call %d\n", reg->callno);
12425 iaxs[reg->callno]->reg = reg;
12426 ast_mutex_unlock(&iaxsl[reg->callno]);
12427 }
12428 /* Setup the next registration a little early */
12429 reg->expire = iax2_sched_replace(reg->expire, sched,
12430 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
12431 /* Send the request */
12432 memset(&ied, 0, sizeof(ied));
12433 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
12434 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
12435 add_empty_calltoken_ie(iaxs[reg->callno], &ied); /* this _MUST_ be the last ie added */
12436 send_command(iaxs[reg->callno],AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
12437 reg->regstate = REG_STATE_REGSENT;
12438 return 0;
12439}
12440
12441static int iax2_provision(struct ast_sockaddr *end, int sockfd, const char *dest, const char *template, int force)
12442{
12443 /* Returns 1 if provisioned, -1 if not able to find destination, or 0 if no provisioning
12444 is found for template */
12445 struct iax_ie_data provdata;
12446 struct iax_ie_data ied;
12447 unsigned int sig;
12448 struct ast_sockaddr addr;
12449 int callno;
12450 struct create_addr_info cai;
12451
12452 memset(&cai, 0, sizeof(cai));
12453
12454 ast_debug(1, "Provisioning '%s' from template '%s'\n", dest, template);
12455
12456 if (iax_provision_build(&provdata, &sig, template, force)) {
12457 ast_debug(1, "No provisioning found for template '%s'\n", template);
12458 return 0;
12459 }
12460
12461 if (end) {
12462 ast_sockaddr_copy(&addr, end);
12463 cai.sockfd = sockfd;
12464 } else if (create_addr(dest, NULL, &addr, &cai))
12465 return -1;
12466
12467 /* Build the rest of the message */
12468 memset(&ied, 0, sizeof(ied));
12469 iax_ie_append_raw(&ied, IAX_IE_PROVISIONING, provdata.buf, provdata.pos);
12470
12471 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
12472 if (!callno)
12473 return -1;
12474
12475 if (iaxs[callno]) {
12476 /* Schedule autodestruct in case they don't ever give us anything back */
12477 iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
12478 sched, 15000, auto_hangup, (void *)(long)callno);
12479 ast_set_flag64(iaxs[callno], IAX_PROVISION);
12480 /* Got a call number now, so go ahead and send the provisioning information */
12481 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PROVISION, 0, ied.buf, ied.pos, -1);
12482 }
12483 ast_mutex_unlock(&iaxsl[callno]);
12484
12485 return 1;
12486}
12487
12488static char *papp = "IAX2Provision";
12489
12490/*! iax2provision
12491\ingroup applications
12492*/
12493static int iax2_prov_app(struct ast_channel *chan, const char *data)
12494{
12495 int res;
12496 char *sdata;
12497 char *opts;
12498 int force =0;
12499 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
12500 if (ast_strlen_zero(data))
12501 data = "default";
12502 sdata = ast_strdupa(data);
12503 opts = strchr(sdata, '|');
12504 if (opts)
12505 *opts='\0';
12506
12507 if (ast_channel_tech(chan) != &iax2_tech) {
12508 ast_log(LOG_NOTICE, "Can't provision a non-IAX device!\n");
12509 return -1;
12510 }
12511 if (!callno || !iaxs[callno] || ast_sockaddr_isnull(&iaxs[callno]->addr)) {
12512 ast_log(LOG_NOTICE, "Can't provision something with no IP?\n");
12513 return -1;
12514 }
12515 res = iax2_provision(&iaxs[callno]->addr, iaxs[callno]->sockfd, NULL, sdata, force);
12516 ast_verb(3, "Provisioned IAXY at '%s' with '%s'= %d\n",
12517 ast_sockaddr_stringify(&iaxs[callno]->addr),
12518 sdata, res);
12519 return res;
12520}
12521
12522static char *handle_cli_iax2_provision(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
12523{
12524 int force = 0;
12525 int res;
12526
12527 switch (cmd) {
12528 case CLI_INIT:
12529 e->command = "iax2 provision";
12530 e->usage =
12531 "Usage: iax2 provision <host> <template> [forced]\n"
12532 " Provisions the given peer or IP address using a template\n"
12533 " matching either 'template' or '*' if the template is not\n"
12534 " found. If 'forced' is specified, even empty provisioning\n"
12535 " fields will be provisioned as empty fields.\n";
12536 return NULL;
12537 case CLI_GENERATE:
12538 if (a->pos == 3)
12539 return iax_prov_complete_template(a->line, a->word, a->pos, a->n);
12540 return NULL;
12541 }
12542
12543 if (a->argc < 4)
12544 return CLI_SHOWUSAGE;
12545 if (a->argc > 4) {
12546 if (!strcasecmp(a->argv[4], "forced"))
12547 force = 1;
12548 else
12549 return CLI_SHOWUSAGE;
12550 }
12551 res = iax2_provision(NULL, -1, a->argv[2], a->argv[3], force);
12552 if (res < 0)
12553 ast_cli(a->fd, "Unable to find peer/address '%s'\n", a->argv[2]);
12554 else if (res < 1)
12555 ast_cli(a->fd, "No template (including wildcard) matching '%s'\n", a->argv[3]);
12556 else
12557 ast_cli(a->fd, "Provisioning '%s' with template '%s'%s\n", a->argv[2], a->argv[3], force ? ", forced" : "");
12558 return CLI_SUCCESS;
12559}
12560
12561static void __iax2_poke_noanswer(const void *data)
12562{
12563 struct iax2_peer *peer = (struct iax2_peer *)data;
12564 int callno;
12565
12566 if (peer->lastms > -1) {
12567 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
12568
12569 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Time: %d\n", peer->name, peer->lastms);
12570 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
12571 blob = ast_json_pack("{s: s, s: i}",
12572 "peer_status", "Unreachable",
12573 "time", peer->lastms);
12574 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
12575 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
12576 }
12577 if ((callno = peer->callno) > 0) {
12578 ast_mutex_lock(&iaxsl[callno]);
12579 iax2_destroy(callno);
12580 ast_mutex_unlock(&iaxsl[callno]);
12581 }
12582 peer->callno = 0;
12583 peer->lastms = -1;
12584 /* Try again quickly */
12585 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
12586 if (peer->pokeexpire == -1)
12587 peer_unref(peer);
12588}
12589
12590static int iax2_poke_noanswer(const void *data)
12591{
12592 struct iax2_peer *peer = (struct iax2_peer *)data;
12593 peer->pokeexpire = -1;
12594#ifdef SCHED_MULTITHREADED
12595 if (schedule_action(__iax2_poke_noanswer, data))
12596#endif
12597 __iax2_poke_noanswer(data);
12598 peer_unref(peer);
12599 return 0;
12600}
12601
12602static int iax2_poke_peer_cb(void *obj, void *arg, int flags)
12603{
12604 struct iax2_peer *peer = obj;
12605
12606 iax2_poke_peer(peer, 0);
12607
12608 return 0;
12609}
12610
12611static int iax2_poke_peer(struct iax2_peer *peer, int heldcall)
12612{
12613 int callno;
12614 int poke_timeout;
12615
12616 if (!peer->maxms || (ast_sockaddr_isnull(&peer->addr) && !peer->dnsmgr)) {
12617 /* IF we have no IP without dnsmgr, or this isn't to be monitored, return
12618 immediately after clearing things out */
12619 peer->lastms = 0;
12620 peer->historicms = 0;
12621 peer->pokeexpire = -1;
12622 peer->callno = 0;
12623 return 0;
12624 }
12625
12626 /* The peer could change the callno inside iax2_destroy, since we do deadlock avoidance */
12627 if ((callno = peer->callno) > 0) {
12628 ast_log(LOG_NOTICE, "Still have a callno...\n");
12629 ast_mutex_lock(&iaxsl[callno]);
12630 iax2_destroy(callno);
12631 ast_mutex_unlock(&iaxsl[callno]);
12632 }
12633 if (heldcall)
12634 ast_mutex_unlock(&iaxsl[heldcall]);
12635 callno = peer->callno = find_callno(0, 0, &peer->addr, NEW_FORCE, peer->sockfd, 0);
12636 if (heldcall)
12637 ast_mutex_lock(&iaxsl[heldcall]);
12638 if (callno < 1) {
12639 ast_log(LOG_WARNING, "Unable to allocate call for poking peer '%s'\n", peer->name);
12640 return -1;
12641 }
12642
12643 if (peer->pokeexpire > -1) {
12644 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
12645 peer->pokeexpire = -1;
12646 peer_unref(peer);
12647 }
12648 }
12649
12650 if (peer->lastms < 0){
12651 /* If the host is already unreachable then use time less than the unreachable
12652 * interval. 5/6 is arbitrary multiplier to get value less than
12653 * peer->pokefreqnotok. Value less than peer->pokefreqnotok is used to expire
12654 * current POKE before starting new POKE (which is scheduled after
12655 * peer->pokefreqnotok). */
12656 poke_timeout = peer->pokefreqnotok * 5 / 6;
12657 } else {
12658 /* If the host is reachable, use timeout large enough to allow for multiple
12659 * POKE retries. Limit this value to less than peer->pokefreqok. 5/6 is arbitrary
12660 * multiplier to get value less than peer->pokefreqok. Value less than
12661 * peer->pokefreqok is used to expire current POKE before starting new POKE
12662 * (which is scheduled after peer->pokefreqok). */
12663 poke_timeout = MIN(MAX_RETRY_TIME * 2 + peer->maxms, peer->pokefreqok * 5 / 6);
12664 }
12665
12666 /* Queue up a new task to handle no reply */
12667 peer->pokeexpire = iax2_sched_add(sched, poke_timeout, iax2_poke_noanswer, peer_ref(peer));
12668
12669 if (peer->pokeexpire == -1)
12670 peer_unref(peer);
12671
12672 /* And send the poke */
12673 ast_mutex_lock(&iaxsl[callno]);
12674 if (iaxs[callno]) {
12675 struct iax_ie_data ied = {
12676 .buf = { 0 },
12677 .pos = 0,
12678 };
12679
12680 /* Speed up retransmission times for this qualify call */
12681 iaxs[callno]->pingtime = peer->maxms / 8;
12682 iaxs[callno]->peerpoke = peer;
12683
12684 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
12685 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_POKE, 0, ied.buf, ied.pos, -1);
12686 }
12687 ast_mutex_unlock(&iaxsl[callno]);
12688
12689 return 0;
12690}
12691
12692static void free_context(struct iax2_context *con)
12693{
12694 struct iax2_context *conl;
12695 while(con) {
12696 conl = con;
12697 con = con->next;
12698 ast_free(conl);
12699 }
12700}
12701
12702static 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)
12703{
12704 int callno;
12705 int res;
12706 struct ast_sockaddr addr;
12707 struct ast_channel *c;
12708 struct parsed_dial_string pds;
12709 struct create_addr_info cai;
12710 char *tmpstr;
12711 ast_callid callid;
12712
12713 memset(&pds, 0, sizeof(pds));
12714 tmpstr = ast_strdupa(data);
12715 parse_dial_string(tmpstr, &pds);
12716
12717 callid = ast_read_threadstorage_callid();
12718
12719 if (ast_strlen_zero(pds.peer)) {
12720 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
12721 return NULL;
12722 }
12723 memset(&cai, 0, sizeof(cai));
12724 cai.capability = iax2_capability;
12725
12726 ast_copy_flags64(&cai, &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12727
12728 /* Populate our address from the given */
12729 if (create_addr(pds.peer, NULL, &addr, &cai)) {
12730 *cause = AST_CAUSE_UNREGISTERED;
12731 return NULL;
12732 }
12733
12734 if (pds.port) {
12735 int bindport;
12736 ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535);
12737 ast_sockaddr_set_port(&addr, bindport);
12738 }
12739
12740 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
12741 if (callno < 1) {
12742 ast_log(LOG_WARNING, "Unable to create call\n");
12743 *cause = AST_CAUSE_CONGESTION;
12744 return NULL;
12745 }
12746
12747 /* If this is a trunk, update it now */
12748 ast_copy_flags64(iaxs[callno], &cai, IAX_TRUNK | IAX_SENDANI | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12749 if (ast_test_flag64(&cai, IAX_TRUNK)) {
12750 int new_callno;
12751 if ((new_callno = make_trunk(callno, 1)) != -1)
12752 callno = new_callno;
12753 }
12754 iaxs[callno]->maxtime = cai.maxtime;
12755 if (callid) {
12756 iax_pvt_callid_set(callno, callid);
12757 }
12758
12759 if (cai.found) {
12760 ast_string_field_set(iaxs[callno], host, pds.peer);
12761 }
12762
12763 c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, &cai.prefs, assignedids,
12764 requestor, cai.found);
12765
12766 ast_mutex_unlock(&iaxsl[callno]);
12767
12768 if (c) {
12769 struct ast_format_cap *joint;
12770 struct ast_format *format;
12771 if (callid) {
12772 ast_channel_lock(c);
12773 ast_channel_callid_set(c, callid);
12774 ast_channel_unlock(c);
12775 }
12776
12777 joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
12778 if (!joint) {
12779 ast_hangup(c);
12780 return NULL;
12781 }
12782
12783 ast_format_cap_get_compatible(ast_channel_nativeformats(c), cap, joint);
12784
12785 /* If there is no joint format find one through translation */
12786 if (!ast_format_cap_count(joint)) {
12787 struct ast_format *best_fmt_cap = NULL;
12788 struct ast_format *best_fmt_native = NULL;
12789
12790 res = ast_translator_best_choice(cap, ast_channel_nativeformats(c), &best_fmt_cap, &best_fmt_native);
12791 if (res < 0) {
12792 struct ast_str *native_cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
12793 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
12794
12795 ast_log(LOG_WARNING, "Unable to create translator path for %s to %s on %s\n",
12796 ast_format_cap_get_names(ast_channel_nativeformats(c), &native_cap_buf),
12797 ast_format_cap_get_names(cap, &cap_buf),
12798 ast_channel_name(c));
12799 ast_hangup(c);
12800 ao2_ref(joint, -1);
12801 return NULL;
12802 }
12803 ast_format_cap_append(joint, best_fmt_native, 0);
12804 ao2_ref(best_fmt_cap, -1);
12805 ao2_ref(best_fmt_native, -1);
12806 }
12807 ast_channel_nativeformats_set(c, joint);
12808 format = ast_format_cap_get_format(ast_channel_nativeformats(c), 0);
12809 ast_channel_set_readformat(c, format);
12810 ast_channel_set_writeformat(c, format);
12811
12812 ao2_ref(joint, -1);
12813 ao2_ref(format, -1);
12814 }
12815
12816 return c;
12817}
12818
12819static void *network_thread(void *ignore)
12820{
12821 int res;
12822
12823 if (timer) {
12824 ast_io_add(io, ast_timer_fd(timer), timing_read, AST_IO_IN | AST_IO_PRI, NULL);
12825 }
12826
12827 for (;;) {
12828 pthread_testcancel();
12829 /* Wake up once a second just in case SIGURG was sent while
12830 * we weren't in poll(), to make sure we don't hang when trying
12831 * to unload. */
12832 res = ast_io_wait(io, 1000);
12833 /* Timeout(=0), and EINTR is not a thread exit condition. We do
12834 * not want to exit the thread loop on these conditions. */
12835 if (res < 0 && errno != -EINTR) {
12836 ast_log(LOG_ERROR, "IAX2 network thread unexpected exit: %s\n", strerror(errno));
12837 break;
12838 }
12839 }
12840
12841 return NULL;
12842}
12843
12844static int start_network_thread(void)
12845{
12846 struct iax2_thread *thread;
12847 int threadcount = 0;
12848 int x;
12849 for (x = 0; x < iaxthreadcount; x++) {
12850 thread = ast_calloc(1, sizeof(*thread));
12851 if (thread) {
12852 thread->type = IAX_THREAD_TYPE_POOL;
12853 thread->threadnum = ++threadcount;
12854 ast_mutex_init(&thread->lock);
12855 ast_cond_init(&thread->cond, NULL);
12856 ast_mutex_init(&thread->init_lock);
12857 ast_cond_init(&thread->init_cond, NULL);
12858
12859 ast_mutex_lock(&thread->init_lock);
12860
12861 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
12862 ast_log(LOG_WARNING, "Failed to create new thread!\n");
12863 ast_mutex_destroy(&thread->lock);
12864 ast_cond_destroy(&thread->cond);
12865 ast_mutex_unlock(&thread->init_lock);
12866 ast_mutex_destroy(&thread->init_lock);
12867 ast_cond_destroy(&thread->init_cond);
12868 ast_free(thread);
12869 thread = NULL;
12870 continue;
12871 }
12872 /* Wait for the thread to be ready */
12873 ast_cond_wait(&thread->init_cond, &thread->init_lock);
12874
12875 /* Done with init_lock */
12876 ast_mutex_unlock(&thread->init_lock);
12877
12878 AST_LIST_LOCK(&idle_list);
12879 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
12880 AST_LIST_UNLOCK(&idle_list);
12881 }
12882 }
12883 if (ast_pthread_create_background(&netthreadid, NULL, network_thread, NULL)) {
12884 ast_log(LOG_ERROR, "Failed to create new thread!\n");
12885 return -1;
12886 }
12887 ast_verb(2, "%d helper threads started\n", threadcount);
12888 return 0;
12889}
12890
12891static struct iax2_context *build_context(const char *context)
12892{
12893 struct iax2_context *con;
12894
12895 if ((con = ast_calloc(1, sizeof(*con))))
12896 ast_copy_string(con->context, context, sizeof(con->context));
12897
12898 return con;
12899}
12900
12901static int get_auth_methods(const char *value)
12902{
12903 int methods = 0;
12904 if (strstr(value, "rsa"))
12905 methods |= IAX_AUTH_RSA;
12906 if (strstr(value, "md5"))
12907 methods |= IAX_AUTH_MD5;
12908 if (strstr(value, "plaintext"))
12909 methods |= IAX_AUTH_PLAINTEXT;
12910 return methods;
12911}
12912
12913
12914/*! \brief Check if address can be used as packet source.
12915 \retval 0 address available
12916 \retval 1 address unavailable
12917 \retval -1 error
12918*/
12919static int check_srcaddr(struct ast_sockaddr *addr)
12920{
12921 int sd;
12922
12923 sd = socket(addr->ss.ss_family, SOCK_DGRAM, 0);
12924 if (sd < 0) {
12925 ast_log(LOG_ERROR, "Socket: %s\n", strerror(errno));
12926 return -1;
12927 }
12928
12929 if (ast_bind(sd, addr) < 0) {
12930 ast_debug(1, "Can't bind: %s\n", strerror(errno));
12931 close(sd);
12932 return 1;
12933 }
12934
12935 close(sd);
12936 return 0;
12937}
12938
12939/*! \brief Parse the "sourceaddress" value,
12940 lookup in netsock list and set peer's sockfd. Defaults to defaultsockfd if
12941 not found. */
12942static int peer_set_srcaddr(struct iax2_peer *peer, const char *srcaddr)
12943{
12944 struct ast_sockaddr addr;
12945 int nonlocal = 1;
12946 int port = IAX_DEFAULT_PORTNO;
12947 int sockfd = defaultsockfd;
12948 char *tmp;
12949 char *host;
12950 char *portstr;
12951
12952 tmp = ast_strdupa(srcaddr);
12953 ast_sockaddr_split_hostport(tmp, &host, &portstr, 0);
12954
12955 if (portstr) {
12956 port = atoi(portstr);
12957 if (port < 1)
12958 port = IAX_DEFAULT_PORTNO;
12959 }
12960
12961 addr.ss.ss_family = AST_AF_UNSPEC;
12962 if (!ast_get_ip(&addr, host)) {
12963 struct ast_netsock *sock;
12964
12965 if (check_srcaddr(&addr) == 0) {
12966 /* ip address valid. */
12967 ast_sockaddr_set_port(&addr, port);
12968
12969 if (!(sock = ast_netsock_find(netsock, &addr)))
12970 sock = ast_netsock_find(outsock, &addr);
12971 if (sock) {
12972 sockfd = ast_netsock_sockfd(sock);
12973 nonlocal = 0;
12974 } else {
12975 /* INADDR_ANY matches anyway! */
12976 ast_sockaddr_parse(&addr, "0.0.0.0", 0);
12977 ast_sockaddr_set_port(&addr, port);
12978 if (ast_netsock_find(netsock, &addr)) {
12979 sock = ast_netsock_bind(outsock, io, srcaddr, port, qos.tos, qos.cos, socket_read, NULL);
12980 if (sock) {
12981 sockfd = ast_netsock_sockfd(sock);
12982 ast_netsock_unref(sock);
12983 nonlocal = 0;
12984 } else {
12985 nonlocal = 2;
12986 }
12987 }
12988 }
12989 }
12990 }
12991
12992 peer->sockfd = sockfd;
12993
12994 if (nonlocal == 1) {
12995 ast_log(LOG_WARNING,
12996 "Non-local or unbound address specified (%s) in sourceaddress for '%s', reverting to default\n",
12997 srcaddr,
12998 peer->name);
12999 return -1;
13000 } else if (nonlocal == 2) {
13001 ast_log(LOG_WARNING,
13002 "Unable to bind to sourceaddress '%s' for '%s', reverting to default\n",
13003 srcaddr,
13004 peer->name);
13005 return -1;
13006 } else {
13007 ast_debug(1, "Using sourceaddress %s for '%s'\n", srcaddr, peer->name);
13008 return 0;
13009 }
13010}
13011
13012static void peer_destructor(void *obj)
13013{
13014 struct iax2_peer *peer = obj;
13015 int callno = peer->callno;
13016
13017 ast_free_acl_list(peer->acl);
13018
13019 if (callno > 0) {
13020 ast_mutex_lock(&iaxsl[callno]);
13021 iax2_destroy(callno);
13022 ast_mutex_unlock(&iaxsl[callno]);
13023 }
13024
13025 register_peer_exten(peer, 0);
13026
13027 if (peer->dnsmgr)
13028 ast_dnsmgr_release(peer->dnsmgr);
13029
13030 if (peer->mwi_event_sub) {
13031 peer->mwi_event_sub = ast_mwi_unsubscribe(peer->mwi_event_sub);
13032 }
13033
13034 ast_string_field_free_memory(peer);
13035
13036 ast_endpoint_shutdown(peer->endpoint);
13037}
13038
13039/*! \brief Create peer structure based on configuration */
13040static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
13041{
13042 struct iax2_peer *peer = NULL;
13043 struct ast_acl_list *oldacl = NULL;
13044 int maskfound = 0;
13045 int found = 0;
13046 int firstpass = 1;
13047 int subscribe_acl_change = 0;
13048
13049 if (!temponly) {
13050 peer = ao2_find(peers, name, OBJ_KEY);
13051 if (peer && !ast_test_flag64(peer, IAX_DELME))
13052 firstpass = 0;
13053 }
13054
13055 if (peer) {
13056 found++;
13057 if (firstpass) {
13058 oldacl = peer->acl;
13059 peer->acl = NULL;
13060 }
13061 unlink_peer(peer);
13062 } else if ((peer = ao2_alloc(sizeof(*peer), peer_destructor))) {
13063 peer->expire = -1;
13064 peer->pokeexpire = -1;
13065 peer->sockfd = defaultsockfd;
13066 if (ast_string_field_init(peer, 32))
13067 peer = peer_unref(peer);
13068 if (!(peer->endpoint = ast_endpoint_create("IAX2", name))) {
13069 peer = peer_unref(peer);
13070 }
13071 }
13072
13073 if (peer) {
13074 if (firstpass) {
13075 ast_copy_flags64(peer, &globalflags, IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
13076 peer->encmethods = iax2_encryption;
13077 peer->authmethods = iax2_authmethods;
13078 peer->adsi = adsi;
13079 ast_string_field_set(peer, secret, "");
13080 if (!found) {
13081 ast_string_field_set(peer, name, name);
13082 ast_sockaddr_parse(&peer->addr, "0.0.0.0", 0);
13083 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
13084 peer->expiry = min_reg_expire;
13085 }
13086 peer->prefs = prefs_global;
13087 peer->capability = iax2_capability;
13088 peer->smoothing = 0;
13089 peer->pokefreqok = DEFAULT_FREQ_OK;
13090 peer->pokefreqnotok = DEFAULT_FREQ_NOTOK;
13091 peer->maxcallno = 0;
13092 peercnt_modify((unsigned char) 0, 0, &peer->addr);
13093 peer->calltoken_required = CALLTOKEN_DEFAULT;
13094 ast_string_field_set(peer,context,"");
13095 ast_string_field_set(peer,peercontext,"");
13096 ast_clear_flag64(peer, IAX_HASCALLERID);
13097 ast_string_field_set(peer, cid_name, "");
13098 ast_string_field_set(peer, cid_num, "");
13099 ast_string_field_set(peer, mohinterpret, mohinterpret);
13100 ast_string_field_set(peer, mohsuggest, mohsuggest);
13101 }
13102
13103 if (!v) {
13104 v = alt;
13105 alt = NULL;
13106 }
13107 while(v) {
13108 if (!strcasecmp(v->name, "secret")) {
13109 ast_string_field_set(peer, secret, v->value);
13110 } else if (!strcasecmp(v->name, "mailbox")) {
13111 ast_string_field_set(peer, mailbox, v->value);
13112 } else if (!strcasecmp(v->name, "mohinterpret")) {
13113 ast_string_field_set(peer, mohinterpret, v->value);
13114 } else if (!strcasecmp(v->name, "mohsuggest")) {
13115 ast_string_field_set(peer, mohsuggest, v->value);
13116 } else if (!strcasecmp(v->name, "dbsecret")) {
13117 ast_string_field_set(peer, dbsecret, v->value);
13118 } else if (!strcasecmp(v->name, "description")) {
13119 ast_string_field_set(peer, description, v->value);
13120 } else if (!strcasecmp(v->name, "trunk")) {
13121 ast_set2_flag64(peer, ast_true(v->value), IAX_TRUNK);
13122 if (ast_test_flag64(peer, IAX_TRUNK) && !timer) {
13123 ast_log(LOG_WARNING, "Unable to support trunking on peer '%s' without a timing interface\n", peer->name);
13124 ast_clear_flag64(peer, IAX_TRUNK);
13125 }
13126 } else if (!strcasecmp(v->name, "auth")) {
13127 peer->authmethods = get_auth_methods(v->value);
13128 if (peer->authmethods & IAX_AUTH_PLAINTEXT) {
13129 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);
13130 }
13131 } else if (!strcasecmp(v->name, "encryption")) {
13132 peer->encmethods |= get_encrypt_methods(v->value);
13133 if (!peer->encmethods) {
13134 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
13135 }
13136 } else if (!strcasecmp(v->name, "forceencryption")) {
13137 if (ast_false(v->value)) {
13138 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
13139 } else {
13140 peer->encmethods |= get_encrypt_methods(v->value);
13141 if (peer->encmethods) {
13142 ast_set_flag64(peer, IAX_FORCE_ENCRYPT);
13143 }
13144 }
13145 } else if (!strcasecmp(v->name, "transfer")) {
13146 if (!strcasecmp(v->value, "mediaonly")) {
13147 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13148 } else if (ast_true(v->value)) {
13149 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13150 } else
13151 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13152 } else if (!strcasecmp(v->name, "jitterbuffer")) {
13153 ast_set2_flag64(peer, ast_true(v->value), IAX_USEJITTERBUF);
13154 } else if (!strcasecmp(v->name, "host")) {
13155 if (!strcasecmp(v->value, "dynamic")) {
13156 /* They'll register with us */
13157 ast_set_flag64(peer, IAX_DYNAMIC);
13158 if (!found) {
13159 int peer_port = ast_sockaddr_port(&peer->addr);
13160 if (peer_port) {
13161 ast_sockaddr_set_port(&peer->defaddr, peer_port);
13162 }
13163 ast_sockaddr_setnull(&peer->addr);
13164 }
13165 } else {
13166 /* Non-dynamic. Make sure we become that way if we're not */
13167 AST_SCHED_DEL(sched, peer->expire);
13168 ast_clear_flag64(peer, IAX_DYNAMIC);
13169 if (peer->dnsmgr) {
13170 // Make sure we refresh dnsmgr if we're using it
13171 ast_dnsmgr_refresh(peer->dnsmgr);
13172 } else {
13173 // Or just invalidate the address
13174 peer->addr.ss.ss_family = AST_AF_UNSPEC;
13175 }
13176 if (ast_dnsmgr_lookup(v->value, &peer->addr, &peer->dnsmgr, srvlookup ? "_iax._udp" : NULL)) {
13177 return peer_unref(peer);
13178 }
13179 if (!ast_sockaddr_port(&peer->addr)) {
13180 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
13181 }
13182 }
13183 } else if (!strcasecmp(v->name, "defaultip")) {
13184 struct ast_sockaddr peer_defaddr_tmp;
13185 peer_defaddr_tmp.ss.ss_family = AF_UNSPEC;
13186 if (ast_get_ip(&peer_defaddr_tmp, v->value)) {
13187 return peer_unref(peer);
13188 }
13189 ast_sockaddr_set_port(&peer_defaddr_tmp, ast_sockaddr_port(&peer->defaddr));
13190 ast_sockaddr_copy(&peer->defaddr, &peer_defaddr_tmp);
13191 } else if (!strcasecmp(v->name, "sourceaddress")) {
13192 peer_set_srcaddr(peer, v->value);
13193 } else if (!strcasecmp(v->name, "permit") ||
13194 !strcasecmp(v->name, "deny") ||
13195 !strcasecmp(v->name, "acl")) {
13196 ast_append_acl(v->name, v->value, &peer->acl, NULL, &subscribe_acl_change);
13197 } else if (!strcasecmp(v->name, "mask")) {
13198 maskfound++;
13199 ast_sockaddr_parse(&peer->mask, v->value, 0);
13200 } else if (!strcasecmp(v->name, "context")) {
13201 ast_string_field_set(peer, context, v->value);
13202 } else if (!strcasecmp(v->name, "regexten")) {
13203 ast_string_field_set(peer, regexten, v->value);
13204 } else if (!strcasecmp(v->name, "peercontext")) {
13205 ast_string_field_set(peer, peercontext, v->value);
13206 } else if (!strcasecmp(v->name, "port")) {
13207 int bindport;
13208 if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
13209 bindport = IAX_DEFAULT_PORTNO;
13210 }
13211 if (ast_test_flag64(peer, IAX_DYNAMIC)) {
13212 ast_sockaddr_set_port(&peer->defaddr, bindport);
13213 } else {
13214 ast_sockaddr_set_port(&peer->addr, bindport);
13215 }
13216 } else if (!strcasecmp(v->name, "username")) {
13217 ast_string_field_set(peer, username, v->value);
13218 } else if (!strcasecmp(v->name, "allow")) {
13219 iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
13220 } else if (!strcasecmp(v->name, "disallow")) {
13221 iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
13222 } else if (!strcasecmp(v->name, "callerid")) {
13223 if (!ast_strlen_zero(v->value)) {
13224 char name2[80];
13225 char num2[80];
13226 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
13227 ast_string_field_set(peer, cid_name, name2);
13228 ast_string_field_set(peer, cid_num, num2);
13229 } else {
13230 ast_string_field_set(peer, cid_name, "");
13231 ast_string_field_set(peer, cid_num, "");
13232 }
13233 ast_set_flag64(peer, IAX_HASCALLERID);
13234 } else if (!strcasecmp(v->name, "fullname")) {
13235 ast_string_field_set(peer, cid_name, S_OR(v->value, ""));
13236 ast_set_flag64(peer, IAX_HASCALLERID);
13237 } else if (!strcasecmp(v->name, "cid_number")) {
13238 ast_string_field_set(peer, cid_num, S_OR(v->value, ""));
13239 ast_set_flag64(peer, IAX_HASCALLERID);
13240 } else if (!strcasecmp(v->name, "sendani")) {
13241 ast_set2_flag64(peer, ast_true(v->value), IAX_SENDANI);
13242 } else if (!strcasecmp(v->name, "inkeys")) {
13243 ast_string_field_set(peer, inkeys, v->value);
13244 } else if (!strcasecmp(v->name, "outkey")) {
13245 ast_string_field_set(peer, outkey, v->value);
13246 } else if (!strcasecmp(v->name, "qualify")) {
13247 if (!strcasecmp(v->value, "no")) {
13248 peer->maxms = 0;
13249 } else if (!strcasecmp(v->value, "yes")) {
13250 peer->maxms = DEFAULT_MAXMS;
13251 } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
13252 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);
13253 peer->maxms = 0;
13254 }
13255 } else if (!strcasecmp(v->name, "qualifysmoothing")) {
13256 peer->smoothing = ast_true(v->value);
13257 } else if (!strcasecmp(v->name, "qualifyfreqok")) {
13258 if (sscanf(v->value, "%30d", &peer->pokefreqok) != 1) {
13259 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);
13260 }
13261 } else if (!strcasecmp(v->name, "qualifyfreqnotok")) {
13262 if (sscanf(v->value, "%30d", &peer->pokefreqnotok) != 1) {
13263 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);
13264 }
13265 } else if (!strcasecmp(v->name, "timezone")) {
13266 ast_string_field_set(peer, zonetag, v->value);
13267 } else if (!strcasecmp(v->name, "adsi")) {
13268 peer->adsi = ast_true(v->value);
13269 } else if (!strcasecmp(v->name, "connectedline")) {
13270 if (ast_true(v->value)) {
13271 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13272 } else if (!strcasecmp(v->value, "send")) {
13273 ast_clear_flag64(peer, IAX_RECVCONNECTEDLINE);
13274 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE);
13275 } else if (!strcasecmp(v->value, "receive")) {
13276 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE);
13277 ast_set_flag64(peer, IAX_RECVCONNECTEDLINE);
13278 } else {
13279 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13280 }
13281 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
13282 if (sscanf(v->value, "%10hu", &peer->maxcallno) != 1) {
13283 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d.\n", v->value, v->lineno);
13284 } else {
13285 peercnt_modify((unsigned char) 1, peer->maxcallno, &peer->addr);
13286 }
13287 } else if (!strcasecmp(v->name, "requirecalltoken")) {
13288 /* default is required unless in optional ip list */
13289 if (ast_false(v->value)) {
13290 peer->calltoken_required = CALLTOKEN_NO;
13291 } else if (!strcasecmp(v->value, "auto")) {
13292 peer->calltoken_required = CALLTOKEN_AUTO;
13293 } else if (ast_true(v->value)) {
13294 peer->calltoken_required = CALLTOKEN_YES;
13295 } else {
13296 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
13297 }
13298 } /* else if (strcasecmp(v->name,"type")) */
13299 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
13300 v = v->next;
13301 if (!v) {
13302 v = alt;
13303 alt = NULL;
13304 }
13305 }
13306 if (!peer->authmethods)
13307 peer->authmethods = IAX_AUTH_MD5;
13308 ast_clear_flag64(peer, IAX_DELME);
13309 }
13310
13311 if (!maskfound && !ast_sockaddr_isnull(&peer->addr)) {
13312 if (ast_sockaddr_is_ipv4_mapped(&peer->addr)) {
13313 ast_sockaddr_parse(&peer->mask, "::ffff:ffff:ffff", 0);
13314 } else if (ast_sockaddr_is_ipv6(&peer->addr)) {
13315 ast_sockaddr_parse(&peer->mask, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
13316 } else {
13317 ast_sockaddr_parse(&peer->mask, "255.255.255.255", 0);
13318 }
13319 }
13320
13321 if (oldacl) {
13322 ast_free_acl_list(oldacl);
13323 }
13324
13325 if (!ast_strlen_zero(peer->mailbox) && !peer->mwi_event_sub) {
13326 /* The MWI subscriptions exist just so the core knows we care about those
13327 * mailboxes. However, we just grab the events out of the cache when it
13328 * is time to send MWI, since it is only sent with a REGACK. */
13329 peer->mwi_event_sub = ast_mwi_subscribe_pool(peer->mailbox, stasis_subscription_cb_noop, NULL);
13330 }
13331
13332 if (subscribe_acl_change) {
13333 acl_change_stasis_subscribe();
13334 }
13335
13336 return peer;
13337}
13338
13339static void user_destructor(void *obj)
13340{
13341 struct iax2_user *user = obj;
13342
13343 ast_free_acl_list(user->acl);
13344 free_context(user->contexts);
13345 if(user->vars) {
13346 ast_variables_destroy(user->vars);
13347 user->vars = NULL;
13348 }
13349 ast_string_field_free_memory(user);
13350}
13351
13352/*! \brief Create in-memory user structure from configuration */
13353static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly)
13354{
13355 struct iax2_user *user = NULL;
13356 struct iax2_context *con, *conl = NULL;
13357 struct ast_acl_list *oldacl = NULL;
13358 struct iax2_context *oldcon = NULL;
13359 int format;
13360 int firstpass=1;
13361 int oldcurauthreq = 0;
13362 int subscribe_acl_change = 0;
13363 char *varname = NULL, *varval = NULL;
13364 struct ast_variable *tmpvar = NULL;
13365
13366 if (!temponly) {
13367 user = ao2_find(users, name, OBJ_KEY);
13368 if (user && !ast_test_flag64(user, IAX_DELME))
13369 firstpass = 0;
13370 }
13371
13372 if (user) {
13373 if (firstpass) {
13374 oldcurauthreq = user->curauthreq;
13375 oldacl = user->acl;
13376 oldcon = user->contexts;
13377 user->acl = NULL;
13378 user->contexts = NULL;
13379 }
13380 /* Already in the list, remove it and it will be added back (or FREE'd) */
13381 ao2_unlink(users, user);
13382 } else {
13383 user = ao2_alloc(sizeof(*user), user_destructor);
13384 }
13385
13386 if (user) {
13387 if (firstpass) {
13388 ast_string_field_free_memory(user);
13389 memset(user, 0, sizeof(struct iax2_user));
13390 if (ast_string_field_init(user, 32)) {
13391 user = user_unref(user);
13392 goto cleanup;
13393 }
13394 user->maxauthreq = maxauthreq;
13395 user->curauthreq = oldcurauthreq;
13396 user->prefs = prefs_global;
13397 user->capability = iax2_capability;
13398 user->encmethods = iax2_encryption;
13399 user->authmethods = iax2_authmethods;
13400 user->adsi = adsi;
13401 user->calltoken_required = CALLTOKEN_DEFAULT;
13402 ast_string_field_set(user, name, name);
13403 ast_string_field_set(user, language, language);
13404 ast_copy_flags64(user, &globalflags, IAX_USEJITTERBUF | IAX_CODEC_USER_FIRST | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
13405 ast_clear_flag64(user, IAX_HASCALLERID);
13406 ast_string_field_set(user, cid_name, "");
13407 ast_string_field_set(user, cid_num, "");
13408 ast_string_field_set(user, accountcode, accountcode);
13409 ast_string_field_set(user, mohinterpret, mohinterpret);
13410 ast_string_field_set(user, mohsuggest, mohsuggest);
13411 }
13412 if (!v) {
13413 v = alt;
13414 alt = NULL;
13415 }
13416 while(v) {
13417 if (!strcasecmp(v->name, "context")) {
13418 con = build_context(v->value);
13419 if (con) {
13420 if (conl)
13421 conl->next = con;
13422 else
13423 user->contexts = con;
13424 conl = con;
13425 }
13426 } else if (!strcasecmp(v->name, "permit") ||
13427 !strcasecmp(v->name, "deny") ||
13428 !strcasecmp(v->name, "acl")) {
13429 ast_append_acl(v->name, v->value, &user->acl, NULL, &subscribe_acl_change);
13430 } else if (!strcasecmp(v->name, "setvar")) {
13431 varname = ast_strdupa(v->value);
13432 if ((varval = strchr(varname, '='))) {
13433 *varval = '\0';
13434 varval++;
13435 if ((tmpvar = ast_variable_new(varname, varval, ""))) {
13436 if (ast_variable_list_replace(&user->vars, tmpvar)) {
13437 tmpvar->next = user->vars;
13438 user->vars = tmpvar;
13439 }
13440 }
13441 }
13442 } else if (!strcasecmp(v->name, "allow")) {
13443 iax2_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
13444 } else if (!strcasecmp(v->name, "disallow")) {
13445 iax2_parse_allow_disallow(&user->prefs, &user->capability,v->value, 0);
13446 } else if (!strcasecmp(v->name, "trunk")) {
13447 ast_set2_flag64(user, ast_true(v->value), IAX_TRUNK);
13448 if (ast_test_flag64(user, IAX_TRUNK) && !timer) {
13449 ast_log(LOG_WARNING, "Unable to support trunking on user '%s' without a timing interface\n", user->name);
13450 ast_clear_flag64(user, IAX_TRUNK);
13451 }
13452 } else if (!strcasecmp(v->name, "auth")) {
13453 user->authmethods = get_auth_methods(v->value);
13454 if (user->authmethods & IAX_AUTH_PLAINTEXT) {
13455 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);
13456 }
13457 } else if (!strcasecmp(v->name, "encryption")) {
13458 user->encmethods |= get_encrypt_methods(v->value);
13459 if (!user->encmethods) {
13460 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
13461 }
13462 } else if (!strcasecmp(v->name, "forceencryption")) {
13463 if (ast_false(v->value)) {
13464 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
13465 } else {
13466 user->encmethods |= get_encrypt_methods(v->value);
13467 if (user->encmethods) {
13468 ast_set_flag64(user, IAX_FORCE_ENCRYPT);
13469 }
13470 }
13471 } else if (!strcasecmp(v->name, "transfer")) {
13472 if (!strcasecmp(v->value, "mediaonly")) {
13473 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13474 } else if (ast_true(v->value)) {
13475 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13476 } else
13477 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13478 } else if (!strcasecmp(v->name, "codecpriority")) {
13479 if(!strcasecmp(v->value, "caller"))
13480 ast_set_flag64(user, IAX_CODEC_USER_FIRST);
13481 else if(!strcasecmp(v->value, "disabled"))
13482 ast_set_flag64(user, IAX_CODEC_NOPREFS);
13483 else if(!strcasecmp(v->value, "reqonly")) {
13484 ast_set_flag64(user, IAX_CODEC_NOCAP);
13485 ast_set_flag64(user, IAX_CODEC_NOPREFS);
13486 }
13487 } else if (!strcasecmp(v->name, "immediate")) {
13488 ast_set2_flag64(user, ast_true(v->value), IAX_IMMEDIATE);
13489 } else if (!strcasecmp(v->name, "jitterbuffer")) {
13490 ast_set2_flag64(user, ast_true(v->value), IAX_USEJITTERBUF);
13491 } else if (!strcasecmp(v->name, "dbsecret")) {
13492 ast_string_field_set(user, dbsecret, v->value);
13493 } else if (!strcasecmp(v->name, "secret")) {
13494 if (!ast_strlen_zero(user->secret)) {
13495 char *old = ast_strdupa(user->secret);
13496
13497 ast_string_field_build(user, secret, "%s;%s", old, v->value);
13498 } else
13499 ast_string_field_set(user, secret, v->value);
13500 } else if (!strcasecmp(v->name, "callerid")) {
13501 if (!ast_strlen_zero(v->value) && strcasecmp(v->value, "asreceived")) {
13502 char name2[80];
13503 char num2[80];
13504 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
13505 ast_string_field_set(user, cid_name, name2);
13506 ast_string_field_set(user, cid_num, num2);
13507 ast_set_flag64(user, IAX_HASCALLERID);
13508 } else {
13509 ast_clear_flag64(user, IAX_HASCALLERID);
13510 ast_string_field_set(user, cid_name, "");
13511 ast_string_field_set(user, cid_num, "");
13512 }
13513 } else if (!strcasecmp(v->name, "fullname")) {
13514 if (!ast_strlen_zero(v->value)) {
13515 ast_string_field_set(user, cid_name, v->value);
13516 ast_set_flag64(user, IAX_HASCALLERID);
13517 } else {
13518 ast_string_field_set(user, cid_name, "");
13519 if (ast_strlen_zero(user->cid_num))
13520 ast_clear_flag64(user, IAX_HASCALLERID);
13521 }
13522 } else if (!strcasecmp(v->name, "cid_number")) {
13523 if (!ast_strlen_zero(v->value)) {
13524 ast_string_field_set(user, cid_num, v->value);
13525 ast_set_flag64(user, IAX_HASCALLERID);
13526 } else {
13527 ast_string_field_set(user, cid_num, "");
13528 if (ast_strlen_zero(user->cid_name))
13529 ast_clear_flag64(user, IAX_HASCALLERID);
13530 }
13531 } else if (!strcasecmp(v->name, "accountcode")) {
13532 ast_string_field_set(user, accountcode, v->value);
13533 } else if (!strcasecmp(v->name, "mohinterpret")) {
13534 ast_string_field_set(user, mohinterpret, v->value);
13535 } else if (!strcasecmp(v->name, "mohsuggest")) {
13536 ast_string_field_set(user, mohsuggest, v->value);
13537 } else if (!strcasecmp(v->name, "parkinglot")) {
13538 ast_string_field_set(user, parkinglot, v->value);
13539 } else if (!strcasecmp(v->name, "language")) {
13540 ast_string_field_set(user, language, v->value);
13541 } else if (!strcasecmp(v->name, "amaflags")) {
13542 format = ast_channel_string2amaflag(v->value);
13543 if (format < 0) {
13544 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
13545 } else {
13546 user->amaflags = format;
13547 }
13548 } else if (!strcasecmp(v->name, "inkeys")) {
13549 ast_string_field_set(user, inkeys, v->value);
13550 } else if (!strcasecmp(v->name, "maxauthreq")) {
13551 user->maxauthreq = atoi(v->value);
13552 if (user->maxauthreq < 0)
13553 user->maxauthreq = 0;
13554 } else if (!strcasecmp(v->name, "adsi")) {
13555 user->adsi = ast_true(v->value);
13556 } else if (!strcasecmp(v->name, "connectedline")) {
13557 if (ast_true(v->value)) {
13558 ast_set_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13559 } else if (!strcasecmp(v->value, "send")) {
13560 ast_clear_flag64(user, IAX_RECVCONNECTEDLINE);
13561 ast_set_flag64(user, IAX_SENDCONNECTEDLINE);
13562 } else if (!strcasecmp(v->value, "receive")) {
13563 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE);
13564 ast_set_flag64(user, IAX_RECVCONNECTEDLINE);
13565 } else {
13566 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13567 }
13568 } else if (!strcasecmp(v->name, "requirecalltoken")) {
13569 /* default is required unless in optional ip list */
13570 if (ast_false(v->value)) {
13571 user->calltoken_required = CALLTOKEN_NO;
13572 } else if (!strcasecmp(v->value, "auto")) {
13573 user->calltoken_required = CALLTOKEN_AUTO;
13574 } else if (ast_true(v->value)) {
13575 user->calltoken_required = CALLTOKEN_YES;
13576 } else {
13577 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
13578 }
13579 } /* else if (strcasecmp(v->name,"type")) */
13580 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
13581 v = v->next;
13582 if (!v) {
13583 v = alt;
13584 alt = NULL;
13585 }
13586 }
13587 if (!user->authmethods) {
13588 if (!ast_strlen_zero(user->secret)) {
13589 user->authmethods = IAX_AUTH_MD5;
13590 if (!ast_strlen_zero(user->inkeys))
13591 user->authmethods |= IAX_AUTH_RSA;
13592 } else if (!ast_strlen_zero(user->inkeys)) {
13593 user->authmethods = IAX_AUTH_RSA;
13594 } else {
13595 user->authmethods = IAX_AUTH_MD5;
13596 }
13597 }
13598 ast_clear_flag64(user, IAX_DELME);
13599 }
13600cleanup:
13601 if (oldacl) {
13602 ast_free_acl_list(oldacl);
13603 }
13604 if (oldcon) {
13605 free_context(oldcon);
13606 }
13607
13608 if (subscribe_acl_change) {
13609 acl_change_stasis_subscribe();
13610 }
13611
13612 return user;
13613}
13614
13615static int peer_delme_cb(void *obj, void *arg, int flags)
13616{
13617 struct iax2_peer *peer = obj;
13618
13619 ast_set_flag64(peer, IAX_DELME);
13620
13621 return 0;
13622}
13623
13624static int user_delme_cb(void *obj, void *arg, int flags)
13625{
13626 struct iax2_user *user = obj;
13627
13628 ast_set_flag64(user, IAX_DELME);
13629
13630 return 0;
13631}
13632
13633static void delete_users(void)
13634{
13635 struct iax2_registry *reg;
13636
13637 ao2_callback(users, OBJ_NODATA, user_delme_cb, NULL);
13638
13639 AST_LIST_LOCK(&registrations);
13640 while ((reg = AST_LIST_REMOVE_HEAD(&registrations, entry))) {
13641 if (sched) {
13642 AST_SCHED_DEL(sched, reg->expire);
13643 }
13644 if (reg->callno) {
13645 int callno = reg->callno;
13646 ast_mutex_lock(&iaxsl[callno]);
13647 if (iaxs[callno]) {
13648 iaxs[callno]->reg = NULL;
13649 iax2_destroy(callno);
13650 }
13651 ast_mutex_unlock(&iaxsl[callno]);
13652 }
13653 if (reg->dnsmgr)
13654 ast_dnsmgr_release(reg->dnsmgr);
13655 ast_free(reg);
13656 }
13657 AST_LIST_UNLOCK(&registrations);
13658
13659 ao2_callback(peers, OBJ_NODATA, peer_delme_cb, NULL);
13660}
13661
13662static void prune_users(void)
13663{
13664 struct iax2_user *user;
13665 struct ao2_iterator i;
13666
13667 i = ao2_iterator_init(users, 0);
13668 while ((user = ao2_iterator_next(&i))) {
13669 if (ast_test_flag64(user, IAX_DELME) || ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
13670 ao2_unlink(users, user);
13671 }
13672 user_unref(user);
13673 }
13674 ao2_iterator_destroy(&i);
13675}
13676
13677/* Prune peers who still are supposed to be deleted */
13678static void prune_peers(void)
13679{
13680 struct iax2_peer *peer;
13681 struct ao2_iterator i;
13682
13683 i = ao2_iterator_init(peers, 0);
13684 while ((peer = ao2_iterator_next(&i))) {
13685 if (ast_test_flag64(peer, IAX_DELME) || ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
13686 unlink_peer(peer);
13687 }
13688 peer_unref(peer);
13689 }
13690 ao2_iterator_destroy(&i);
13691}
13692
13693static void set_config_destroy(void)
13694{
13695 strcpy(accountcode, "");
13696 strcpy(language, "");
13697 strcpy(mohinterpret, "");
13698 strcpy(mohsuggest, "");
13699 trunkmaxsize = MAX_TRUNKDATA;
13700 amaflags = 0;
13701 delayreject = 0;
13702 ast_clear_flag64((&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF |
13703 IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13704 delete_users();
13705 ao2_callback(callno_limits, OBJ_NODATA, addr_range_delme_cb, NULL);
13706 ao2_callback(calltoken_ignores, OBJ_NODATA, addr_range_delme_cb, NULL);
13707}
13708
13709/*! \brief Load configuration */
13710static int set_config(const char *config_file, int reload, int forced)
13711{
13712 struct ast_config *cfg;
13713 iax2_format capability;
13714 struct ast_variable *v;
13715 char *cat;
13716 const char *utype;
13717 const char *tosval;
13718 int format;
13719 int portno = IAX_DEFAULT_PORTNO;
13720 int x;
13721 int mtuv;
13722 int subscribe_network_change = 1;
13723 struct iax2_user *user;
13724 struct iax2_peer *peer;
13725 struct ast_netsock *ns;
13726 struct ast_flags config_flags = { (reload && !forced) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
13727 struct ast_sockaddr bindaddr;
13728 struct iax2_codec_pref prefs_new;
13729
13730 cfg = ast_config_load(config_file, config_flags);
13731
13732 if (!cfg) {
13733 ast_log(LOG_ERROR, "Unable to load config %s\n", config_file);
13734 return -1;
13735 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
13736 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13737 if ((cfg = ast_config_load(config_file, config_flags)) == CONFIG_STATUS_FILEINVALID) {
13738 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13739 return 0;
13740 }
13741 if (!cfg) {
13742 /* should have been able to load the config here */
13743 ast_log(LOG_ERROR, "Unable to load config %s again\n", config_file);
13744 return -1;
13745 }
13746 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
13747 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13748 return 0;
13749 } else { /* iax.conf changed */
13750 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13751 }
13752
13753 if (reload) {
13754 set_config_destroy();
13755 }
13756
13757 ast_sockaddr_parse(&bindaddr, "0.0.0.0:0", 0);
13758
13759 /* Setup new codec prefs */
13760 capability = iax2_codec_pref_from_bitfield(&prefs_new, IAX_CAPABILITY_FULLBANDWIDTH);
13761
13762 /* Reset Global Flags */
13763 memset(&globalflags, 0, sizeof(globalflags));
13764 ast_set_flag64(&globalflags, IAX_RTUPDATE);
13765 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
13766
13767#ifdef SO_NO_CHECK
13768 nochecksums = 0;
13769#endif
13770 /* Reset default parking lot */
13771 default_parkinglot[0] = '\0';
13772
13773 min_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13774 max_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13775 global_max_trunk_mtu = MAX_TRUNK_MTU;
13776 global_maxcallno = DEFAULT_MAXCALLNO_LIMIT;
13777 global_maxcallno_nonval = DEFAULT_MAXCALLNO_LIMIT_NONVAL;
13778
13779 maxauthreq = 3;
13780
13781 srvlookup = 0;
13782 iax2_authmethods = 0;
13783
13784 v = ast_variable_browse(cfg, "general");
13785
13786 /* Seed initial tos value */
13787 tosval = ast_variable_retrieve(cfg, "general", "tos");
13788 if (tosval) {
13789 if (ast_str2tos(tosval, &qos.tos))
13790 ast_log(LOG_WARNING, "Invalid tos value, refer to QoS documentation\n");
13791 }
13792 /* Seed initial cos value */
13793 tosval = ast_variable_retrieve(cfg, "general", "cos");
13794 if (tosval) {
13795 if (ast_str2cos(tosval, &qos.cos))
13796 ast_log(LOG_WARNING, "Invalid cos value, refer to QoS documentation\n");
13797 }
13798 while(v) {
13799 if (!strcasecmp(v->name, "bindport")) {
13800 if (reload) {
13801 ast_log(LOG_NOTICE, "Ignoring bindport on reload\n");
13802 }
13803 else if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &portno, 1024, 65535)) {
13804 portno = IAX_DEFAULT_PORTNO;
13805 }
13806 } else if (!strcasecmp(v->name, "pingtime")){
13807 ping_time = atoi(v->value);
13808 }
13809 else if (!strcasecmp(v->name, "iaxthreadcount")) {
13810 if (reload) {
13811 if (atoi(v->value) != iaxthreadcount)
13812 ast_log(LOG_NOTICE, "Ignoring any changes to iaxthreadcount during reload\n");
13813 } else {
13814 iaxthreadcount = atoi(v->value);
13815 if (iaxthreadcount < 1) {
13816 ast_log(LOG_NOTICE, "iaxthreadcount must be at least 1.\n");
13817 iaxthreadcount = 1;
13818 } else if (iaxthreadcount > 256) {
13819 ast_log(LOG_NOTICE, "limiting iaxthreadcount to 256\n");
13820 iaxthreadcount = 256;
13821 }
13822 }
13823 } else if (!strcasecmp(v->name, "iaxmaxthreadcount")) {
13824 if (reload) {
13825 AST_LIST_LOCK(&dynamic_list);
13826 iaxmaxthreadcount = atoi(v->value);
13827 AST_LIST_UNLOCK(&dynamic_list);
13828 } else {
13829 iaxmaxthreadcount = atoi(v->value);
13830 if (iaxmaxthreadcount < 0) {
13831 ast_log(LOG_NOTICE, "iaxmaxthreadcount must be at least 0.\n");
13832 iaxmaxthreadcount = 0;
13833 } else if (iaxmaxthreadcount > 256) {
13834 ast_log(LOG_NOTICE, "Limiting iaxmaxthreadcount to 256\n");
13835 iaxmaxthreadcount = 256;
13836 }
13837 }
13838 } else if (!strcasecmp(v->name, "nochecksums")) {
13839#ifdef SO_NO_CHECK
13840 if (ast_true(v->value))
13841 nochecksums = 1;
13842 else
13843 nochecksums = 0;
13844#else
13845 if (ast_true(v->value))
13846 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
13847#endif
13848 }
13849 else if (!strcasecmp(v->name, "maxjitterbuffer"))
13850 maxjitterbuffer = atoi(v->value);
13851 else if (!strcasecmp(v->name, "resyncthreshold"))
13852 resyncthreshold = atoi(v->value);
13853 else if (!strcasecmp(v->name, "maxjitterinterps"))
13854 maxjitterinterps = atoi(v->value);
13855 else if (!strcasecmp(v->name, "jittertargetextra"))
13856 jittertargetextra = atoi(v->value);
13857 else if (!strcasecmp(v->name, "lagrqtime"))
13858 lagrq_time = atoi(v->value);
13859 else if (!strcasecmp(v->name, "maxregexpire"))
13860 max_reg_expire = atoi(v->value);
13861 else if (!strcasecmp(v->name, "minregexpire"))
13862 min_reg_expire = atoi(v->value);
13863 else if (!strcasecmp(v->name, "bindaddr")) {
13864 if (reload) {
13865 ast_log(LOG_NOTICE, "Ignoring bindaddr on reload\n");
13866 } else {
13867
13868 if (!ast_parse_arg(v->value, PARSE_ADDR, NULL)) {
13869
13870 ast_sockaddr_parse(&bindaddr, v->value, 0);
13871
13872 if (!ast_sockaddr_port(&bindaddr)) {
13873 ast_sockaddr_set_port(&bindaddr, portno);
13874 }
13875
13876 if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
13877 ast_log(LOG_WARNING, "Unable to apply binding to '%s' at line %d\n", v->value, v->lineno);
13878 } else {
13879 ast_verb(2, "Binding IAX2 to address %s\n", ast_sockaddr_stringify(&bindaddr));
13880
13881 if (defaultsockfd < 0) {
13882 defaultsockfd = ast_netsock_sockfd(ns);
13883 }
13884 ast_netsock_unref(ns);
13885 }
13886
13887 } else {
13888 ast_log(LOG_WARNING, "Invalid address '%s' specified, at line %d\n", v->value, v->lineno);
13889 }
13890 }
13891 } else if (!strcasecmp(v->name, "auth")) {
13892 iax2_authmethods = get_auth_methods(v->value);
13893 if (iax2_authmethods & IAX_AUTH_PLAINTEXT) {
13894 ast_log(LOG_WARNING, "Default auth method is set to deprecated 'plaintext' at line %d of iax.conf\n", v->lineno);
13895 }
13896 } else if (!strcasecmp(v->name, "authdebug")) {
13897 authdebug = ast_true(v->value);
13898 } else if (!strcasecmp(v->name, "encryption")) {
13899 iax2_encryption |= get_encrypt_methods(v->value);
13900 if (!iax2_encryption) {
13901 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13902 }
13903 } else if (!strcasecmp(v->name, "forceencryption")) {
13904 if (ast_false(v->value)) {
13905 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13906 } else {
13907 iax2_encryption |= get_encrypt_methods(v->value);
13908 if (iax2_encryption) {
13909 ast_set_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13910 }
13911 }
13912 } else if (!strcasecmp(v->name, "transfer")) {
13913 if (!strcasecmp(v->value, "mediaonly")) {
13914 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13915 } else if (ast_true(v->value)) {
13916 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13917 } else
13918 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13919 } else if (!strcasecmp(v->name, "codecpriority")) {
13920 if(!strcasecmp(v->value, "caller"))
13921 ast_set_flag64((&globalflags), IAX_CODEC_USER_FIRST);
13922 else if(!strcasecmp(v->value, "disabled"))
13923 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13924 else if(!strcasecmp(v->value, "reqonly")) {
13925 ast_set_flag64((&globalflags), IAX_CODEC_NOCAP);
13926 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13927 }
13928 } else if (!strcasecmp(v->name, "jitterbuffer"))
13929 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_USEJITTERBUF);
13930 else if (!strcasecmp(v->name, "delayreject"))
13931 delayreject = ast_true(v->value);
13932 else if (!strcasecmp(v->name, "allowfwdownload"))
13933 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_ALLOWFWDOWNLOAD);
13934 else if (!strcasecmp(v->name, "rtcachefriends"))
13935 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTCACHEFRIENDS);
13936 else if (!strcasecmp(v->name, "rtignoreregexpire"))
13937 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTIGNOREREGEXPIRE);
13938 else if (!strcasecmp(v->name, "rtupdate"))
13939 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTUPDATE);
13940 else if (!strcasecmp(v->name, "rtsavesysname"))
13941 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTSAVE_SYSNAME);
13942 else if (!strcasecmp(v->name, "trunktimestamps"))
13943 ast_set2_flag64(&globalflags, ast_true(v->value), IAX_TRUNKTIMESTAMPS);
13944 else if (!strcasecmp(v->name, "rtautoclear")) {
13945 int i = atoi(v->value);
13946 if(i > 0)
13947 global_rtautoclear = i;
13948 else
13949 i = 0;
13950 ast_set2_flag64((&globalflags), i || ast_true(v->value), IAX_RTAUTOCLEAR);
13951 } else if (!strcasecmp(v->name, "trunkfreq")) {
13952 trunkfreq = atoi(v->value);
13953 if (trunkfreq < 10) {
13954 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 10ms instead.\n");
13955 trunkfreq = 10;
13956 } else if (trunkfreq > 1000) {
13957 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 1000ms instead.\n");
13958 trunkfreq = 1000;
13959 }
13960 if (timer) {
13961 ast_timer_set_rate(timer, 1000 / trunkfreq);
13962 }
13963 } else if (!strcasecmp(v->name, "trunkmtu")) {
13964 mtuv = atoi(v->value);
13965 if (mtuv == 0 )
13966 global_max_trunk_mtu = 0;
13967 else if (mtuv >= 172 && mtuv < 4000)
13968 global_max_trunk_mtu = mtuv;
13969 else
13970 ast_log(LOG_NOTICE, "trunkmtu value out of bounds (%d) at line %d\n",
13971 mtuv, v->lineno);
13972 } else if (!strcasecmp(v->name, "trunkmaxsize")) {
13973 trunkmaxsize = atoi(v->value);
13974 if (trunkmaxsize == 0)
13975 trunkmaxsize = MAX_TRUNKDATA;
13976 } else if (!strcasecmp(v->name, "autokill")) {
13977 if (sscanf(v->value, "%30d", &x) == 1) {
13978 if (x >= 0)
13979 autokill = x;
13980 else
13981 ast_log(LOG_NOTICE, "Nice try, but autokill has to be >0 or 'yes' or 'no' at line %d\n", v->lineno);
13982 } else if (ast_true(v->value)) {
13983 autokill = DEFAULT_MAXMS;
13984 } else {
13985 autokill = 0;
13986 }
13987 } else if (!strcasecmp(v->name, "bandwidth")) {
13988 if (!strcasecmp(v->value, "low")) {
13989 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13990 IAX_CAPABILITY_LOWBANDWIDTH);
13991 } else if (!strcasecmp(v->value, "medium")) {
13992 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13993 IAX_CAPABILITY_MEDBANDWIDTH);
13994 } else if (!strcasecmp(v->value, "high")) {
13995 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13996 IAX_CAPABILITY_FULLBANDWIDTH);
13997 } else {
13998 ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
13999 }
14000 } else if (!strcasecmp(v->name, "allow")) {
14001 iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 1);
14002 } else if (!strcasecmp(v->name, "disallow")) {
14003 iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 0);
14004 } else if (!strcasecmp(v->name, "register")) {
14005 iax2_register(v->value, v->lineno);
14006 } else if (!strcasecmp(v->name, "iaxcompat")) {
14007 iaxcompat = ast_true(v->value);
14008 } else if (!strcasecmp(v->name, "regcontext")) {
14009 ast_copy_string(regcontext, v->value, sizeof(regcontext));
14010 /* Create context if it doesn't exist already */
14011 ast_context_find_or_create(NULL, NULL, regcontext, "IAX2");
14012 } else if (!strcasecmp(v->name, "tos")) {
14013 if (ast_str2tos(v->value, &qos.tos))
14014 ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
14015 } else if (!strcasecmp(v->name, "cos")) {
14016 if (ast_str2cos(v->value, &qos.cos))
14017 ast_log(LOG_WARNING, "Invalid cos value at line %d, refer to QoS documentation\n", v->lineno);
14018 } else if (!strcasecmp(v->name, "parkinglot")) {
14019 ast_copy_string(default_parkinglot, v->value, sizeof(default_parkinglot));
14020 } else if (!strcasecmp(v->name, "accountcode")) {
14021 ast_copy_string(accountcode, v->value, sizeof(accountcode));
14022 } else if (!strcasecmp(v->name, "mohinterpret")) {
14023 ast_copy_string(mohinterpret, v->value, sizeof(mohinterpret));
14024 } else if (!strcasecmp(v->name, "mohsuggest")) {
14025 ast_copy_string(mohsuggest, v->value, sizeof(mohsuggest));
14026 } else if (!strcasecmp(v->name, "amaflags")) {
14027 format = ast_channel_string2amaflag(v->value);
14028 if (format < 0) {
14029 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
14030 } else {
14031 amaflags = format;
14032 }
14033 } else if (!strcasecmp(v->name, "language")) {
14034 ast_copy_string(language, v->value, sizeof(language));
14035 } else if (!strcasecmp(v->name, "maxauthreq")) {
14036 maxauthreq = atoi(v->value);
14037 if (maxauthreq < 0)
14038 maxauthreq = 0;
14039 } else if (!strcasecmp(v->name, "adsi")) {
14040 adsi = ast_true(v->value);
14041 } else if (!strcasecmp(v->name, "srvlookup")) {
14042 srvlookup = ast_true(v->value);
14043 } else if (!strcasecmp(v->name, "connectedline")) {
14044 if (ast_true(v->value)) {
14045 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
14046 } else if (!strcasecmp(v->value, "send")) {
14047 ast_clear_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
14048 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
14049 } else if (!strcasecmp(v->value, "receive")) {
14050 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
14051 ast_set_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
14052 } else {
14053 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
14054 }
14055 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
14056 if (sscanf(v->value, "%10hu", &global_maxcallno) != 1) {
14057 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d\n", v->value, v->lineno);
14058 }
14059 } else if (!strcasecmp(v->name, "maxcallnumbers_nonvalidated")) {
14060 if (sscanf(v->value, "%10hu", &global_maxcallno_nonval) != 1) {
14061 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);
14062 }
14063 } else if (!strcasecmp(v->name, "calltokenoptional")) {
14064 if (add_calltoken_ignore(v->value)) {
14065 ast_log(LOG_WARNING, "Invalid calltokenoptional address range - '%s' line %d\n", v->value, v->lineno);
14066 return -1;
14067 }
14068 } else if (!strcasecmp(v->name, "calltokenexpiration")) {
14069 int temp = -1;
14070 sscanf(v->value, "%u", &temp);
14071 if( temp <= 0 ){
14072 ast_log(LOG_WARNING, "Invalid calltokenexpiration value %s. Should be integer greater than 0.\n", v->value);
14073 } else {
14074 max_calltoken_delay = temp;
14075 }
14076 } else if (!strcasecmp(v->name, "subscribe_network_change_event")) {
14077 if (ast_true(v->value)) {
14078 subscribe_network_change = 1;
14079 } else if (ast_false(v->value)) {
14080 subscribe_network_change = 0;
14081 } else {
14082 ast_log(LOG_WARNING, "subscribe_network_change_event value %s is not valid at line %d.\n", v->value, v->lineno);
14083 }
14084 } else if (!strcasecmp(v->name, "shrinkcallerid")) {
14085 if (ast_true(v->value)) {
14086 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
14087 } else if (ast_false(v->value)) {
14088 ast_clear_flag64((&globalflags), IAX_SHRINKCALLERID);
14089 } else {
14090 ast_log(LOG_WARNING, "shrinkcallerid value %s is not valid at line %d.\n", v->value, v->lineno);
14091 }
14092 }/*else if (strcasecmp(v->name,"type")) */
14093 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
14094 v = v->next;
14095 }
14096
14097 if (subscribe_network_change) {
14098 network_change_stasis_subscribe();
14099 } else {
14100 network_change_stasis_unsubscribe();
14101 }
14102
14103 if (defaultsockfd < 0) {
14104
14105 ast_sockaddr_set_port(&bindaddr, portno);
14106
14107 if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
14108 ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
14109 } else {
14110 ast_verb(2, "Binding IAX2 to default address %s\n", ast_sockaddr_stringify(&bindaddr));
14111 defaultsockfd = ast_netsock_sockfd(ns);
14112 ast_netsock_unref(ns);
14113 }
14114 }
14115 if (reload) {
14116 ast_netsock_release(outsock);
14117 outsock = ast_netsock_list_alloc();
14118 if (!outsock) {
14119 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
14120 return -1;
14121 }
14122 ast_netsock_init(outsock);
14123 }
14124
14125 if (min_reg_expire > max_reg_expire) {
14126 ast_log(LOG_WARNING, "Minimum registration interval of %d is more than maximum of %d, resetting minimum to %d\n",
14127 min_reg_expire, max_reg_expire, max_reg_expire);
14128 min_reg_expire = max_reg_expire;
14129 }
14130 prefs_global = prefs_new;
14131 iax2_capability = capability;
14132
14133 cat = ast_category_browse(cfg, NULL);
14134 while(cat) {
14135 if (strcasecmp(cat, "general")) {
14136 utype = ast_variable_retrieve(cfg, cat, "type");
14137 if (!strcasecmp(cat, "callnumberlimits")) {
14138 build_callno_limits(ast_variable_browse(cfg, cat));
14139 } else if (utype) {
14140 if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) {
14141 user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
14142 if (user) {
14143 ao2_link(users, user);
14144 user = user_unref(user);
14145 }
14146 }
14147 if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) {
14148 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
14149 if (peer) {
14150 if (ast_test_flag64(peer, IAX_DYNAMIC))
14151 reg_source_db(peer);
14152 ao2_link(peers, peer);
14153 peer = peer_unref(peer);
14154 }
14155 } else if (strcasecmp(utype, "user")) {
14156 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file);
14157 }
14158 } else
14159 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
14160 }
14161 cat = ast_category_browse(cfg, cat);
14162 }
14163 ast_config_destroy(cfg);
14164 return 1;
14165}
14166
14167static void poke_all_peers(void)
14168{
14169 struct ao2_iterator i;
14170 struct iax2_peer *peer;
14171
14172 i = ao2_iterator_init(peers, 0);
14173 while ((peer = ao2_iterator_next(&i))) {
14174 iax2_poke_peer(peer, 0);
14175 peer_unref(peer);
14176 }
14177 ao2_iterator_destroy(&i);
14178}
14179static int reload_config(int forced_reload)
14180{
14181 static const char config[] = "iax.conf";
14182 struct iax2_registry *reg;
14183
14184 if (set_config(config, 1, forced_reload) > 0) {
14185 prune_peers();
14186 prune_users();
14187 ao2_callback(callno_limits, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
14188 ao2_callback(calltoken_ignores, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
14189 ao2_callback(peercnts, OBJ_NODATA, set_peercnt_limit_all_cb, NULL);
14190 trunk_timed = trunk_untimed = 0;
14191 trunk_nmaxmtu = trunk_maxmtu = 0;
14192 memset(&debugaddr, '\0', sizeof(debugaddr));
14193
14194 AST_LIST_LOCK(&registrations);
14195 AST_LIST_TRAVERSE(&registrations, reg, entry)
14196 iax2_do_register(reg);
14197 AST_LIST_UNLOCK(&registrations);
14198
14199 /* Qualify hosts, too */
14200 poke_all_peers();
14201 }
14202
14203 iax_firmware_reload();
14204 iax_provision_reload(1);
14205 ast_unload_realtime("iaxpeers");
14206
14207 return 0;
14208}
14209
14210static char *handle_cli_iax2_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
14211{
14212 switch (cmd) {
14213 case CLI_INIT:
14214 e->command = "iax2 reload";
14215 e->usage =
14216 "Usage: iax2 reload\n"
14217 " Reloads IAX configuration from iax.conf\n";
14218 return NULL;
14219 case CLI_GENERATE:
14220 return NULL;
14221 }
14222
14223 reload_config(0);
14224
14225 return CLI_SUCCESS;
14226}
14227
14228static int reload(void)
14229{
14230 return reload_config(0);
14231}
14232
14233static int cache_get_callno_locked(const char *data)
14234{
14235 struct ast_sockaddr addr;
14236 int x;
14237 int callno;
14238 struct iax_ie_data ied;
14239 struct create_addr_info cai;
14240 struct parsed_dial_string pds;
14241 char *tmpstr;
14242
14243 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14244 /* Look for an *exact match* call. Once a call is negotiated, it can only
14245 look up entries for a single context */
14246 if (!ast_mutex_trylock(&iaxsl[x])) {
14247 if (iaxs[x] && !strcasecmp(data, iaxs[x]->dproot))
14248 return x;
14249 ast_mutex_unlock(&iaxsl[x]);
14250 }
14251 }
14252
14253 /* No match found, we need to create a new one */
14254
14255 memset(&cai, 0, sizeof(cai));
14256 memset(&ied, 0, sizeof(ied));
14257 memset(&pds, 0, sizeof(pds));
14258
14259 tmpstr = ast_strdupa(data);
14260 parse_dial_string(tmpstr, &pds);
14261
14262 if (ast_strlen_zero(pds.peer)) {
14263 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
14264 return -1;
14265 }
14266
14267 /* Populate our address from the given */
14268 if (create_addr(pds.peer, NULL, &addr, &cai))
14269 return -1;
14270
14271 ast_debug(1, "peer: %s, username: %s, password: %s, context: %s\n",
14272 pds.peer, pds.username, pds.password, pds.context);
14273
14274 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
14275 if (callno < 1) {
14276 ast_log(LOG_WARNING, "Unable to create call\n");
14277 return -1;
14278 }
14279
14280 ast_string_field_set(iaxs[callno], dproot, data);
14281 iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH;
14282
14283 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
14284 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, "TBD");
14285 /* the string format is slightly different from a standard dial string,
14286 because the context appears in the 'exten' position
14287 */
14288 if (pds.exten)
14289 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.exten);
14290 if (pds.username)
14291 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
14292 iax_ie_append_int(&ied, IAX_IE_FORMAT, IAX_CAPABILITY_FULLBANDWIDTH);
14293 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, IAX_CAPABILITY_FULLBANDWIDTH);
14294 /* Keep password handy */
14295 if (pds.password)
14296 ast_string_field_set(iaxs[callno], secret, pds.password);
14297 if (pds.key)
14298 ast_string_field_set(iaxs[callno], outkey, pds.key);
14299 /* Start the call going */
14300 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
14301 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
14302
14303 return callno;
14304}
14305
14306static struct iax2_dpcache *find_cache(struct ast_channel *chan, const char *data, const char *context, const char *exten, int priority)
14307{
14308 struct iax2_dpcache *dp = NULL;
14309 struct timeval now = ast_tvnow();
14310 int x, com[2], timeout, doabort, callno;
14311
14312 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, cache_list) {
14313 if (ast_tvcmp(now, dp->expiry) > 0) {
14314 AST_LIST_REMOVE_CURRENT(cache_list);
14315 if ((dp->flags & CACHE_FLAG_PENDING) || dp->callno)
14316 ast_log(LOG_WARNING, "DP still has peer field or pending or callno (flags = %d, peer = blah, callno = %d)\n", dp->flags, dp->callno);
14317 else
14318 ast_free(dp);
14319 continue;
14320 }
14321 if (!strcmp(dp->peercontext, data) && !strcmp(dp->exten, exten))
14322 break;
14323 }
14324 AST_LIST_TRAVERSE_SAFE_END;
14325
14326 if (!dp) {
14327 /* No matching entry. Create a new one. */
14328 /* First, can we make a callno? */
14329 if ((callno = cache_get_callno_locked(data)) < 0) {
14330 ast_log(LOG_WARNING, "Unable to generate call for '%s'\n", data);
14331 return NULL;
14332 }
14333 if (!(dp = ast_calloc(1, sizeof(*dp)))) {
14334 ast_mutex_unlock(&iaxsl[callno]);
14335 return NULL;
14336 }
14337 ast_copy_string(dp->peercontext, data, sizeof(dp->peercontext));
14338 ast_copy_string(dp->exten, exten, sizeof(dp->exten));
14339 dp->expiry = ast_tvnow();
14340 dp->orig = dp->expiry;
14341 /* Expires in 30 mins by default */
14342 dp->expiry.tv_sec += iaxdefaultdpcache;
14343 dp->flags = CACHE_FLAG_PENDING;
14344 for (x = 0; x < ARRAY_LEN(dp->waiters); x++)
14345 dp->waiters[x] = -1;
14346 /* Insert into the lists */
14347 AST_LIST_INSERT_TAIL(&dpcache, dp, cache_list);
14348 AST_LIST_INSERT_TAIL(&iaxs[callno]->dpentries, dp, peer_list);
14349 /* Send the request if we're already up */
14350 if (ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
14351 iax2_dprequest(dp, callno);
14352 ast_mutex_unlock(&iaxsl[callno]);
14353 }
14354
14355 /* By here we must have a dp */
14356 if (dp->flags & CACHE_FLAG_PENDING) {
14357 int res;
14358 struct pollfd pfd;
14359 /* Okay, here it starts to get nasty. We need a pipe now to wait
14360 for a reply to come back so long as it's pending */
14361 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
14362 /* Find an empty slot */
14363 if (dp->waiters[x] < 0)
14364 break;
14365 }
14366 if (x >= ARRAY_LEN(dp->waiters)) {
14367 ast_log(LOG_WARNING, "No more waiter positions available\n");
14368 return NULL;
14369 }
14370 if (pipe(com)) {
14371 ast_log(LOG_WARNING, "Unable to create pipe for comm\n");
14372 return NULL;
14373 }
14374 dp->waiters[x] = com[1];
14375 /* Okay, now we wait */
14376 timeout = iaxdefaulttimeout * 1000;
14377 /* Temporarily unlock */
14378 AST_LIST_UNLOCK(&dpcache);
14379 doabort = 0;
14380
14381 /* chan is in autoservice here, so do NOT service it here! */
14382 pfd.fd = com[0];
14383 pfd.events = POLLIN;
14384 pfd.revents = 0;
14385 /* Wait for pipe activity... if the channel hangs up, we'll catch it on the way out. */
14386 res = ast_poll(&pfd, 1, timeout);
14387 if (res < 0) {
14388 ast_log(LOG_WARNING, "poll returned < 0: %s\n", strerror(errno));
14389 return NULL;
14390 } else if (!pfd.revents) {
14391 ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten);
14392 }
14393
14394 if (chan && ast_check_hangup(chan)) {
14395 doabort = 1;
14396 }
14397
14398 AST_LIST_LOCK(&dpcache);
14399 dp->waiters[x] = -1;
14400 close(com[1]);
14401 close(com[0]);
14402 if (doabort) {
14403 /* Don't interpret anything, just abort. */
14404 return NULL;
14405 }
14406 if (!(dp->flags & CACHE_FLAG_TIMEOUT)) {
14407 /* Now to do non-independent analysis the results of our wait */
14408 if (dp->flags & CACHE_FLAG_PENDING) {
14409 /* Still pending... It's a timeout. Wake everybody up. Consider it no longer
14410 pending. Don't let it take as long to timeout. */
14411 dp->flags &= ~CACHE_FLAG_PENDING;
14412 dp->flags |= CACHE_FLAG_TIMEOUT;
14413 /* Expire after only 60 seconds now. This is designed to help reduce backlog in heavily loaded
14414 systems without leaving it unavailable once the server comes back online */
14415 dp->expiry.tv_sec = dp->orig.tv_sec + 60;
14416 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
14417 if (dp->waiters[x] > -1) {
14418 if (write(dp->waiters[x], "asdf", 4) < 0) {
14419 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
14420 }
14421 }
14422 }
14423 }
14424 }
14425 /* Our caller will obtain the rest */
14426 }
14427 return dp;
14428}
14429
14430/*! \brief Part of the IAX2 switch interface */
14431static int iax2_exists(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
14432{
14433 int res = 0;
14434 struct iax2_dpcache *dp = NULL;
14435#if 0
14436 ast_log(LOG_NOTICE, "iax2_exists: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14437#endif
14438 if ((priority != 1) && (priority != 2))
14439 return 0;
14440
14441 AST_LIST_LOCK(&dpcache);
14442 if ((dp = find_cache(chan, data, context, exten, priority))) {
14443 if (dp->flags & CACHE_FLAG_EXISTS)
14444 res = 1;
14445 } else {
14446 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14447 }
14448 AST_LIST_UNLOCK(&dpcache);
14449
14450 return res;
14451}
14452
14453/*! \brief part of the IAX2 dial plan switch interface */
14454static int iax2_canmatch(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
14455{
14456 int res = 0;
14457 struct iax2_dpcache *dp = NULL;
14458#if 0
14459 ast_log(LOG_NOTICE, "iax2_canmatch: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14460#endif
14461 if ((priority != 1) && (priority != 2))
14462 return 0;
14463
14464 AST_LIST_LOCK(&dpcache);
14465 if ((dp = find_cache(chan, data, context, exten, priority))) {
14466 if (dp->flags & CACHE_FLAG_CANEXIST)
14467 res = 1;
14468 } else {
14469 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14470 }
14471 AST_LIST_UNLOCK(&dpcache);
14472
14473 return res;
14474}
14475
14476/*! \brief Part of the IAX2 Switch interface */
14477static int iax2_matchmore(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
14478{
14479 int res = 0;
14480 struct iax2_dpcache *dp = NULL;
14481#if 0
14482 ast_log(LOG_NOTICE, "iax2_matchmore: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14483#endif
14484 if ((priority != 1) && (priority != 2))
14485 return 0;
14486
14487 AST_LIST_LOCK(&dpcache);
14488 if ((dp = find_cache(chan, data, context, exten, priority))) {
14489 if (dp->flags & CACHE_FLAG_MATCHMORE)
14490 res = 1;
14491 } else {
14492 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14493 }
14494 AST_LIST_UNLOCK(&dpcache);
14495
14496 return res;
14497}
14498
14499/*! \brief Execute IAX2 dialplan switch */
14500static int iax2_exec(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
14501{
14502 char odata[256];
14503 char req[sizeof(odata) + AST_MAX_CONTEXT + AST_MAX_EXTENSION + sizeof("IAX2//@")];
14504 char *ncontext;
14505 struct iax2_dpcache *dp = NULL;
14506 struct ast_app *dial = NULL;
14507#if 0
14508 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);
14509#endif
14510 if (priority == 2) {
14511 /* Indicate status, can be overridden in dialplan */
14512 const char *dialstatus = pbx_builtin_getvar_helper(chan, "DIALSTATUS");
14513 if (dialstatus) {
14514 dial = pbx_findapp(dialstatus);
14515 if (dial)
14516 pbx_exec(chan, dial, "");
14517 }
14518 return -1;
14519 } else if (priority != 1)
14520 return -1;
14521
14522 AST_LIST_LOCK(&dpcache);
14523 if ((dp = find_cache(chan, data, context, exten, priority))) {
14524 if (dp->flags & CACHE_FLAG_EXISTS) {
14525 ast_copy_string(odata, data, sizeof(odata));
14526 ncontext = strchr(odata, '/');
14527 if (ncontext) {
14528 *ncontext = '\0';
14529 ncontext++;
14530 snprintf(req, sizeof(req), "IAX2/%s/%s@%s", odata, exten, ncontext);
14531 } else {
14532 snprintf(req, sizeof(req), "IAX2/%s/%s", odata, exten);
14533 }
14534 ast_verb(3, "Executing Dial('%s')\n", req);
14535 } else {
14536 AST_LIST_UNLOCK(&dpcache);
14537 ast_log(LOG_WARNING, "Can't execute nonexistent extension '%s[@%s]' in data '%s'\n", exten, context, data);
14538 return -1;
14539 }
14540 }
14541 AST_LIST_UNLOCK(&dpcache);
14542
14543 if ((dial = pbx_findapp("Dial")))
14544 return pbx_exec(chan, dial, req);
14545 else
14546 ast_log(LOG_WARNING, "No dial application registered\n");
14547
14548 return -1;
14549}
14550
14551static int function_iaxpeer(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
14552{
14553 struct iax2_peer *peer;
14554 char *peername, *colname;
14555
14556 peername = ast_strdupa(data);
14557
14558 /* if our channel, return the IP address of the endpoint of current channel */
14559 if (!strcmp(peername,"CURRENTCHANNEL")) {
14560 unsigned short callno;
14561 if (!chan || ast_channel_tech(chan) != &iax2_tech) {
14562 return -1;
14563 }
14564 callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
14565 ast_copy_string(buf, !ast_sockaddr_isnull(&iaxs[callno]->addr) ? ast_sockaddr_stringify_addr(&iaxs[callno]->addr) : "", len);
14566 return 0;
14567 }
14568
14569 if ((colname = strchr(peername, ',')))
14570 *colname++ = '\0';
14571 else
14572 colname = "ip";
14573
14574 if (!(peer = find_peer(peername, 1)))
14575 return -1;
14576
14577 if (!strcasecmp(colname, "ip")) {
14578 ast_copy_string(buf, ast_sockaddr_stringify_addr(&peer->addr), len);
14579 } else if (!strcasecmp(colname, "status")) {
14580 peer_status(peer, buf, len);
14581 } else if (!strcasecmp(colname, "mailbox")) {
14582 ast_copy_string(buf, peer->mailbox, len);
14583 } else if (!strcasecmp(colname, "context")) {
14584 ast_copy_string(buf, peer->context, len);
14585 } else if (!strcasecmp(colname, "expire")) {
14586 snprintf(buf, len, "%d", peer->expire);
14587 } else if (!strcasecmp(colname, "dynamic")) {
14588 ast_copy_string(buf, (ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no"), len);
14589 } else if (!strcasecmp(colname, "callerid_name")) {
14590 ast_copy_string(buf, peer->cid_name, len);
14591 } else if (!strcasecmp(colname, "callerid_num")) {
14592 ast_copy_string(buf, peer->cid_num, len);
14593 } else if (!strcasecmp(colname, "codecs")) {
14594 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
14595
14596 iax2_getformatname_multiple(peer->capability, &codec_buf);
14597 ast_copy_string(buf, ast_str_buffer(codec_buf), len);
14598 } else if (!strncasecmp(colname, "codec[", 6)) {
14599 char *codecnum, *ptr;
14600 struct ast_format *tmpfmt;
14601
14602 /* skip over "codec" to the '[' */
14603 codecnum = colname + 5;
14604 *codecnum = '\0';
14605 codecnum++;
14606 if ((ptr = strchr(codecnum, ']'))) {
14607 *ptr = '\0';
14608 }
14609 if((iax2_codec_pref_index(&peer->prefs, atoi(codecnum), &tmpfmt))) {
14610 ast_copy_string(buf, ast_format_get_name(tmpfmt), len);
14611 } else {
14612 buf[0] = '\0';
14613 }
14614 } else {
14615 buf[0] = '\0';
14616 }
14617
14618 peer_unref(peer);
14619
14620 return 0;
14621}
14622
14623static struct ast_custom_function iaxpeer_function = {
14624 .name = "IAXPEER",
14625 .read = function_iaxpeer,
14626};
14627
14628static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *args, char *buf, size_t buflen)
14629{
14630 struct chan_iax2_pvt *pvt;
14631 unsigned int callno;
14632 int res = 0;
14633
14634 if (!chan || ast_channel_tech(chan) != &iax2_tech) {
14635 ast_log(LOG_ERROR, "This function requires a valid IAX2 channel\n");
14636 return -1;
14637 }
14638
14639 callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
14640 ast_mutex_lock(&iaxsl[callno]);
14641 if (!(pvt = iaxs[callno])) {
14642 ast_mutex_unlock(&iaxsl[callno]);
14643 return -1;
14644 }
14645
14646 if (!strcasecmp(args, "osptoken")) {
14647 ast_copy_string(buf, pvt->osptoken, buflen);
14648 } else if (!strcasecmp(args, "peerip")) {
14649 ast_copy_string(buf, !ast_sockaddr_isnull(&pvt->addr) ? ast_sockaddr_stringify_addr(&pvt->addr) : "", buflen);
14650 } else if (!strcasecmp(args, "peername")) {
14651 ast_copy_string(buf, pvt->username, buflen);
14652 } else if (!strcasecmp(args, "auth_method")) {
14653 ast_copy_string(buf, auth_method_labels[pvt->eff_auth_method], buflen);
14654 } else if (!strcasecmp(args, "secure_signaling") || !strcasecmp(args, "secure_media")) {
14655 snprintf(buf, buflen, "%s", IAX_CALLENCRYPTED(pvt) ? "1" : "");
14656 } else {
14657 res = -1;
14658 }
14659
14660 ast_mutex_unlock(&iaxsl[callno]);
14661
14662 return res;
14663}
14664
14665/*! \brief Part of the device state notification system ---*/
14666static int iax2_devicestate(const char *data)
14667{
14668 struct parsed_dial_string pds;
14669 char *tmp = ast_strdupa(data);
14670 struct iax2_peer *p;
14671 int res = AST_DEVICE_INVALID;
14672
14673 memset(&pds, 0, sizeof(pds));
14674 parse_dial_string(tmp, &pds);
14675
14676 if (ast_strlen_zero(pds.peer)) {
14677 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
14678 return res;
14679 }
14680
14681 ast_debug(3, "Checking device state for device %s\n", pds.peer);
14682
14683 /* SLD: FIXME: second call to find_peer during registration */
14684 if (!(p = find_peer(pds.peer, 1)))
14685 return res;
14686
14687 res = AST_DEVICE_UNAVAILABLE;
14688
14689 ast_debug(3, "Found peer. What's device state of %s? addr=%s, defaddr=%s maxms=%d, lastms=%d\n",
14690 pds.peer, ast_sockaddr_stringify(&p->addr), ast_sockaddr_stringify(&p->defaddr), p->maxms, p->lastms);
14691
14692 if (((!ast_sockaddr_isnull(&p->addr)) || (!ast_sockaddr_isnull(&p->defaddr))) &&
14693 (!p->maxms || ((p->lastms > -1) && (p->historicms <= p->maxms)))) {
14694 /* Peer is registered, or have default IP address
14695 and a valid registration */
14696 if (p->historicms == 0 || p->historicms <= p->maxms)
14697 /* let the core figure out whether it is in use or not */
14698 res = AST_DEVICE_UNKNOWN;
14699 }
14700
14701 peer_unref(p);
14702
14703 return res;
14704}
14705
14706static struct ast_switch iax2_switch =
14707{
14708 .name = "IAX2",
14709 .description = "IAX Remote Dialplan Switch",
14710 .exists = iax2_exists,
14711 .canmatch = iax2_canmatch,
14712 .exec = iax2_exec,
14713 .matchmore = iax2_matchmore,
14714};
14715
14716static struct ast_cli_entry cli_iax2[] = {
14717 AST_CLI_DEFINE(handle_cli_iax2_provision, "Provision an IAX device"),
14718 AST_CLI_DEFINE(handle_cli_iax2_prune_realtime, "Prune a cached realtime lookup"),
14719 AST_CLI_DEFINE(handle_cli_iax2_reload, "Reload IAX configuration"),
14720 AST_CLI_DEFINE(handle_cli_iax2_set_mtu, "Set the IAX systemwide trunking MTU"),
14721 AST_CLI_DEFINE(handle_cli_iax2_set_debug, "Enable/Disable IAX debugging"),
14722 AST_CLI_DEFINE(handle_cli_iax2_set_debug_trunk, "Enable/Disable IAX trunk debugging"),
14723 AST_CLI_DEFINE(handle_cli_iax2_set_debug_jb, "Enable/Disable IAX jitterbuffer debugging"),
14724 AST_CLI_DEFINE(handle_cli_iax2_show_cache, "Display IAX cached dialplan"),
14725 AST_CLI_DEFINE(handle_cli_iax2_show_channels, "List active IAX channels"),
14726 AST_CLI_DEFINE(handle_cli_iax2_show_firmware, "List available IAX firmware"),
14727 AST_CLI_DEFINE(handle_cli_iax2_show_netstats, "List active IAX channel netstats"),
14728 AST_CLI_DEFINE(handle_cli_iax2_show_peer, "Show details on specific IAX peer"),
14729 AST_CLI_DEFINE(handle_cli_iax2_show_peers, "List defined IAX peers"),
14730 AST_CLI_DEFINE(handle_cli_iax2_show_registry, "Display IAX registration status"),
14731 AST_CLI_DEFINE(handle_cli_iax2_show_stats, "Display IAX statistics"),
14732 AST_CLI_DEFINE(handle_cli_iax2_show_threads, "Display IAX helper thread info"),
14733 AST_CLI_DEFINE(handle_cli_iax2_show_users, "List defined IAX users"),
14734 AST_CLI_DEFINE(handle_cli_iax2_test_losspct, "Set IAX2 incoming frame loss percentage"),
14735 AST_CLI_DEFINE(handle_cli_iax2_unregister, "Unregister (force expiration) an IAX2 peer from the registry"),
14736 AST_CLI_DEFINE(handle_cli_iax2_show_callno_limits, "Show current entries in IP call number limit table"),
14737#ifdef IAXTESTS
14738 AST_CLI_DEFINE(handle_cli_iax2_test_jitter, "Simulates jitter for testing"),
14739 AST_CLI_DEFINE(handle_cli_iax2_test_late, "Test the receipt of a late frame"),
14740 AST_CLI_DEFINE(handle_cli_iax2_test_resync, "Test a resync in received timestamps"),
14741#endif /* IAXTESTS */
14742};
14743
14744static void cleanup_thread_list(void *head)
14745{
14746 AST_LIST_HEAD(iax2_thread_list, iax2_thread);
14747 struct iax2_thread_list *list_head = head;
14748 struct iax2_thread *thread;
14749
14750 AST_LIST_LOCK(list_head);
14751 while ((thread = AST_LIST_REMOVE_HEAD(list_head, list))) {
14752 pthread_t thread_id = thread->threadid;
14753
14754 thread->stop = 1;
14755 signal_condition(&thread->lock, &thread->cond);
14756
14757 AST_LIST_UNLOCK(list_head);
14758 pthread_join(thread_id, NULL);
14759 AST_LIST_LOCK(list_head);
14760 }
14761 AST_LIST_UNLOCK(list_head);
14762}
14763
14764static int __unload_module(void)
14765{
14766 int x;
14767
14768 network_change_stasis_unsubscribe();
14769 acl_change_stasis_unsubscribe();
14770
14771 ast_manager_unregister("IAXpeers");
14772 ast_manager_unregister("IAXpeerlist");
14773 ast_manager_unregister("IAXnetstats");
14774 ast_manager_unregister("IAXregistry");
14775 ast_unregister_application(papp);
14776 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14777 ast_unregister_switch(&iax2_switch);
14778 ast_channel_unregister(&iax2_tech);
14779
14780 if (netthreadid != AST_PTHREADT_NULL) {
14781 pthread_cancel(netthreadid);
14782 pthread_kill(netthreadid, SIGURG);
14783 pthread_join(netthreadid, NULL);
14784 }
14785
14786 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14787 if (iaxs[x]) {
14788 iax2_destroy(x);
14789 }
14790 }
14791
14792 /* Call for all threads to halt */
14793 cleanup_thread_list(&active_list);
14794 cleanup_thread_list(&dynamic_list);
14795 cleanup_thread_list(&idle_list);
14796
14797 ast_netsock_release(netsock);
14798 ast_netsock_release(outsock);
14799 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14800 if (iaxs[x]) {
14801 iax2_destroy(x);
14802 }
14803 }
14804 ast_manager_unregister( "IAXpeers" );
14805 ast_manager_unregister( "IAXpeerlist" );
14806 ast_manager_unregister( "IAXnetstats" );
14807 ast_manager_unregister( "IAXregistry" );
14808 ast_unregister_application(papp);
14809 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14810 ast_unregister_switch(&iax2_switch);
14811 ast_channel_unregister(&iax2_tech);
14812 delete_users();
14813 iax_provision_unload();
14814 iax_firmware_unload();
14815
14816 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
14817 ast_mutex_destroy(&iaxsl[x]);
14818 }
14819
14820 ao2_ref(peers, -1);
14821 ao2_ref(users, -1);
14822 ao2_ref(iax_peercallno_pvts, -1);
14823 ao2_ref(iax_transfercallno_pvts, -1);
14824 ao2_ref(callno_limits, -1);
14825 ao2_ref(calltoken_ignores, -1);
14826 if (timer) {
14827 ast_timer_close(timer);
14828 timer = NULL;
14829 }
14830 transmit_processor = ast_taskprocessor_unreference(transmit_processor);
14831
14832 ast_sched_clean_by_callback(sched, peercnt_remove_cb, peercnt_remove_cb);
14833 ast_sched_context_destroy(sched);
14834 sched = NULL;
14835 ao2_ref(peercnts, -1);
14836
14837 ast_context_destroy_by_name(regcontext, "IAX2");
14838 ast_unload_realtime("iaxpeers");
14839
14840 ao2_ref(iax2_tech.capabilities, -1);
14841 iax2_tech.capabilities = NULL;
14842 return 0;
14843}
14844
14845static int unload_module(void)
14846{
14847 ast_custom_function_unregister(&iaxpeer_function);
14848 ast_custom_function_unregister(&iaxvar_function);
14849 return __unload_module();
14850}
14851
14852static int peer_set_sock_cb(void *obj, void *arg, int flags)
14853{
14854 struct iax2_peer *peer = obj;
14855
14856 if (peer->sockfd < 0)
14857 peer->sockfd = defaultsockfd;
14858
14859 return 0;
14860}
14861
14862static int pvt_hash_cb(const void *obj, const int flags)
14863{
14864 const struct chan_iax2_pvt *pvt = obj;
14865
14866 return pvt->peercallno;
14867}
14868
14869static int pvt_cmp_cb(void *obj, void *arg, int flags)
14870{
14871 struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
14872
14873 /* The frames_received field is used to hold whether we're matching
14874 * against a full frame or not ... */
14875
14876 return match(&pvt2->addr, pvt2->peercallno, pvt2->callno, pvt,
14877 pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
14878}
14879
14880static int transfercallno_pvt_hash_cb(const void *obj, const int flags)
14881{
14882 const struct chan_iax2_pvt *pvt = obj;
14883
14884 return pvt->transfercallno;
14885}
14886
14887static int transfercallno_pvt_cmp_cb(void *obj, void *arg, int flags)
14888{
14889 struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
14890
14891 /* The frames_received field is used to hold whether we're matching
14892 * against a full frame or not ... */
14893
14894 return match(&pvt2->transfer, pvt2->transfercallno, pvt2->callno, pvt,
14895 pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
14896}
14897
14898static int load_objects(void)
14899{
14900 peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
14901 peercnts = callno_limits = calltoken_ignores = NULL;
14902
14903 peers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
14904 peer_hash_cb, NULL, peer_cmp_cb);
14905 if (!peers) {
14906 goto container_fail;
14907 }
14908
14909 users = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_USER_BUCKETS,
14910 user_hash_cb, NULL, user_cmp_cb);
14911 if (!users) {
14912 goto container_fail;
14913 }
14914
14915 iax_peercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14916 IAX_MAX_CALLS, pvt_hash_cb, NULL, pvt_cmp_cb);
14917 if (!iax_peercallno_pvts) {
14918 goto container_fail;
14919 }
14920
14921 iax_transfercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14922 IAX_MAX_CALLS, transfercallno_pvt_hash_cb, NULL, transfercallno_pvt_cmp_cb);
14923 if (!iax_transfercallno_pvts) {
14924 goto container_fail;
14925 }
14926
14927 peercnts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
14928 peercnt_hash_cb, NULL, peercnt_cmp_cb);
14929 if (!peercnts) {
14930 goto container_fail;
14931 }
14932
14933 callno_limits = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14934 MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
14935 if (!callno_limits) {
14936 goto container_fail;
14937 }
14938
14939 calltoken_ignores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14940 MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
14941 if (!calltoken_ignores) {
14942 goto container_fail;
14943 }
14944
14945 if (create_callno_pools()) {
14946 goto container_fail;
14947 }
14948
14949 transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT);
14950 if (!transmit_processor) {
14951 goto container_fail;
14952 }
14953
14954 return 0;
14955
14956container_fail:
14957 if (peers) {
14958 ao2_ref(peers, -1);
14959 }
14960 if (users) {
14961 ao2_ref(users, -1);
14962 }
14963 if (iax_peercallno_pvts) {
14964 ao2_ref(iax_peercallno_pvts, -1);
14965 }
14966 if (iax_transfercallno_pvts) {
14967 ao2_ref(iax_transfercallno_pvts, -1);
14968 }
14969 if (peercnts) {
14970 ao2_ref(peercnts, -1);
14971 }
14972 if (callno_limits) {
14973 ao2_ref(callno_limits, -1);
14974 }
14975 if (calltoken_ignores) {
14976 ao2_ref(calltoken_ignores, -1);
14977 }
14978 return -1;
14979}
14980
14981/*!
14982 * \brief Load the module
14983 *
14984 * Module loading including tests for configuration or dependencies.
14985 * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
14986 * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
14987 * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
14988 * configuration file or other non-critical problem return
14989 * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
14990 */
14991static int load_module(void)
14992{
14993 static const char config[] = "iax.conf";
14994 int x = 0;
14995 struct iax2_registry *reg = NULL;
14996
14997 if (!(iax2_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
14998 return AST_MODULE_LOAD_DECLINE;
14999 }
15000 ast_format_cap_append_by_type(iax2_tech.capabilities, AST_MEDIA_TYPE_UNKNOWN);
15001
15002 if (load_objects()) {
15003 ao2_ref(iax2_tech.capabilities, -1);
15004 iax2_tech.capabilities = NULL;
15005 return AST_MODULE_LOAD_DECLINE;
15006 }
15007
15008 memset(iaxs, 0, sizeof(iaxs));
15009
15010 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
15011 ast_mutex_init(&iaxsl[x]);
15012 }
15013
15014 if (!(sched = ast_sched_context_create())) {
15015 ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
15016 ao2_ref(iax2_tech.capabilities, -1);
15017 iax2_tech.capabilities = NULL;
15018 return AST_MODULE_LOAD_DECLINE;
15019 }
15020
15021 if (ast_sched_start_thread(sched)) {
15022 ast_sched_context_destroy(sched);
15023 ao2_ref(iax2_tech.capabilities, -1);
15024 iax2_tech.capabilities = NULL;
15025 sched = NULL;
15026 return AST_MODULE_LOAD_DECLINE;
15027 }
15028
15029 if (!(io = io_context_create())) {
15030 ast_log(LOG_ERROR, "Failed to create I/O context\n");
15031 ast_sched_context_destroy(sched);
15032 ao2_ref(iax2_tech.capabilities, -1);
15033 iax2_tech.capabilities = NULL;
15034 sched = NULL;
15035 return AST_MODULE_LOAD_DECLINE;
15036 }
15037
15038 if (!(netsock = ast_netsock_list_alloc())) {
15039 ast_log(LOG_ERROR, "Failed to create netsock list\n");
15040 io_context_destroy(io);
15041 ast_sched_context_destroy(sched);
15042 ao2_ref(iax2_tech.capabilities, -1);
15043 iax2_tech.capabilities = NULL;
15044 sched = NULL;
15045 return AST_MODULE_LOAD_DECLINE;
15046 }
15047 ast_netsock_init(netsock);
15048
15049 outsock = ast_netsock_list_alloc();
15050 if (!outsock) {
15051 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
15052 io_context_destroy(io);
15053 ast_sched_context_destroy(sched);
15054 ao2_ref(iax2_tech.capabilities, -1);
15055 iax2_tech.capabilities = NULL;
15056 sched = NULL;
15057 return AST_MODULE_LOAD_DECLINE;
15058 }
15059 ast_netsock_init(outsock);
15060
15061 randomcalltokendata = ast_random();
15062
15063 iax_set_output(iax_debug_output);
15064 iax_set_error(iax_error_output);
15065 jb_setoutput(jb_error_output, jb_warning_output, NULL);
15066
15067 if ((timer = ast_timer_open())) {
15068 ast_timer_set_rate(timer, 1000 / trunkfreq);
15069 }
15070
15071 if (set_config(config, 0, 0) == -1) {
15072 if (timer) {
15073 ast_timer_close(timer);
15074 timer = NULL;
15075 }
15076 __unload_module();
15077 return AST_MODULE_LOAD_DECLINE;
15078 }
15079
15080 ast_cli_register_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
15081
15082 ast_register_application_xml(papp, iax2_prov_app);
15083
15084 ast_custom_function_register(&iaxpeer_function);
15085 ast_custom_function_register(&iaxvar_function);
15086
15087 ast_manager_register_xml("IAXpeers", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peers);
15088 ast_manager_register_xml("IAXpeerlist", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peer_list);
15089 ast_manager_register_xml("IAXnetstats", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_netstats);
15090 ast_manager_register_xml("IAXregistry", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_registry);
15091
15092 if (ast_channel_register(&iax2_tech)) {
15093 ast_log(LOG_ERROR, "Unable to register channel class %s\n", "IAX2");
15094 __unload_module();
15095 return AST_MODULE_LOAD_DECLINE;
15096 }
15097
15098 if (ast_register_switch(&iax2_switch)) {
15099 ast_log(LOG_ERROR, "Unable to register IAX switch\n");
15100 }
15101
15102 if (start_network_thread()) {
15103 ast_log(LOG_ERROR, "Unable to start network thread\n");
15104 __unload_module();
15105 return AST_MODULE_LOAD_DECLINE;
15106 } else {
15107 ast_verb(2, "IAX Ready and Listening\n");
15108 }
15109
15110 AST_LIST_LOCK(&registrations);
15111 AST_LIST_TRAVERSE(&registrations, reg, entry)
15112 iax2_do_register(reg);
15113 AST_LIST_UNLOCK(&registrations);
15114
15115 ao2_callback(peers, 0, peer_set_sock_cb, NULL);
15116 ao2_callback(peers, 0, iax2_poke_peer_cb, NULL);
15117
15118
15119 iax_firmware_reload();
15120 iax_provision_reload(0);
15121
15122 ast_realtime_require_field("iaxpeers", "name", RQ_CHAR, 10, "ipaddr", RQ_CHAR, 15, "port", RQ_UINTEGER2, 5, "regseconds", RQ_UINTEGER2, 6, SENTINEL);
15123
15124 network_change_stasis_subscribe();
15125
15126 return AST_MODULE_LOAD_SUCCESS;
15127}
15128
15129AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Inter Asterisk eXchange (Ver 2)",
15130 .support_level = AST_MODULE_SUPPORT_CORE,
15131 .load = load_module,
15132 .unload = unload_module,
15133 .reload = reload,
15134 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
15135 .requires = "dnsmgr",
15136 .optional_modules = "res_crypto",
15137);
ast_apply_acl
enum ast_acl_sense ast_apply_acl(struct ast_acl_list *acl_list, const struct ast_sockaddr *addr, const char *purpose)
Apply a set of rules to a given IP address.
Definition acl.c:799
ast_free_ha
void ast_free_ha(struct ast_ha *ha)
Free a list of HAs.
Definition acl.c:222
ast_str2tos
int ast_str2tos(const char *value, unsigned int *tos)
Convert a string to the appropriate TOS value.
Definition acl.c:983
ast_named_acl_change_type
struct stasis_message_type * ast_named_acl_change_type(void)
a stasis_message_type for changes against a named ACL or the set of all named ACLs
ast_copy_ha
void ast_copy_ha(const struct ast_ha *from, struct ast_ha *to)
Copy the contents of one HA to another.
Definition acl.c:255
ast_append_acl
void ast_append_acl(const char *sense, const char *stuff, struct ast_acl_list **path, int *error, int *named_acl_flag)
Add a rule to an ACL struct.
Definition acl.c:429
AST_SENSE_ALLOW
@ AST_SENSE_ALLOW
Definition acl.h:38
AST_SENSE_DENY
@ AST_SENSE_DENY
Definition acl.h:37
ast_get_ip
int ast_get_ip(struct ast_sockaddr *addr, const char *hostname)
Get the IP address given a hostname.
Definition acl.c:1016
ast_acl_list_is_empty
int ast_acl_list_is_empty(struct ast_acl_list *acl_list)
Determines if an ACL is empty or if it contains entries.
Definition acl.c:540
ast_str2cos
int ast_str2cos(const char *value, unsigned int *cos)
Convert a string to the appropriate COS value.
Definition acl.c:969
ast_free_acl_list
struct ast_acl_list * ast_free_acl_list(struct ast_acl_list *acl)
Free a list of ACLs.
Definition acl.c:233
ast_append_ha
struct ast_ha * ast_append_ha(const char *sense, const char *stuff, struct ast_ha *path, int *error)
Add a new rule to a list of HAs.
Definition acl.c:712
ast_get_ip_or_srv
int ast_get_ip_or_srv(struct ast_sockaddr *addr, const char *hostname, const char *service)
Get the IP address given a hostname and optional service.
Definition acl.c:933
ast_cli_unregister_multiple
void ast_cli_unregister_multiple(void)
Definition ael_main.c:408
events
static const struct adsi_event events[]
Definition app_adsiprog.c:88
digit
char digit
Definition app_alarmreceiver.c:131
status
jack_status_t status
Definition app_jack.c:149
thread
pthread_t thread
Definition app_sla.c:335
cond
ast_cond_t cond
Definition app_sla.c:336
lock
ast_mutex_t lock
Definition app_sla.c:337
zonetag
static char zonetag[80]
Definition app_voicemail.c:1104
copy
static int copy(char *infile, char *outfile)
Utility function to copy a file.
Definition app_voicemail.c:5104
var
#define var
Definition ast_expr2f.c:605
ast_db_put
int ast_db_put(const char *family, const char *key, const char *value)
Store value addressed by family/key.
Definition db.c:335
ast_db_get
int ast_db_get(const char *family, const char *key, char *value, int valuelen)
Get key value specified by family/key.
Definition db.c:421
ast_db_del
int ast_db_del(const char *family, const char *key)
Delete entry in astdb.
Definition db.c:472
strsep
char * strsep(char **str, const char *delims)
ast_alloca
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition astmm.h:288
ast_free
#define ast_free(a)
Definition astmm.h:180
ast_realloc
#define ast_realloc(p, len)
A wrapper for realloc()
Definition astmm.h:226
ast_strdup
#define ast_strdup(str)
A wrapper for strdup()
Definition astmm.h:241
ast_strdupa
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition astmm.h:298
ast_free_ptr
void ast_free_ptr(void *ptr)
free() wrapper
Definition astmm.c:1739
ast_calloc
#define ast_calloc(num, len)
A wrapper for calloc()
Definition astmm.h:202
ast_malloc
#define ast_malloc(len)
A wrapper for malloc()
Definition astmm.h:191
ast_log
#define ast_log
Definition astobj2.c:42
ao2_iterator_next
#define ao2_iterator_next(iter)
Definition astobj2.h:1911
ao2_link
#define ao2_link(container, obj)
Add an object to a container.
Definition astobj2.h:1532
CMP_MATCH
@ CMP_MATCH
Definition astobj2.h:1027
CMP_STOP
@ CMP_STOP
Definition astobj2.h:1028
OBJ_KEY
#define OBJ_KEY
Definition astobj2.h:1151
OBJ_POINTER
#define OBJ_POINTER
Definition astobj2.h:1150
AO2_ALLOC_OPT_LOCK_MUTEX
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition astobj2.h:363
ao2_callback
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition astobj2.h:1693
ao2_cleanup
#define ao2_cleanup(obj)
Definition astobj2.h:1934
ao2_unlink
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition astobj2.h:1578
ao2_find
#define ao2_find(container, arg, flags)
Definition astobj2.h:1736
ao2_iterator_init
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
Definition astobj2_container.c:485
ao2_unlock
#define ao2_unlock(a)
Definition astobj2.h:729
ao2_lock
#define ao2_lock(a)
Definition astobj2.h:717
ao2_ref
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition astobj2.h:459
ao2_iterator_destroy
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
Definition astobj2_container.c:534
OBJ_NODATA
@ OBJ_NODATA
Definition astobj2.h:1044
OBJ_MULTIPLE
@ OBJ_MULTIPLE
Definition astobj2.h:1049
OBJ_UNLINK
@ OBJ_UNLINK
Definition astobj2.h:1039
ao2_alloc
#define ao2_alloc(data_size, destructor_fn)
Definition astobj2.h:409
ao2_container_alloc_hash
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition astobj2.h:1303
ast_bridge_transfer_blind
enum ast_transfer_result ast_bridge_transfer_blind(int is_external, struct ast_channel *transferer, const char *exten, const char *context, transfer_channel_cb new_channel_cb, void *user_data)
Blind transfer target to the extension and context provided.
Definition bridge.c:4634
AST_BRIDGE_TRANSFER_SUCCESS
@ AST_BRIDGE_TRANSFER_SUCCESS
Definition bridge.h:1161
AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN
#define AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN
Definition callerid.h:440
ast_callerid_merge
char * ast_callerid_merge(char *buf, int bufsiz, const char *name, const char *num, const char *unknown)
Definition callerid.c:1273
AST_PRES_NUMBER_NOT_AVAILABLE
#define AST_PRES_NUMBER_NOT_AVAILABLE
Definition callerid.h:461
ast_shrink_phone_number
void ast_shrink_phone_number(char *n)
Shrink a phone number in place to just digits (more accurately it just removes ()'s,...
Definition callerid.c:1101
ast_callerid_split
int ast_callerid_split(const char *src, char *name, int namelen, char *num, int numlen)
Definition callerid.c:1292
AST_CAUSE_CONGESTION
#define AST_CAUSE_CONGESTION
Definition causes.h:153
AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
#define AST_CAUSE_BEARERCAPABILITY_NOTAVAIL
Definition causes.h:130
AST_CAUSE_DESTINATION_OUT_OF_ORDER
#define AST_CAUSE_DESTINATION_OUT_OF_ORDER
Definition causes.h:115
AST_CAUSE_NO_USER_RESPONSE
#define AST_CAUSE_NO_USER_RESPONSE
Definition causes.h:108
AST_CAUSE_FACILITY_NOT_SUBSCRIBED
#define AST_CAUSE_FACILITY_NOT_SUBSCRIBED
Definition causes.h:126
AST_CAUSE_CALL_REJECTED
#define AST_CAUSE_CALL_REJECTED
Definition causes.h:111
AST_CAUSE_FACILITY_REJECTED
#define AST_CAUSE_FACILITY_REJECTED
Definition causes.h:117
AST_CAUSE_NO_ROUTE_DESTINATION
#define AST_CAUSE_NO_ROUTE_DESTINATION
Definition causes.h:100
AST_CAUSE_UNREGISTERED
#define AST_CAUSE_UNREGISTERED
Definition causes.h:154
AST_CAUSE_BUSY
#define AST_CAUSE_BUSY
Definition causes.h:149
priority
static int priority
Definition cdr_beanstalkd.c:76
config_file
static const char config_file[]
Definition cdr_odbc.c:54
connected
static int connected
Definition cdr_pgsql.c:73
tz
static char * tz
Definition cdr_pgsql.c:71
MAX_USER_BUCKETS
#define MAX_USER_BUCKETS
Definition chan_iax2.c:1040
timing_read
static int timing_read(int *id, int fd, short events, void *cbdata)
Definition chan_iax2.c:9655
IAX_TRUNKTIMESTAMPS
#define IAX_TRUNKTIMESTAMPS
Definition chan_iax2.c:556
iax2_indicate
static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
Definition chan_iax2.c:5864
set_peercnt_limit
static void set_peercnt_limit(struct peercnt *peercnt)
Definition chan_iax2.c:2639
check_access
static int check_access(int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
Definition chan_iax2.c:7940
iaxthreadcount
static int iaxthreadcount
Definition chan_iax2.c:757
send_ping
static int send_ping(const void *data)
Definition chan_iax2.c:1826
iax2_trunk_expired
static int iax2_trunk_expired(struct iax2_trunk_peer *tpeer, struct timeval *now)
Definition chan_iax2.c:9647
iax2_thread_iostate
iax2_thread_iostate
Definition chan_iax2.c:1128
IAX_IOSTATE_PROCESSING
@ IAX_IOSTATE_PROCESSING
Definition chan_iax2.c:1131
IAX_IOSTATE_SCHEDREADY
@ IAX_IOSTATE_SCHEDREADY
Definition chan_iax2.c:1132
IAX_IOSTATE_IDLE
@ IAX_IOSTATE_IDLE
Definition chan_iax2.c:1129
IAX_IOSTATE_READY
@ IAX_IOSTATE_READY
Definition chan_iax2.c:1130
manager_iax2_show_peers
static int manager_iax2_show_peers(struct mansession *s, const struct message *m)
callback to display iax peers in manager
Definition chan_iax2.c:7398
peercnts
static struct ao2_container * peercnts
Definition chan_iax2.c:1044
build_context
static struct iax2_context * build_context(const char *context)
Definition chan_iax2.c:12892
save_rr
static void save_rr(struct iax_frame *fr, struct iax_ies *ies)
Definition chan_iax2.c:9823
IAX_ALREADYGONE
#define IAX_ALREADYGONE
Definition chan_iax2.c:544
IAX_PROVISION
#define IAX_PROVISION
Definition chan_iax2.c:545
update_registry
static int update_registry(struct ast_sockaddr *addr, int callno, char *devtype, int fd, unsigned short refresh)
Definition chan_iax2.c:9197
iax2_write
static int iax2_write(struct ast_channel *c, struct ast_frame *f)
Definition chan_iax2.c:7836
AUTH_METHOD_NAMES_BUFSIZE
#define AUTH_METHOD_NAMES_BUFSIZE
Definition chan_iax2.c:444
realtime_peer
static struct iax2_peer * realtime_peer(const char *peername, struct ast_sockaddr *addr)
Definition chan_iax2.c:4470
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)
Definition chan_iax2.c:10046
user_unref
static struct iax2_user * user_unref(struct iax2_user *user)
Definition chan_iax2.c:2125
apply_context
static int apply_context(struct iax2_context *con, const char *context)
Definition chan_iax2.c:7929
iax2_tech
static struct ast_channel_tech iax2_tech
Definition chan_iax2.c:1379
__auto_hangup
static void __auto_hangup(const void *nothing)
Definition chan_iax2.c:9526
iax2_poke_peer_cb
static int iax2_poke_peer_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:12603
iax2_destroy_helper
static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:2174
complete_iax2_peers
static char * complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags)
Definition chan_iax2.c:3977
autokill
static int autokill
Definition chan_iax2.c:383
randomcalltokendata
static int randomcalltokendata
Definition chan_iax2.c:1022
iaxdynamicthreadcount
static int iaxdynamicthreadcount
Definition chan_iax2.c:759
iax2_lock_owner
static void iax2_lock_owner(int callno)
Definition chan_iax2.c:1419
delayreject
static int delayreject
Definition chan_iax2.c:515
iax2_queue_hold
static int iax2_queue_hold(int callno, const char *musicclass)
Queue a hold frame on the ast_channel owner.
Definition chan_iax2.c:3362
MAX_TIMESTAMP_SKEW
#define MAX_TIMESTAMP_SKEW
Definition chan_iax2.c:749
acl_change_stasis_subscribe
static void acl_change_stasis_subscribe(void)
Definition chan_iax2.c:1555
store_by_transfercallno
static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:2485
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)
Create new call, interface with the PBX core.
Definition chan_iax2.c:5959
jb_error_output
static void jb_error_output(const char *fmt,...)
Definition chan_iax2.c:1294
peer_hash_cb
static int peer_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:2048
iax2_publish_registry
static void iax2_publish_registry(const char *username, const char *domain, const char *status, const char *cause)
Definition chan_iax2.c:8905
replace_callno
static int replace_callno(const void *obj)
Definition chan_iax2.c:3068
CALLNO_ENTRY_IS_VALIDATED
#define CALLNO_ENTRY_IS_VALIDATED(a)
Definition chan_iax2.c:992
auto_congest
static int auto_congest(const void *data)
Definition chan_iax2.c:4848
calc_txpeerstamp
static unsigned int calc_txpeerstamp(struct iax2_trunk_peer *tpeer, int sampms, struct timeval *now)
Definition chan_iax2.c:6158
__iax2_poke_noanswer
static void __iax2_poke_noanswer(const void *data)
Definition chan_iax2.c:12562
iax2_predestroy
static int iax2_predestroy(int callno)
Definition chan_iax2.c:3522
update_packet
static int update_packet(struct iax_frame *f)
Definition chan_iax2.c:3607
iaxcompat
static int iaxcompat
Definition chan_iax2.c:384
iax2_trunk_queue
static int iax2_trunk_queue(struct chan_iax2_pvt *pvt, struct iax_frame *fr)
Definition chan_iax2.c:6413
handle_cli_iax2_prune_realtime
static char * handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:3726
peercnt_hash_cb
static int peercnt_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:2545
check_provisioning
static int check_provisioning(struct ast_sockaddr *addr, int sockfd, char *si, unsigned int ver)
Definition chan_iax2.c:9794
iax2_setoption
static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
Definition chan_iax2.c:5497
send_command_transfer
static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int)
Definition chan_iax2.c:7924
unwrap_timestamp
static void unwrap_timestamp(struct iax_frame *fr)
Definition chan_iax2.c:4159
wait_for_peercallno
static int wait_for_peercallno(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:5478
iax2_hangup
static int iax2_hangup(struct ast_channel *c)
Definition chan_iax2.c:5430
queue_signalling
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 ca...
Definition chan_iax2.c:2257
__schedule_action
static int __schedule_action(void(*func)(const void *data), const void *data, const char *funcname)
Definition chan_iax2.c:1738
addr_range_match_address_cb
static int addr_range_match_address_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2561
maxjitterbuffer
static int maxjitterbuffer
Definition chan_iax2.c:372
auth_fail
static int auth_fail(int callno, int failcode)
Definition chan_iax2.c:9511
handle_cli_iax2_test_losspct
static char * handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:3787
PEERS_FORMAT2
#define PEERS_FORMAT2
Definition chan_iax2.c:6995
PTR_TO_CALLNO
#define PTR_TO_CALLNO(a)
Definition chan_iax2.c:329
iax2_queue_hangup
static int iax2_queue_hangup(int callno)
Queue a hangup frame on the ast_channel owner.
Definition chan_iax2.c:3408
peercnt_remove_cb
static int peercnt_remove_cb(const void *obj)
Definition chan_iax2.c:2794
fix_peerts
static unsigned int fix_peerts(struct timeval *rxtrunktime, int callno, unsigned int ts)
Definition chan_iax2.c:6187
compress_subclass
static unsigned char compress_subclass(iax2_format subclass)
Definition chan_iax2.c:1899
handle_error
static int handle_error(void)
Definition chan_iax2.c:3441
IAX_TRUNK
#define IAX_TRUNK
Definition chan_iax2.c:538
auth_method_labels
static const char * auth_method_labels[]
Name of effective auth method.
Definition chan_iax2.c:436
peer_cmp_cb
static int peer_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2059
resend_with_token
static void resend_with_token(int callno, struct iax_frame *f, const char *newtoken)
Definition chan_iax2.c:4921
get_auth_methods
static int get_auth_methods(const char *value)
Definition chan_iax2.c:12902
handle_call_token
static int handle_call_token(struct ast_iax2_full_hdr *fh, struct iax_ies *ies, struct ast_sockaddr *addr, int fd)
Definition chan_iax2.c:5043
new_iax
static struct chan_iax2_pvt * new_iax(struct ast_sockaddr *addr, const char *host)
Definition chan_iax2.c:2329
default_parkinglot
static char default_parkinglot[AST_MAX_CONTEXT]
Definition chan_iax2.c:359
find_tpeer
static struct iax2_trunk_peer * find_tpeer(struct ast_sockaddr *addr, int fd)
Definition chan_iax2.c:6377
iax_error_output
static void iax_error_output(const char *data)
Definition chan_iax2.c:1289
vnak_retransmit
static void vnak_retransmit(int callno, int last)
Definition chan_iax2.c:9573
user_delme_cb
static int user_delme_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:13625
send_command_immediate
static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
Definition chan_iax2.c:7919
acf_channel_read
static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen)
Definition chan_iax2.c:14629
iaxvar_function
static struct ast_custom_function iaxvar_function
Definition chan_iax2.c:10251
IAX_SHRINKCALLERID
#define IAX_SHRINKCALLERID
Definition chan_iax2.c:565
defer_full_frame
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.
Definition chan_iax2.c:9937
iax2_exec
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.
Definition chan_iax2.c:14501
__unload_module
static int __unload_module(void)
Definition chan_iax2.c:14765
handle_cli_iax2_set_debug
static char * handle_cli_iax2_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7737
acl_change_sub
static struct stasis_subscription * acl_change_sub
Definition chan_iax2.c:365
iax2_poke_peer
static int iax2_poke_peer(struct iax2_peer *peer, int heldcall)
Definition chan_iax2.c:12612
iax2_capability
static iax2_format iax2_capability
Definition chan_iax2.c:496
DEFAULT_MAX_THREAD_COUNT
#define DEFAULT_MAX_THREAD_COUNT
Definition chan_iax2.c:333
iaxsl
static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)]
chan_iax2_pvt structure locks
Definition chan_iax2.c:1249
iax2_digit_end
static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
Definition chan_iax2.c:4432
DEFAULT_MAXCALLNO_LIMIT_NONVAL
static uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL
Definition chan_iax2.c:1054
sched
static struct ast_sched_context * sched
Definition chan_iax2.c:494
dp_lookup_thread
static void * dp_lookup_thread(void *data)
Definition chan_iax2.c:9765
DEFAULT_MAXCALLNO_LIMIT
static uint16_t DEFAULT_MAXCALLNO_LIMIT
Definition chan_iax2.c:1052
peercnt_modify
static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
Definition chan_iax2.c:2689
transmit_trunk
static int transmit_trunk(struct iax_frame *f, struct ast_sockaddr *addr, int sockfd)
Definition chan_iax2.c:3475
registry_rerequest
static int registry_rerequest(struct iax_ies *ies, int callno, struct ast_sockaddr *addr)
Definition chan_iax2.c:9423
send_command
static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
Definition chan_iax2.c:7884
encmethods_to_str
static void encmethods_to_str(int e, struct ast_str **buf)
Definition chan_iax2.c:1836
construct_rr
static void construct_rr(struct chan_iax2_pvt *pvt, struct iax_ie_data *iep)
Definition chan_iax2.c:9807
iaxpeer_function
static struct ast_custom_function iaxpeer_function
Definition chan_iax2.c:14624
load_objects
static int load_objects(void)
Definition chan_iax2.c:14899
complete_transfer
static int complete_transfer(int callno, struct iax_ies *ies)
Definition chan_iax2.c:8844
iax2_fixup
static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
Definition chan_iax2.c:4454
codec_choose_from_prefs
static struct ast_format * codec_choose_from_prefs(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
Definition chan_iax2.c:1933
prune_addr_range_cb
static int prune_addr_range_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2678
iax_debug_output
static void iax_debug_output(const char *data)
Definition chan_iax2.c:1283
IAX_CALLENCRYPTED
#define IAX_CALLENCRYPTED(pvt)
Definition chan_iax2.c:477
handle_cli_iax2_provision
static char * handle_cli_iax2_provision(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:12523
global_maxcallno_nonval
static uint16_t global_maxcallno_nonval
Definition chan_iax2.c:1059
maxjitterinterps
static int maxjitterinterps
Definition chan_iax2.c:374
schedule_delivery
static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
Definition chan_iax2.c:4329
IAX_ENCRYPTED
#define IAX_ENCRYPTED
Definition chan_iax2.c:547
jb_debug_output
static void jb_debug_output(const char *fmt,...)
Definition chan_iax2.c:1318
IAX_CODEC_NOCAP
#define IAX_CODEC_NOCAP
Definition chan_iax2.c:551
ping_time
static int ping_time
Definition chan_iax2.c:370
iax_pvt_callid_new
static void iax_pvt_callid_new(int callno)
Definition chan_iax2.c:1223
regstate2str
static char * regstate2str(int regstate)
Definition chan_iax2.c:7459
last_authmethod
static int last_authmethod
Definition chan_iax2.c:385
IAX_NOTRANSFER
#define IAX_NOTRANSFER
Definition chan_iax2.c:539
__iax2_show_peers
static int __iax2_show_peers(int fd, int *total, struct mansession *s, const int argc, const char *const argv[])
Definition chan_iax2.c:7099
IAX_IMMEDIATE
#define IAX_IMMEDIATE
Definition chan_iax2.c:561
iax2_call
static int iax2_call(struct ast_channel *c, const char *dest, int timeout)
Definition chan_iax2.c:5205
handle_cli_iax2_set_mtu
static char * handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Set trunk MTU from CLI.
Definition chan_iax2.c:4046
trunk_untimed
static int trunk_untimed
Definition chan_iax2.c:355
pvt_destructor
static void pvt_destructor(void *obj)
Definition chan_iax2.c:2282
addr_range_hash_cb
static int addr_range_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:2531
pvt_hash_cb
static int pvt_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:14863
iax2_queue_unhold
static int iax2_queue_unhold(int callno)
Queue an unhold frame on the ast_channel owner.
Definition chan_iax2.c:3385
MAX_TRUNK_MTU
#define MAX_TRUNK_MTU
Maximum transmission unit for the UDP packet in the trunk not to be fragmented. This is based on 1516...
Definition chan_iax2.c:352
iax2_getpeername
static int iax2_getpeername(struct ast_sockaddr addr, char *host, int len)
Definition chan_iax2.c:2131
build_peer
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.
Definition chan_iax2.c:13041
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)
Definition chan_iax2.c:3324
iax2_process_thread
static void * iax2_process_thread(void *data)
Definition chan_iax2.c:12235
frame_queue
static struct @119 frame_queue[IAX_MAX_CALLS]
a list of frames that may need to be retransmitted
iax2_digit_begin
static int iax2_digit_begin(struct ast_channel *c, char digit)
Definition chan_iax2.c:4427
build_user
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.
Definition chan_iax2.c:13354
regcontext
static char regcontext[AST_MAX_CONTEXT]
Definition chan_iax2.c:362
socket_process_helper
static int socket_process_helper(struct iax2_thread *thread)
Definition chan_iax2.c:10278
IAX_CAPABILITY_FULLBANDWIDTH
#define IAX_CAPABILITY_FULLBANDWIDTH
Definition chan_iax2.c:410
peers
static struct ao2_container * peers
Definition chan_iax2.c:1038
set_config
static int set_config(const char *config_file, int reload, int forced)
Load configuration.
Definition chan_iax2.c:13711
try_transfer
static int try_transfer(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
Definition chan_iax2.c:8763
_iax2_show_peers_one
static void _iax2_show_peers_one(int fd, struct mansession *s, struct show_peers_context *cont, struct iax2_peer *peer)
Definition chan_iax2.c:6998
__auto_congest
static void __auto_congest(const void *nothing)
Definition chan_iax2.c:4835
IAX_HASCALLERID
#define IAX_HASCALLERID
Definition chan_iax2.c:535
free_signaling_queue_entry
static void free_signaling_queue_entry(struct signaling_queue_entry *s)
Definition chan_iax2.c:2234
__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)
Definition chan_iax2.c:7865
MARK_IAX_SUBCLASS_TX
#define MARK_IAX_SUBCLASS_TX
Definition chan_iax2.c:755
iax2_key_rotate
static int iax2_key_rotate(const void *vpvt)
Definition chan_iax2.c:5592
schedule_action
#define schedule_action(func, data)
Definition chan_iax2.c:1763
invalid_key
static int invalid_key(ast_aes_decrypt_key *ecx)
Definition chan_iax2.c:6496
user_cmp_cb
static int user_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2082
__expire_registry
static void __expire_registry(const void *data)
Definition chan_iax2.c:9093
reg_source_db
static void reg_source_db(struct iax2_peer *p)
Definition chan_iax2.c:9143
scheduled_destroy
static int scheduled_destroy(const void *vid)
Definition chan_iax2.c:2222
prune_peers
static void prune_peers(void)
Definition chan_iax2.c:13679
max_calltoken_delay
static time_t max_calltoken_delay
Definition chan_iax2.c:1024
callno_limits
static struct ao2_container * callno_limits
Definition chan_iax2.c:1047
calltoken_required
static int calltoken_required(struct ast_sockaddr *addr, const char *name, int subclass)
Definition chan_iax2.c:2580
iax2_read
static struct ast_frame * iax2_read(struct ast_channel *c)
Definition chan_iax2.c:5586
netsock
static struct ast_netsock_list * netsock
Definition chan_iax2.c:403
min_reg_expire
static int min_reg_expire
Definition chan_iax2.c:396
add_calltoken_ignore
static int add_calltoken_ignore(const char *addr)
Definition chan_iax2.c:2881
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)
Definition chan_iax2.c:8596
ACN_FORMAT2
#define ACN_FORMAT2
handle_cli_iax2_show_firmware
static char * handle_cli_iax2_show_firmware(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7371
iax2_transfer
static int iax2_transfer(struct ast_channel *c, const char *dest)
Definition chan_iax2.c:5917
iax2_transmit
static int iax2_transmit(struct iax_frame *fr)
Definition chan_iax2.c:4420
IAX_SENDANI
#define IAX_SENDANI
Definition chan_iax2.c:542
last
struct iax_frame * last
Definition chan_iax2.c:1018
__auth_reject
static void __auth_reject(const void *nothing)
Definition chan_iax2.c:9477
adsi
static int adsi
Definition chan_iax2.c:514
build_ecx_key
static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:6518
iax2_thread_type
iax2_thread_type
Definition chan_iax2.c:1135
IAX_THREAD_TYPE_DYNAMIC
@ IAX_THREAD_TYPE_DYNAMIC
Definition chan_iax2.c:1137
IAX_THREAD_TYPE_POOL
@ IAX_THREAD_TYPE_POOL
Definition chan_iax2.c:1136
CALLNO_ENTRY_GET_CALLNO
#define CALLNO_ENTRY_GET_CALLNO(a)
Definition chan_iax2.c:993
iax2_getpeertrunk
static int iax2_getpeertrunk(struct ast_sockaddr addr)
Definition chan_iax2.c:5937
attempt_transmit
static int attempt_transmit(const void *data)
Definition chan_iax2.c:3717
encrypt_frame
static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen)
Definition chan_iax2.c:6629
outsock
static struct ast_netsock_list * outsock
Definition chan_iax2.c:404
prune_users
static void prune_users(void)
Definition chan_iax2.c:13663
DEFAULT_CONTEXT
#define DEFAULT_CONTEXT
Definition chan_iax2.c:357
user_destructor
static void user_destructor(void *obj)
Definition chan_iax2.c:13340
iax_transfercallno_pvts
static struct ao2_container * iax_transfercallno_pvts
Another container of iax2_pvt structures.
Definition chan_iax2.c:1256
find_user
static struct iax2_user * find_user(const char *name)
Definition chan_iax2.c:2120
resyncthreshold
static int resyncthreshold
Definition chan_iax2.c:373
IAX_RECVCONNECTEDLINE
#define IAX_RECVCONNECTEDLINE
Definition chan_iax2.c:563
register_peer_exten
static void register_peer_exten(struct iax2_peer *peer, int onoff)
Definition chan_iax2.c:9055
transfercallno_pvt_cmp_cb
static int transfercallno_pvt_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:14888
MAX_RETRY_TIME
#define MAX_RETRY_TIME
Definition chan_iax2.c:742
iaxdynamicthreadnum
static int iaxdynamicthreadnum
Definition chan_iax2.c:760
callno_pool_lock
static ast_mutex_t callno_pool_lock
Definition chan_iax2.c:1001
TRUNK_CALL_START
#define TRUNK_CALL_START
Definition chan_iax2.c:1260
send_command_final
static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int)
Definition chan_iax2.c:7909
MAX_TRUNKDATA
#define MAX_TRUNKDATA
Definition chan_iax2.c:377
trunk_maxmtu
static int trunk_maxmtu
Definition chan_iax2.c:355
DEFAULT_FREQ_OK
#define DEFAULT_FREQ_OK
Definition chan_iax2.c:432
free_context
static void free_context(struct iax2_context *con)
Definition chan_iax2.c:12693
handle_cli_iax2_show_channels
static char * handle_cli_iax2_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7564
CALLNO_ENTRY_SET_VALIDATED
#define CALLNO_ENTRY_SET_VALIDATED(a)
Definition chan_iax2.c:991
total_nonval_callno_used
static uint16_t total_nonval_callno_used
Definition chan_iax2.c:1061
complete_dpreply
static int complete_dpreply(struct chan_iax2_pvt *pvt, struct iax_ies *ies)
Definition chan_iax2.c:8797
IAX_DEBUGDIGEST
#define IAX_DEBUGDIGEST(msg, key)
Definition chan_iax2.c:480
tdesc
static const char tdesc[]
Definition chan_iax2.c:347
parse_dial_string
static void parse_dial_string(char *data, struct parsed_dial_string *pds)
Parses an IAX dial string into its component parts.
Definition chan_iax2.c:5145
global_rtautoclear
static int global_rtautoclear
Definition chan_iax2.c:566
iax2_destroy
static void iax2_destroy(int callno)
Definition chan_iax2.c:3545
manager_iax2_show_netstats
static int manager_iax2_show_netstats(struct mansession *s, const struct message *m)
Definition chan_iax2.c:7351
spawn_dp_lookup
static void spawn_dp_lookup(int callno, const char *context, const char *callednum, const char *callerid)
Definition chan_iax2.c:9776
CALLNO_TO_PTR
#define CALLNO_TO_PTR(a)
Definition chan_iax2.c:330
iaxfrdup2
static struct iax_frame * iaxfrdup2(struct iax_frame *fr)
Definition chan_iax2.c:2372
transmit_frame
static int transmit_frame(void *data)
Definition chan_iax2.c:4393
acf_iaxvar_write
static int acf_iaxvar_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
Definition chan_iax2.c:10201
iax2_answer
static int iax2_answer(struct ast_channel *c)
Definition chan_iax2.c:5857
iax2_authmethods
static int iax2_authmethods
Definition chan_iax2.c:517
iax2_getformatname_multiple
static const char * iax2_getformatname_multiple(iax2_format format, struct ast_str **codec_buf)
Definition chan_iax2.c:2001
set_hangup_source_and_cause
static void set_hangup_source_and_cause(int callno, unsigned char causecode)
Definition chan_iax2.c:10257
IAX_RTUPDATE
#define IAX_RTUPDATE
Definition chan_iax2.c:553
IAX_QUELCH
#define IAX_QUELCH
Definition chan_iax2.c:546
iax2_canmatch
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
Definition chan_iax2.c:14455
__send_ping
static void __send_ping(const void *data)
Definition chan_iax2.c:1802
find_peer
static struct iax2_peer * find_peer(const char *name, int realtime)
Definition chan_iax2.c:2095
handle_cli_iax2_show_netstats
static char * handle_cli_iax2_show_netstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7714
MIN_RETRY_TIME
#define MIN_RETRY_TIME
Definition chan_iax2.c:741
iaxactivethreadcount
static int iaxactivethreadcount
Definition chan_iax2.c:761
check_srcaddr
static int check_srcaddr(struct ast_sockaddr *addr)
Check if address can be used as packet source.
Definition chan_iax2.c:12920
IAX_MAXAUTHREQ
#define IAX_MAXAUTHREQ
Definition chan_iax2.c:558
insert_idle_thread
static void insert_idle_thread(struct iax2_thread *thread)
Definition chan_iax2.c:1656
acl_change_stasis_unsubscribe
static void acl_change_stasis_unsubscribe(void)
Definition chan_iax2.c:1565
match
static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
Definition chan_iax2.c:2401
pvt_cmp_cb
static int pvt_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:14870
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)
Definition chan_iax2.c:8518
network_change_stasis_cb
static void network_change_stasis_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Definition chan_iax2.c:1583
iaxdefaulttimeout
static int iaxdefaulttimeout
Definition chan_iax2.c:389
users
static struct ao2_container * users
Definition chan_iax2.c:1041
auth_reject
static int auth_reject(const void *data)
Definition chan_iax2.c:9497
create_callno_pools
static int create_callno_pools(void)
Definition chan_iax2.c:3107
send_signaling
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....
Definition chan_iax2.c:2244
CALLTOKEN_IE_FORMAT
#define CALLTOKEN_IE_FORMAT
handle_cli_iax2_show_cache
static char * handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:4087
IAX_FORCE_ENCRYPT
#define IAX_FORCE_ENCRYPT
Definition chan_iax2.c:564
handle_cli_iax2_reload
static char * handle_cli_iax2_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:14211
network_change_stasis_subscribe
static void network_change_stasis_subscribe(void)
Definition chan_iax2.c:1540
iax2_switch
static struct ast_switch iax2_switch
Definition chan_iax2.c:14707
iax_transfer_state
iax_transfer_state
Definition chan_iax2.c:708
TRANSFER_MEDIA
@ TRANSFER_MEDIA
Definition chan_iax2.c:718
TRANSFER_NONE
@ TRANSFER_NONE
Definition chan_iax2.c:709
TRANSFER_MPASSTHROUGH
@ TRANSFER_MPASSTHROUGH
Definition chan_iax2.c:717
TRANSFER_MEDIAPASS
@ TRANSFER_MEDIAPASS
Definition chan_iax2.c:719
TRANSFER_PASSTHROUGH
@ TRANSFER_PASSTHROUGH
Definition chan_iax2.c:713
TRANSFER_MRELEASED
@ TRANSFER_MRELEASED
Definition chan_iax2.c:716
TRANSFER_BEGIN
@ TRANSFER_BEGIN
Definition chan_iax2.c:710
TRANSFER_MREADY
@ TRANSFER_MREADY
Definition chan_iax2.c:715
TRANSFER_READY
@ TRANSFER_READY
Definition chan_iax2.c:711
TRANSFER_MBEGIN
@ TRANSFER_MBEGIN
Definition chan_iax2.c:714
TRANSFER_RELEASED
@ TRANSFER_RELEASED
Definition chan_iax2.c:712
poke_all_peers
static void poke_all_peers(void)
Definition chan_iax2.c:14168
IAX_SENDCONNECTEDLINE
#define IAX_SENDCONNECTEDLINE
Definition chan_iax2.c:562
iax2_regfunk
static int(* iax2_regfunk)(const char *username, int onoff)
Definition chan_iax2.c:407
network_change_sched_cb
static int network_change_sched_cb(const void *data)
Definition chan_iax2.c:1570
find_callno
static int find_callno(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame)
Definition chan_iax2.c:3320
__do_deliver
static int __do_deliver(void *data)
Definition chan_iax2.c:3426
IAX_RTCACHEFRIENDS
#define IAX_RTCACHEFRIENDS
Definition chan_iax2.c:552
IAX_RTIGNOREREGEXPIRE
#define IAX_RTIGNOREREGEXPIRE
Definition chan_iax2.c:555
papp
static char * papp
Definition chan_iax2.c:12489
socket_process
static int socket_process(struct iax2_thread *thread)
Definition chan_iax2.c:12213
manager_iax2_show_registry
static int manager_iax2_show_registry(struct mansession *s, const struct message *m)
Definition chan_iax2.c:7522
dp_lookup
static void dp_lookup(int callno, const char *context, const char *callednum, const char *callerid, int skiplock)
Definition chan_iax2.c:9733
iax2_poke_noanswer
static int iax2_poke_noanswer(const void *data)
Definition chan_iax2.c:12591
get_unused_callno
static int get_unused_callno(enum callno_type type, int validated, callno_entry *entry)
Definition chan_iax2.c:2991
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)
Definition chan_iax2.c:2922
handle_cli_iax2_show_stats
static char * handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:4000
authdebug
static int authdebug
Definition chan_iax2.c:382
transmit_processor
static struct ast_taskprocessor * transmit_processor
Definition chan_iax2.c:1020
iaxdefaultdpcache
static int iaxdefaultdpcache
Definition chan_iax2.c:387
trunk_nmaxmtu
static int trunk_nmaxmtu
Definition chan_iax2.c:355
function_iaxpeer
static int function_iaxpeer(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
Definition chan_iax2.c:14552
DEFAULT_MAXMS
#define DEFAULT_MAXMS
Definition chan_iax2.c:431
send_lagrq
static int send_lagrq(const void *data)
Definition chan_iax2.c:1890
peer_set_srcaddr
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 defaultsoc...
Definition chan_iax2.c:12943
peercnt_add
static int peercnt_add(struct ast_sockaddr *addr)
Definition chan_iax2.c:2717
iax2_do_register
static int iax2_do_register(struct iax2_registry *reg)
Definition chan_iax2.c:12381
iax2_register
static int iax2_register(const char *value, int lineno)
Definition chan_iax2.c:9019
iax2_sendimage
static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
Definition chan_iax2.c:4444
timer
static struct ast_timer * timer
Definition chan_iax2.c:401
__send_lagrq
static void __send_lagrq(const void *data)
Definition chan_iax2.c:1866
unlink_peer
static void unlink_peer(struct iax2_peer *peer)
Definition chan_iax2.c:9074
authenticate_request
static int authenticate_request(int call_num)
Definition chan_iax2.c:8210
peer_unref
static struct iax2_peer * peer_unref(struct iax2_peer *peer)
Definition chan_iax2.c:2114
iax2_append_register
static int iax2_append_register(const char *hostname, const char *username, const char *secret, const char *porta)
Definition chan_iax2.c:8977
maxauthreq
static int maxauthreq
Definition chan_iax2.c:368
firmware_show_callback
static int firmware_show_callback(struct ast_iax2_firmware_header *header, void *user_data)
Definition chan_iax2.c:7358
get_from_jb
static int get_from_jb(const void *p)
Definition chan_iax2.c:4314
save_osptoken
static void save_osptoken(struct iax_frame *fr, struct iax_ies *ies)
Definition chan_iax2.c:9834
max_reg_expire
static int max_reg_expire
Definition chan_iax2.c:397
iax_reg_state
iax_reg_state
Definition chan_iax2.c:698
REG_STATE_REGSENT
@ REG_STATE_REGSENT
Definition chan_iax2.c:700
REG_STATE_TIMEOUT
@ REG_STATE_TIMEOUT
Definition chan_iax2.c:704
REG_STATE_AUTHSENT
@ REG_STATE_AUTHSENT
Definition chan_iax2.c:701
REG_STATE_NOAUTH
@ REG_STATE_NOAUTH
Definition chan_iax2.c:705
REG_STATE_REGISTERED
@ REG_STATE_REGISTERED
Definition chan_iax2.c:702
REG_STATE_REJECTED
@ REG_STATE_REJECTED
Definition chan_iax2.c:703
REG_STATE_UNREGISTERED
@ REG_STATE_UNREGISTERED
Definition chan_iax2.c:699
iax2_queryoption
static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen)
Definition chan_iax2.c:5569
calc_timestamp
static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
Definition chan_iax2.c:6202
ACN_FORMAT1
#define ACN_FORMAT1
DEFAULT_RETRY_TIME
#define DEFAULT_RETRY_TIME
Definition chan_iax2.c:334
peer_status
static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
peer_status: Report Peer status in character string
Definition chan_iax2.c:3878
set_config_destroy
static void set_config_destroy(void)
Definition chan_iax2.c:13694
iax2_allow_new
static int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
Definition chan_iax2.c:3171
IAX_RTSAVE_SYSNAME
#define IAX_RTSAVE_SYSNAME
Definition chan_iax2.c:543
iax2_codec_choose
static iax2_format iax2_codec_choose(struct iax2_codec_pref *pref, iax2_format formats)
Definition chan_iax2.c:1967
iax2_delete_from_sched
static int iax2_delete_from_sched(const void *data)
Definition chan_iax2.c:2163
lagrq_time
static int lagrq_time
Definition chan_iax2.c:371
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)
Definition chan_iax2.c:7810
DEFAULT_FREQ_NOTOK
#define DEFAULT_FREQ_NOTOK
Definition chan_iax2.c:433
update_jbsched
static void update_jbsched(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:4194
store_by_peercallno
static void store_by_peercallno(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:2504
set_peercnt_limit_all_cb
static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2664
trunkmaxsize
static int trunkmaxsize
Definition chan_iax2.c:380
NEW_PREVENT
@ NEW_PREVENT
Definition chan_iax2.c:2391
NEW_ALLOW
@ NEW_ALLOW
Definition chan_iax2.c:2393
NEW_FORCE
@ NEW_FORCE
Definition chan_iax2.c:2395
NEW_ALLOW_CALLTOKEN_VALIDATED
@ NEW_ALLOW_CALLTOKEN_VALIDATED
Definition chan_iax2.c:2398
handle_deferred_full_frames
static void handle_deferred_full_frames(struct iax2_thread *thread)
Handle any deferred full frames for this thread.
Definition chan_iax2.c:9907
ast_cli_netstats
static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt)
Definition chan_iax2.c:7630
transfercallno_pvt_hash_cb
static int transfercallno_pvt_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:14881
test_losspct
static int test_losspct
Definition chan_iax2.c:502
decrypt_frame
static int decrypt_frame(int callno, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
Definition chan_iax2.c:6668
srvlookup
static int srvlookup
Definition chan_iax2.c:399
iax_pvt_callid_set
static void iax_pvt_callid_set(int callno, ast_callid callid)
Definition chan_iax2.c:1218
__get_from_jb
static void __get_from_jb(const void *p)
Definition chan_iax2.c:4211
iax2_encryption
static int iax2_encryption
Definition chan_iax2.c:516
peercnt_remove_by_addr
static int peercnt_remove_by_addr(struct ast_sockaddr *addr)
Definition chan_iax2.c:2808
decode_frame
static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen)
Definition chan_iax2.c:6576
callno_pool
static struct call_number_pool callno_pool
Definition chan_iax2.c:1004
netthreadid
static pthread_t netthreadid
Definition chan_iax2.c:521
CALLNO_ENTRY_TO_PTR
#define CALLNO_ENTRY_TO_PTR(a)
Definition chan_iax2.c:989
trunkfreq
static int trunkfreq
Definition chan_iax2.c:379
build_rand_pad
static void build_rand_pad(unsigned char *buf, ssize_t len)
Definition chan_iax2.c:6486
signal_condition
static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
Definition chan_iax2.c:1196
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)
Definition chan_iax2.c:7784
handle_cli_iax2_show_registry
static char * handle_cli_iax2_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7481
iax2_sched_add
static int iax2_sched_add(struct ast_sched_context *sched, int when, ast_sched_cb callback, const void *data)
Definition chan_iax2.c:1772
socket_read
static int socket_read(int *id, int fd, short events, void *cbdata)
Definition chan_iax2.c:9968
peer_delme_cb
static int peer_delme_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:13616
create_addr
static int create_addr(const char *peername, struct ast_channel *c, struct ast_sockaddr *addr, struct create_addr_info *cai)
Definition chan_iax2.c:4719
auth_method_names
static char * auth_method_names(int authmethods, char *restrict buf)
Get names of all auth methods.
Definition chan_iax2.c:452
user_hash_cb
static int user_hash_cb(const void *obj, const int flags)
Definition chan_iax2.c:2071
peer_destructor
static void peer_destructor(void *obj)
Definition chan_iax2.c:13013
__iax2_do_register_s
static void __iax2_do_register_s(const void *data)
Definition chan_iax2.c:8736
IAX_USEJITTERBUF
#define IAX_USEJITTERBUF
Definition chan_iax2.c:540
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)
Definition chan_iax2.c:4883
jb_warning_output
static void jb_warning_output(const char *fmt,...)
Definition chan_iax2.c:1306
iax2_exists
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.
Definition chan_iax2.c:14432
calltoken_peer_enum
calltoken_peer_enum
Call token validation settings.
Definition chan_iax2.c:573
CALLTOKEN_DEFAULT
@ CALLTOKEN_DEFAULT
Default calltoken required unless the ip is in the ignorelist.
Definition chan_iax2.c:575
CALLTOKEN_AUTO
@ CALLTOKEN_AUTO
Require call token validation after a successful registration using call token validation occurs.
Definition chan_iax2.c:580
CALLTOKEN_NO
@ CALLTOKEN_NO
Do not require call token validation.
Definition chan_iax2.c:582
CALLTOKEN_YES
@ CALLTOKEN_YES
Require call token validation.
Definition chan_iax2.c:577
get_encrypt_methods
static int get_encrypt_methods(const char *s)
Definition chan_iax2.c:1852
jittertargetextra
static int jittertargetextra
Definition chan_iax2.c:375
iax2_matchmore
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.
Definition chan_iax2.c:14478
globalflags
static struct ast_flags64 globalflags
Definition chan_iax2.c:519
find_cache
static struct iax2_dpcache * find_cache(struct ast_channel *chan, const char *data, const char *context, const char *exten, int priority)
Definition chan_iax2.c:14307
uncompress_subclass
static iax2_format uncompress_subclass(unsigned char csub)
Definition chan_iax2.c:1919
network_thread
static void * network_thread(void *ignore)
Definition chan_iax2.c:12820
handle_cli_iax2_show_peers
static char * handle_cli_iax2_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7326
iax2_is_control_frame_allowed
static int iax2_is_control_frame_allowed(int subtype)
Definition chan_iax2.c:1443
network_change_stasis_unsubscribe
static void network_change_stasis_unsubscribe(void)
Definition chan_iax2.c:1550
realtime_update_peer
static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime)
Definition chan_iax2.c:4677
io
static struct io_context * io
Definition chan_iax2.c:493
trunk_timed
static int trunk_timed
Definition chan_iax2.c:355
complete_iax2_unregister
static char * complete_iax2_unregister(const char *line, const char *word, int pos, int state)
Definition chan_iax2.c:7301
network_change_sub
static struct stasis_subscription * network_change_sub
Definition chan_iax2.c:364
raw_hangup
static int raw_hangup(struct ast_sockaddr *addr, unsigned short src, unsigned short dst, int sockfd)
Definition chan_iax2.c:8173
PTR_TO_CALLNO_ENTRY
#define PTR_TO_CALLNO_ENTRY(a)
Definition chan_iax2.c:988
calltoken_ignores
static struct ao2_container * calltoken_ignores
Definition chan_iax2.c:1050
iax2_dup_variable_datastore
static void * iax2_dup_variable_datastore(void *)
Definition chan_iax2.c:1614
prefs_global
static struct iax2_codec_pref prefs_global
Definition chan_iax2.c:345
iax2_state
iax2_state
Definition chan_iax2.c:523
IAX_STATE_TBD
@ IAX_STATE_TBD
Definition chan_iax2.c:526
IAX_STATE_AUTHENTICATED
@ IAX_STATE_AUTHENTICATED
Definition chan_iax2.c:525
IAX_STATE_STARTED
@ IAX_STATE_STARTED
Definition chan_iax2.c:524
realtime_user
static struct iax2_user * realtime_user(const char *username, struct ast_sockaddr *addr)
Definition chan_iax2.c:4602
IAX2_TRUNK_PREFACE
#define IAX2_TRUNK_PREFACE
Definition chan_iax2.c:675
iax2_ack_registry
static int iax2_ack_registry(struct iax_ies *ies, struct ast_sockaddr *addr, int callno)
Acknowledgment received for OUR registration.
Definition chan_iax2.c:8911
__iax2_poke_peer_s
static void __iax2_poke_peer_s(const void *data)
Definition chan_iax2.c:9586
load_module
static int load_module(void)
Load the module.
Definition chan_iax2.c:14992
iax2_vnak
static int iax2_vnak(int callno)
Definition chan_iax2.c:9568
IAX_CAPABILITY_MEDBANDWIDTH
#define IAX_CAPABILITY_MEDBANDWIDTH
Definition chan_iax2.c:412
iax2_parse_allow_disallow
static int iax2_parse_allow_disallow(struct iax2_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
Definition chan_iax2.c:2015
DEFAULT_TRUNKDATA
#define DEFAULT_TRUNKDATA
Definition chan_iax2.c:747
handle_cli_iax2_show_peer
static char * handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Show one peer in detail.
Definition chan_iax2.c:3901
iax2_process_thread_cleanup
static void iax2_process_thread_cleanup(void *data)
Definition chan_iax2.c:12223
IAX_TRANSFERMEDIA
#define IAX_TRANSFERMEDIA
Definition chan_iax2.c:557
iax2_sendhtml
static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
Definition chan_iax2.c:4449
IAX_KEYPOPULATED
#define IAX_KEYPOPULATED
Definition chan_iax2.c:548
addr_range_cmp_cb
static int addr_range_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2537
IAX_RTAUTOCLEAR
#define IAX_RTAUTOCLEAR
Definition chan_iax2.c:554
registry_authrequest
static int registry_authrequest(int callno)
Definition chan_iax2.c:9375
iax2_provision
static int iax2_provision(struct ast_sockaddr *end, int sockfd, const char *dest, const char *template, int force)
Definition chan_iax2.c:12442
FORMAT
#define FORMAT
iax2_getformatname
const char * iax2_getformatname(iax2_format format)
iax2 wrapper function for ast_getformatname
Definition chan_iax2.c:1989
DEFAULT_THREAD_COUNT
#define DEFAULT_THREAD_COUNT
Definition chan_iax2.c:332
iaxdebug
static int iaxdebug
Definition chan_iax2.c:498
acf_iaxvar_read
static int acf_iaxvar_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
Definition chan_iax2.c:10172
iax2_free_variable_datastore
static void iax2_free_variable_datastore(void *)
Definition chan_iax2.c:1638
callno_entry
uint16_t callno_entry
Definition chan_iax2.c:777
iax2_poke_peer_s
static int iax2_poke_peer_s(const void *data)
Definition chan_iax2.c:9593
addr_range_delme_cb
static int addr_range_delme_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2524
find_idle_thread
static struct iax2_thread * find_idle_thread(void)
Definition chan_iax2.c:1671
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)
Definition chan_iax2.c:12703
IAX_DYNAMIC
#define IAX_DYNAMIC
Definition chan_iax2.c:541
add_empty_calltoken_ie
static void add_empty_calltoken_ie(struct chan_iax2_pvt *pvt, struct iax_ie_data *ied)
Definition chan_iax2.c:4911
max_retries
static int max_retries
Definition chan_iax2.c:369
delete_users
static void delete_users(void)
Definition chan_iax2.c:13634
MIN_REUSE_TIME
#define MIN_REUSE_TIME
Definition chan_iax2.c:340
FORMAT2
#define FORMAT2
IAX_TEMPONLY
#define IAX_TEMPONLY
Definition chan_iax2.c:537
IAX_DELAYPBXSTART
#define IAX_DELAYPBXSTART
Definition chan_iax2.c:559
cache_get_callno_locked
static int cache_get_callno_locked(const char *data)
Definition chan_iax2.c:14234
iax_outputframe
static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct ast_sockaddr *addr, int datalen)
Definition chan_iax2.c:1265
unload_module
static int unload_module(void)
Definition chan_iax2.c:14846
remove_by_transfercallno
static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:2495
iaxs
static struct chan_iax2_pvt * iaxs[IAX_MAX_CALLS]
an array of iax2 pvt structures
Definition chan_iax2.c:1211
reload
static int reload(void)
Definition chan_iax2.c:14229
peer_set_sock_cb
static int peer_set_sock_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:14853
amaflags
static int amaflags
Definition chan_iax2.c:513
stop_stuff
static void stop_stuff(int callno)
Definition chan_iax2.c:9472
handle_cli_iax2_show_users
static char * handle_cli_iax2_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:6910
send_trunk
static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now)
Definition chan_iax2.c:9604
log_jitterstats
static void log_jitterstats(unsigned short callno)
Definition chan_iax2.c:9864
peer_ref
static struct iax2_peer * peer_ref(struct iax2_peer *peer)
Definition chan_iax2.c:2108
iax_pvt_callid_get
static ast_callid iax_pvt_callid_get(int callno)
Definition chan_iax2.c:1213
IAX_CAPABILITY_LOWBANDWIDTH
#define IAX_CAPABILITY_LOWBANDWIDTH
Definition chan_iax2.c:422
cleanup_thread_list
static void cleanup_thread_list(void *head)
Definition chan_iax2.c:14745
iaxtrunkdebug
static int iaxtrunkdebug
Definition chan_iax2.c:500
manager_iax2_show_peer_list
static int manager_iax2_show_peer_list(struct mansession *s, const struct message *m)
callback to display iax peers in manager format
Definition chan_iax2.c:7420
iax2_queue_frame
static int iax2_queue_frame(int callno, struct ast_frame *f)
Queue a frame to a call's owning asterisk channel.
Definition chan_iax2.c:3339
authenticate_verify
static int authenticate_verify(struct chan_iax2_pvt *p, struct iax_ies *ies)
Definition chan_iax2.c:8261
iax2_sendtext
static int iax2_sendtext(struct ast_channel *c, const char *text)
Definition chan_iax2.c:4437
debugaddr
static struct ast_sockaddr debugaddr
Definition chan_iax2.c:1263
send_packet
static int send_packet(struct iax_frame *f)
Definition chan_iax2.c:3488
language
static char language[MAX_LANGUAGE]
Definition chan_iax2.c:361
accountcode
static char accountcode[AST_MAX_ACCOUNT_CODE]
Definition chan_iax2.c:510
merge_encryption
static void merge_encryption(struct chan_iax2_pvt *p, unsigned int enc)
Definition chan_iax2.c:8189
memcpy_decrypt
static void memcpy_decrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_decrypt_key *dcx)
Definition chan_iax2.c:6528
handle_cli_iax2_unregister
static char * handle_cli_iax2_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7260
IAX_ALLOWFWDOWNLOAD
#define IAX_ALLOWFWDOWNLOAD
Definition chan_iax2.c:560
IAX_CODEC_USER_FIRST
#define IAX_CODEC_USER_FIRST
Definition chan_iax2.c:549
iax2_lock_callno_unless_destroyed
static int iax2_lock_callno_unless_destroyed(int callno)
Acquire the iaxsl[callno] if call exists and not having ongoing hangup.
Definition chan_iax2.c:1784
callno_pool_trunk
static struct call_number_pool callno_pool_trunk
Definition chan_iax2.c:1007
global_maxcallno
static uint16_t global_maxcallno
Definition chan_iax2.c:1056
remove_by_peercallno
static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:2514
CALLTOKEN_HASH_FORMAT
#define CALLTOKEN_HASH_FORMAT
IAX_DELME
#define IAX_DELME
Definition chan_iax2.c:536
CACHE_FLAG_TIMEOUT
@ CACHE_FLAG_TIMEOUT
Definition chan_iax2.c:1097
CACHE_FLAG_EXISTS
@ CACHE_FLAG_EXISTS
Definition chan_iax2.c:1089
CACHE_FLAG_UNKNOWN
@ CACHE_FLAG_UNKNOWN
Definition chan_iax2.c:1101
CACHE_FLAG_MATCHMORE
@ CACHE_FLAG_MATCHMORE
Definition chan_iax2.c:1103
CACHE_FLAG_CANEXIST
@ CACHE_FLAG_CANEXIST
Definition chan_iax2.c:1093
CACHE_FLAG_PENDING
@ CACHE_FLAG_PENDING
Definition chan_iax2.c:1095
CACHE_FLAG_NONEXISTENT
@ CACHE_FLAG_NONEXISTENT
Definition chan_iax2.c:1091
CACHE_FLAG_TRANSMITTED
@ CACHE_FLAG_TRANSMITTED
Definition chan_iax2.c:1099
start_network_thread
static int start_network_thread(void)
Definition chan_iax2.c:12845
PEERS_FORMAT
#define PEERS_FORMAT
Definition chan_iax2.c:6996
calc_rxstamp
static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset)
Definition chan_iax2.c:6337
callno_type
callno_type
Definition chan_iax2.c:983
CALLNO_TYPE_TRUNK
@ CALLNO_TYPE_TRUNK
Definition chan_iax2.c:985
CALLNO_TYPE_NORMAL
@ CALLNO_TYPE_NORMAL
Definition chan_iax2.c:984
iax2_sched_replace
static int iax2_sched_replace(int id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data)
Definition chan_iax2.c:1766
mohsuggest
static char mohsuggest[MAX_MUSICCLASS]
Definition chan_iax2.c:512
__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)
Definition chan_iax2.c:3194
build_encryption_keys
static void build_encryption_keys(const unsigned char *digest, struct chan_iax2_pvt *pvt)
Definition chan_iax2.c:6512
qos
static struct @118 qos
build_callno_limits
static void build_callno_limits(struct ast_variable *v)
Definition chan_iax2.c:2826
__attempt_transmit
static void __attempt_transmit(const void *data)
Definition chan_iax2.c:3634
cli_iax2
static struct ast_cli_entry cli_iax2[]
Definition chan_iax2.c:14717
iax2_datetime
static unsigned int iax2_datetime(const char *tz)
Definition chan_iax2.c:4857
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)
Definition chan_iax2.c:6696
IAX_CODEC_NOPREFS
#define IAX_CODEC_NOPREFS
Definition chan_iax2.c:550
auto_hangup
static int auto_hangup(const void *data)
Definition chan_iax2.c:9541
handle_cli_iax2_show_threads
static char * handle_cli_iax2_show_threads(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition chan_iax2.c:7191
acl_change_stasis_cb
static void acl_change_stasis_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Definition chan_iax2.c:1597
mohinterpret
static char mohinterpret[MAX_MUSICCLASS]
Definition chan_iax2.c:511
iax2_variable_datastore_info
static const struct ast_datastore_info iax2_variable_datastore_info
Definition chan_iax2.c:1608
sched_delay_remove
static void sched_delay_remove(struct ast_sockaddr *addr, callno_entry entry)
Definition chan_iax2.c:3140
iax2_do_register_s
static int iax2_do_register_s(const void *data)
Definition chan_iax2.c:8754
iax2_devicestate
static int iax2_devicestate(const char *data)
Part of the device state notification system —.
Definition chan_iax2.c:14667
peercnt_remove
static void peercnt_remove(struct peercnt *peercnt)
Definition chan_iax2.c:2768
network_change_sched_id
static int network_change_sched_id
Definition chan_iax2.c:366
expire_registry
static int expire_registry(const void *data)
Definition chan_iax2.c:9134
MAX_PEER_BUCKETS
#define MAX_PEER_BUCKETS
Definition chan_iax2.c:1036
iax2_frame_free
static void iax2_frame_free(struct iax_frame *fr)
Definition chan_iax2.c:2216
memcpy_encrypt
static void memcpy_encrypt(unsigned char *dst, const unsigned char *src, int len, ast_aes_encrypt_key *ecx)
Definition chan_iax2.c:6552
requirecalltoken_mark_auto
static void requirecalltoken_mark_auto(const char *name, int subclass)
Definition chan_iax2.c:5003
defaultsockfd
static int defaultsockfd
Definition chan_iax2.c:405
iaxmaxthreadcount
static int iaxmaxthreadcount
Definition chan_iax2.c:758
peercnt_cmp_cb
static int peercnt_cmp_cb(void *obj, void *arg, int flags)
Definition chan_iax2.c:2555
iax_peercallno_pvts
static struct ao2_container * iax_peercallno_pvts
Another container of iax2_pvt structures.
Definition chan_iax2.c:1240
send_command_locked
static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int)
Definition chan_iax2.c:7895
make_trunk
static int make_trunk(unsigned short callno, int locked)
Definition chan_iax2.c:2419
register_verify
static int register_verify(int callno, struct ast_sockaddr *addr, struct iax_ies *ies)
Verify inbound registration.
Definition chan_iax2.c:8356
global_max_trunk_mtu
static int global_max_trunk_mtu
Definition chan_iax2.c:354
iax2_dprequest
static void iax2_dprequest(struct iax2_dpcache *dp, int callno)
Definition chan_iax2.c:9556
type
static const char type[]
Definition chan_ooh323.c:109
bindaddr
struct ast_sockaddr bindaddr
Definition chan_ooh323.c:353
version
static char version[AST_MAX_EXTENSION]
Definition chan_ooh323.c:391
config
static const char config[]
Definition chan_ooh323.c:111
transfer
static int transfer(void *data)
Definition chan_pjsip.c:2141
reload_config
static int reload_config(void)
Definition chan_unistim.c:6844
ast_channel_exten_set
void ast_channel_exten_set(struct ast_channel *chan, const char *value)
Definition channel_internal_api.c:240
ast_channel_name
const char * ast_channel_name(const struct ast_channel *chan)
ast_channel_alloc_with_endpoint
#define ast_channel_alloc_with_endpoint(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag, endpoint,...)
Definition channel.h:1303
ast_channel_tech_pvt
void * ast_channel_tech_pvt(const struct ast_channel *chan)
Definition channel_internal_api.c:437
ast_channel_datastore_add
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition channel.c:2376
ast_hangup
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition channel.c:2540
AST_BRIDGE_DTMF_CHANNEL_0
#define AST_BRIDGE_DTMF_CHANNEL_0
Report DTMF on channel 0.
Definition channel.h:2420
ast_channel_alloc
#define ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag,...)
Create a channel structure.
Definition channel.h:1299
ast_queue_hangup
int ast_queue_hangup(struct ast_channel *chan)
Queue a hangup frame.
Definition channel.c:1182
ast_party_id_presentation
int ast_party_id_presentation(const struct ast_party_id *id)
Determine the overall presentation value for the given party.
Definition channel.c:1808
DATASTORE_INHERIT_FOREVER
#define DATASTORE_INHERIT_FOREVER
Definition channel.h:194
ast_channel_nativeformats_set
void ast_channel_nativeformats_set(struct ast_channel *chan, struct ast_format_cap *value)
Definition channel_internal_api.c:544
ast_party_connected_line_free
void ast_party_connected_line_free(struct ast_party_connected_line *doomed)
Destroy the connected line information contents.
Definition channel.c:2059
ast_waitfor_n
struct ast_channel * ast_waitfor_n(struct ast_channel **chan, int n, int *ms)
Waits for input on a group of channels Wait for input on an array of channels for a given # of millis...
Definition channel.c:3161
ast_channel_lock
#define ast_channel_lock(chan)
Definition channel.h:2983
ast_channel_nativeformats
struct ast_format_cap * ast_channel_nativeformats(const struct ast_channel *chan)
Definition channel_internal_api.c:504
AST_FLAG_DISABLE_DEVSTATE_CACHE
@ AST_FLAG_DISABLE_DEVSTATE_CACHE
Definition channel.h:1049
ast_channel_redirecting
struct ast_party_redirecting * ast_channel_redirecting(struct ast_channel *chan)
Definition channel_internal_api.c:775
ast_channel_unregister
void ast_channel_unregister(const struct ast_channel_tech *tech)
Unregister a channel technology.
Definition channel.c:571
ast_channel_flags
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
Definition channel_internal_api.c:1156
ast_channel_ref
#define ast_channel_ref(c)
Increase channel reference count.
Definition channel.h:3008
ast_channel_connected
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
Definition channel_internal_api.c:759
ast_queue_frame
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel's frame queue.
Definition channel.c:1171
ast_channel_context
const char * ast_channel_context(const struct ast_channel *chan)
Definition channel_internal_api.c:215
ast_write
int ast_write(struct ast_channel *chan, struct ast_frame *frame)
Write a frame to a channel This function writes the given frame to the indicated channel.
Definition channel.c:5167
ast_read
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
Definition channel.c:4278
AST_BRIDGE_DTMF_CHANNEL_1
#define AST_BRIDGE_DTMF_CHANNEL_1
Report DTMF on channel 1.
Definition channel.h:2422
ast_channel_trylock
#define ast_channel_trylock(chan)
Definition channel.h:2985
ast_queue_control_data
int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame with payload.
Definition channel.c:1296
ast_channel_adsicpe
ast_channel_adsicpe
Definition channel.h:888
AST_ADSI_UNAVAILABLE
@ AST_ADSI_UNAVAILABLE
Definition channel.h:891
ast_set_callerid
void ast_set_callerid(struct ast_channel *chan, const char *cid_num, const char *cid_name, const char *cid_ani)
Set caller ID number, name and ANI and generate AMI event.
Definition channel.c:7370
ast_set_read_format
int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
Sets read format on channel chan.
Definition channel.c:5785
ast_channel_set_rawreadformat
void ast_channel_set_rawreadformat(struct ast_channel *chan, struct ast_format *format)
Definition channel_internal_api.c:695
ast_channel_tech_pvt_set
void ast_channel_tech_pvt_set(struct ast_channel *chan, void *value)
Definition channel_internal_api.c:441
ast_connected_line_parse_data
int ast_connected_line_parse_data(const unsigned char *data, size_t datalen, struct ast_party_connected_line *connected)
Parse connected line indication frame data.
Definition channel.c:8961
ast_check_hangup
int ast_check_hangup(struct ast_channel *chan)
Check to see if a channel is needing hang up.
Definition channel.c:446
ast_channel_hangupcause
int ast_channel_hangupcause(const struct ast_channel *chan)
Definition channel_internal_api.c:298
ast_channel_set_rawwriteformat
void ast_channel_set_rawwriteformat(struct ast_channel *chan, struct ast_format *format)
Definition channel_internal_api.c:699
ast_channel_dialed
struct ast_party_dialed * ast_channel_dialed(struct ast_channel *chan)
Definition channel_internal_api.c:771
AST_MAX_ACCOUNT_CODE
#define AST_MAX_ACCOUNT_CODE
Definition channel.h:172
ast_channel_release
struct ast_channel * ast_channel_release(struct ast_channel *chan)
Unlink and release reference to a channel.
Definition channel.c:1571
ast_set_hangupsource
void ast_set_hangupsource(struct ast_channel *chan, const char *source, int force)
Set the source of the hangup in this channel and it's bridge.
Definition channel.c:2498
ast_channel_hangupcause_hash_set
void ast_channel_hangupcause_hash_set(struct ast_channel *chan, const struct ast_control_pvt_cause_code *cause_code, int datalen)
Sets the HANGUPCAUSE hash and optionally the SIP_CAUSE hash on the given channel.
Definition channel.c:4368
ast_queue_unhold
int ast_queue_unhold(struct ast_channel *chan)
Queue an unhold frame.
Definition channel.c:1274
ast_bridge_result
ast_bridge_result
Definition channel.h:208
AST_BRIDGE_FAILED_NOWARN
@ AST_BRIDGE_FAILED_NOWARN
Definition channel.h:211
AST_BRIDGE_RETRY
@ AST_BRIDGE_RETRY
Definition channel.h:212
AST_BRIDGE_COMPLETE
@ AST_BRIDGE_COMPLETE
Definition channel.h:209
AST_BRIDGE_FAILED
@ AST_BRIDGE_FAILED
Definition channel.h:210
ast_queue_hold
int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
Queue a hold frame.
Definition channel.c:1249
ast_channel_set_readformat
void ast_channel_set_readformat(struct ast_channel *chan, struct ast_format *format)
Definition channel_internal_api.c:703
AST_CHANNEL_NAME
#define AST_CHANNEL_NAME
Definition channel.h:173
ast_channel_register
int ast_channel_register(const struct ast_channel_tech *tech)
Register a channel technology (a new channel driver) Called by a channel module to register the kind ...
Definition channel.c:540
ast_channel_softhangup_internal_flag_add
void ast_channel_softhangup_internal_flag_add(struct ast_channel *chan, int value)
Definition channel_internal_api.c:872
ast_channel_unref
#define ast_channel_unref(c)
Decrease channel reference count.
Definition channel.h:3019
ast_channel_writeformat
struct ast_format * ast_channel_writeformat(struct ast_channel *chan)
Definition channel_internal_api.c:727
ast_set_write_format
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
Sets write format on channel chan.
Definition channel.c:5826
AST_MAX_CONTEXT
#define AST_MAX_CONTEXT
Definition channel.h:135
ast_party_connected_line_init
void ast_party_connected_line_init(struct ast_party_connected_line *init)
Initialize the given connected line structure.
Definition channel.c:2009
ast_channel_amaflags_set
void ast_channel_amaflags_set(struct ast_channel *chan, enum ama_flags value)
Definition channel_internal_api.c:282
ast_channel_language
const char * ast_channel_language(const struct ast_channel *chan)
ast_channel_context_set
void ast_channel_context_set(struct ast_channel *chan, const char *value)
Definition channel_internal_api.c:223
AST_SOFTHANGUP_DEV
@ AST_SOFTHANGUP_DEV
Definition channel.h:1141
ast_channel_string2amaflag
enum ama_flags ast_channel_string2amaflag(const char *flag)
Convert a string to a detail record AMA flag.
Definition channel.c:4382
AST_CHAN_TP_WANTSJITTER
@ AST_CHAN_TP_WANTSJITTER
Channels have this property if they can accept input with jitter; i.e. most VoIP channels.
Definition channel.h:980
ast_channel_caller
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
Definition channel_internal_api.c:755
ast_channel_callid_set
void ast_channel_callid_set(struct ast_channel *chan, ast_callid value)
Definition channel_internal_api.c:664
ast_channel_hangupcause_set
void ast_channel_hangupcause_set(struct ast_channel *chan, int value)
Definition channel_internal_api.c:302
ast_channel_adsicpe_set
void ast_channel_adsicpe_set(struct ast_channel *chan, enum ast_channel_adsicpe value)
Definition channel_internal_api.c:652
ast_channel_tech_set
void ast_channel_tech_set(struct ast_channel *chan, const struct ast_channel_tech *value)
Definition channel_internal_api.c:640
ast_channel_unlock
#define ast_channel_unlock(chan)
Definition channel.h:2984
AST_MAX_EXTENSION
#define AST_MAX_EXTENSION
Definition channel.h:134
ast_channel_set_writeformat
void ast_channel_set_writeformat(struct ast_channel *chan, struct ast_format *format)
Definition channel_internal_api.c:707
MAX_MUSICCLASS
#define MAX_MUSICCLASS
Definition channel.h:175
ast_channel_datastore_find
struct ast_datastore * ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
Find a datastore on a channel.
Definition channel.c:2390
ast_channel_readformat
struct ast_format * ast_channel_readformat(struct ast_channel *chan)
Definition channel_internal_api.c:723
iax2_format_compatibility_best
uint64_t iax2_format_compatibility_best(uint64_t formats)
Pick the best format from the given bitfield formats.
Definition channels/iax2/format_compatibility.c:79
iax2_format_compatibility_cap2bitfield
uint64_t iax2_format_compatibility_cap2bitfield(const struct ast_format_cap *cap)
Convert a format capabilities structure to a bitfield.
Definition channels/iax2/format_compatibility.c:43
iax2_format_compatibility_bitfield2cap
int iax2_format_compatibility_bitfield2cap(uint64_t bitfield, struct ast_format_cap *cap)
Convert a bitfield to a format capabilities structure.
Definition channels/iax2/format_compatibility.c:59
ast_channel_state
ast_channel_state
ast_channel states
Definition channelstate.h:35
AST_STATE_RING
@ AST_STATE_RING
Definition channelstate.h:40
AST_STATE_RINGING
@ AST_STATE_RINGING
Definition channelstate.h:41
AST_STATE_DOWN
@ AST_STATE_DOWN
Definition channelstate.h:36
AST_STATE_RESERVED
@ AST_STATE_RESERVED
Definition channelstate.h:37
ast_setstate
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
Definition channel.c:7422
callback
static struct ast_channel * callback(struct ast_channelstorage_instance *driver, ao2_callback_data_fn *cb_fn, void *arg, void *data, int ao2_flags, int rdlock)
Definition channelstorage_ao2_legacy.c:66
ast_var_name
const char * ast_var_name(const struct ast_var_t *var)
Definition chanvars.c:60
ast_var_assign
#define ast_var_assign(name, value)
Definition chanvars.h:40
ast_var_value
const char * ast_var_value(const struct ast_var_t *var)
Definition chanvars.c:80
ast_var_delete
void ast_var_delete(struct ast_var_t *var)
Definition extconf.c:2469
CLI_SHOWUSAGE
#define CLI_SHOWUSAGE
Definition cli.h:45
CLI_SUCCESS
#define CLI_SUCCESS
Definition cli.h:44
AST_CLI_DEFINE
#define AST_CLI_DEFINE(fn, txt,...)
Definition cli.h:197
RESULT_SHOWUSAGE
#define RESULT_SHOWUSAGE
Definition cli.h:41
ast_cli
void ast_cli(int fd, const char *fmt,...)
Definition clicompat.c:6
RESULT_SUCCESS
#define RESULT_SUCCESS
Definition cli.h:40
ast_cli_complete
char * ast_cli_complete(const char *word, const char *const choices[], int pos)
Definition main/cli.c:1931
CLI_HANDLER
@ CLI_HANDLER
Definition cli.h:154
CLI_INIT
@ CLI_INIT
Definition cli.h:152
CLI_GENERATE
@ CLI_GENERATE
Definition cli.h:153
CLI_FAILURE
#define CLI_FAILURE
Definition cli.h:46
RESULT_FAILURE
#define RESULT_FAILURE
Definition cli.h:42
ast_cli_register_multiple
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition cli.h:265
AST_MEDIA_TYPE_AUDIO
@ AST_MEDIA_TYPE_AUDIO
Definition codec.h:32
AST_MEDIA_TYPE_UNKNOWN
@ AST_MEDIA_TYPE_UNKNOWN
Definition codec.h:31
ast_codec_samples_count
unsigned int ast_codec_samples_count(struct ast_frame *frame)
Get the number of samples contained within a frame.
Definition codec.c:379
iax2_codec_pref_string
int iax2_codec_pref_string(struct iax2_codec_pref *pref, char *buf, size_t size)
Dump audio codec preference list into a string.
Definition codec_pref.c:178
iax2_codec_pref_prepend
void iax2_codec_pref_prepend(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing, int only_if_existing)
Prepend an audio codec to a preference list, removing it first if it was already there.
Definition codec_pref.c:432
iax2_codec_pref_order_value_to_format_bitfield
uint64_t iax2_codec_pref_order_value_to_format_bitfield(int order_value)
Convert an iax2_codec_pref order value into a format bitfield.
Definition codec_pref.c:367
iax2_codec_pref_from_bitfield
uint64_t iax2_codec_pref_from_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield)
Create codec preference list from the given bitfield formats.
Definition codec_pref.c:481
iax2_codec_pref_index
struct ast_format * iax2_codec_pref_index(struct iax2_codec_pref *pref, int idx, struct ast_format **result)
Codec located at a particular place in the preference index.
Definition codec_pref.c:77
iax2_codec_pref_convert
void iax2_codec_pref_convert(struct iax2_codec_pref *pref, char *buf, size_t size, int right)
Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.
Definition codec_pref.c:44
iax2_codec_pref_remove_missing
void iax2_codec_pref_remove_missing(struct iax2_codec_pref *pref, uint64_t bitfield)
Removes format from the pref list that aren't in the bitfield.
Definition codec_pref.c:288
iax2_codec_pref_append
void iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing)
Append a audio codec to a preference list, removing it first if it was already there.
Definition codec_pref.c:420
iax2_codec_pref_to_cap
int iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
Convert a preference structure to a capabilities structure.
Definition codec_pref.c:91
iax2_codec_pref_best_bitfield2cap
int iax2_codec_pref_best_bitfield2cap(uint64_t bitfield, struct iax2_codec_pref *prefs, struct ast_format_cap *cap)
Convert a bitfield to a format capabilities structure in the "best" order.
Definition codec_pref.c:112
word
short word
Definition codecs/gsm/inc/private.h:12
attribute_pure
#define attribute_pure
Definition compiler.h:35
SENTINEL
#define SENTINEL
Definition compiler.h:87
ast_check_signature
int AST_OPTIONAL_API_NAME() ast_check_signature(struct ast_key *key, const char *msg, const char *sig)
Check the authenticity of a message signature using a given public key.
Definition res_crypto.c:673
ast_aes_set_encrypt_key
int AST_OPTIONAL_API_NAME() ast_aes_set_encrypt_key(const unsigned char *key, ast_aes_encrypt_key *ctx)
Set an encryption key.
Definition res_crypto.c:700
ast_sign
int AST_OPTIONAL_API_NAME() ast_sign(struct ast_key *key, char *msg, char *sig)
Sign a message signature using a given private key.
Definition res_crypto.c:584
ast_aes_decrypt
int AST_OPTIONAL_API_NAME() ast_aes_decrypt(const unsigned char *in, unsigned char *out, const ast_aes_decrypt_key *key)
AES decrypt data.
Definition res_crypto.c:790
AST_KEY_PUBLIC
#define AST_KEY_PUBLIC
Definition crypto.h:46
AST_KEY_PRIVATE
#define AST_KEY_PRIVATE
Definition crypto.h:47
ast_key_get
struct ast_key *AST_OPTIONAL_API_NAME() ast_key_get(const char *kname, int ktype)
Retrieve a key.
Definition res_crypto.c:149
ast_aes_set_decrypt_key
int AST_OPTIONAL_API_NAME() ast_aes_set_decrypt_key(const unsigned char *key, ast_aes_decrypt_key *ctx)
Set a decryption key.
Definition res_crypto.c:709
ast_aes_encrypt
int AST_OPTIONAL_API_NAME() ast_aes_encrypt(const unsigned char *in, unsigned char *out, const ast_aes_encrypt_key *key)
AES encrypt data.
Definition res_crypto.c:749
ast_datastore_alloc
#define ast_datastore_alloc(info, uid)
Definition datastore.h:85
ast_datastore_free
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition datastore.c:68
AST_DEVSTATE_CACHABLE
@ AST_DEVSTATE_CACHABLE
Definition devicestate.h:70
ast_devstate_changed
int ast_devstate_changed(enum ast_device_state state, enum ast_devstate_cache cachable, const char *fmt,...)
Tells Asterisk the State for Device is changed.
Definition devicestate.c:513
AST_DEVICE_UNKNOWN
@ AST_DEVICE_UNKNOWN
Definition devicestate.h:53
AST_DEVICE_INVALID
@ AST_DEVICE_INVALID
Definition devicestate.h:57
AST_DEVICE_NOT_INUSE
@ AST_DEVICE_NOT_INUSE
Definition devicestate.h:54
AST_DEVICE_UNAVAILABLE
@ AST_DEVICE_UNAVAILABLE
Definition devicestate.h:58
ast_dnsmgr_release
void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
Free a DNS manager entry.
Definition dnsmgr.c:136
ast_dnsmgr_lookup
int ast_dnsmgr_lookup(const char *name, struct ast_sockaddr *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
Allocate and initialize a DNS manager entry.
Definition dnsmgr.c:191
ast_dnsmgr_changed
int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry)
Check is see if a dnsmgr entry has changed.
Definition dnsmgr.c:247
ast_dnsmgr_refresh
int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry)
Force a refresh of a dnsmgr entry.
Definition dnsmgr.c:239
threshold
threshold
Definition dsp.h:73
end
char * end
Definition eagi_proxy.c:73
buf
char buf[BUFSIZE]
Definition eagi_proxy.c:66
AST_ENDPOINT_OFFLINE
@ AST_ENDPOINT_OFFLINE
Definition endpoints.h:55
AST_ENDPOINT_ONLINE
@ AST_ENDPOINT_ONLINE
Definition endpoints.h:57
ast_endpoint_set_state
void ast_endpoint_set_state(struct ast_endpoint *endpoint, enum ast_endpoint_state state)
Updates the state of the given endpoint.
Definition main/endpoints.c:389
ast_endpoint_shutdown
void ast_endpoint_shutdown(struct ast_endpoint *endpoint)
Shutsdown an ast_endpoint.
Definition main/endpoints.c:320
ast_endpoint_create
struct ast_endpoint * ast_endpoint_create(const char *tech, const char *resource)
Create an endpoint struct.
Definition main/endpoints.c:289
abs
#define abs(x)
Definition f2c.h:195
iax_firmware_get_version
int iax_firmware_get_version(const char *dev, uint16_t *version)
Definition firmware.c:263
iax_firmware_reload
void iax_firmware_reload(void)
Definition firmware.c:206
iax_firmware_unload
void iax_firmware_unload(void)
Definition firmware.c:250
iax_firmware_append
int iax_firmware_append(struct iax_ie_data *ied, const char *dev, unsigned int desc)
Definition firmware.c:283
iax_firmware_traverse
void iax_firmware_traverse(const char *filter, int(*callback)(struct ast_iax2_firmware_header *header, void *data), void *data)
Definition firmware.c:321
ast_format_get_type
enum ast_media_type ast_format_get_type(const struct ast_format *format)
Get the media type of a format.
Definition format.c:354
ast_format_get_sample_rate
unsigned int ast_format_get_sample_rate(const struct ast_format *format)
Get the sample rate of a media format.
Definition format.c:379
ast_format_cmp
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition format.c:201
AST_FORMAT_CMP_EQUAL
@ AST_FORMAT_CMP_EQUAL
Definition format.h:36
ast_format_get_name
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition format.c:334
ast_format_get_default_ms
unsigned int ast_format_get_default_ms(const struct ast_format *format)
Get the default framing size (in milliseconds) for a format.
Definition format.c:359
ast_format_slin
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
Definition format_cache.c:41
ast_format_none
struct ast_format * ast_format_none
Built-in "null" format.
Definition format_cache.c:246
AST_FORMAT_CAP_NAMES_LEN
#define AST_FORMAT_CAP_NAMES_LEN
Definition format_cap.h:324
ast_format_cap_append_by_type
int ast_format_cap_append_by_type(struct ast_format_cap *cap, enum ast_media_type type)
Add all codecs Asterisk knows about for a specific type to the capabilities structure.
Definition format_cap.c:216
ast_format_cap_get_format
struct ast_format * ast_format_cap_get_format(const struct ast_format_cap *cap, int position)
Get the format at a specific index.
Definition format_cap.c:400
ast_format_cap_get_format_framing
unsigned int ast_format_cap_get_format_framing(const struct ast_format_cap *cap, const struct ast_format *format)
Get the framing for a format.
Definition format_cap.c:443
ast_format_cap_update_by_allow_disallow
int ast_format_cap_update_by_allow_disallow(struct ast_format_cap *cap, const char *list, int allowing)
Parse an "allow" or "deny" list and modify a format capabilities structure accordingly.
Definition format_cap.c:320
ast_format_cap_get_compatible
int ast_format_cap_get_compatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2, struct ast_format_cap *result)
Find the compatible formats between two capabilities structures.
Definition format_cap.c:628
AST_FORMAT_CAP_FLAG_DEFAULT
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition format_cap.h:38
ast_format_cap_get_names
const char * ast_format_cap_get_names(const struct ast_format_cap *cap, struct ast_str **buf)
Get the names of codecs of a set of formats.
Definition format_cap.c:734
ast_format_cap_identical
int ast_format_cap_identical(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if two capabilities structures are identical.
Definition format_cap.c:687
ast_format_cap_append
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition format_cap.h:99
ast_format_cap_alloc
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition format_cap.h:49
ast_format_cap_count
size_t ast_format_cap_count(const struct ast_format_cap *cap)
Get the number of formats present within the capabilities structure.
Definition format_cap.c:395
ast_format_cap_get_compatible_format
struct ast_format * ast_format_cap_get_compatible_format(const struct ast_format_cap *cap, const struct ast_format *format)
Find if input ast_format is within the capabilities of the ast_format_cap object then return the comp...
Definition format_cap.c:546
name
static const char name[]
Definition format_mp3.c:68
exists
static int exists(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
Definition func_logic.c:185
md5
static int md5(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
Definition func_md5.c:55
len
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
Definition func_strings.c:1669
astman_send_listack
void astman_send_listack(struct mansession *s, const struct message *m, char *msg, char *listflag)
Send ack in manager transaction to begin a list.
Definition manager.c:2042
astman_send_list_complete_start
void astman_send_list_complete_start(struct mansession *s, const struct message *m, const char *event_name, int count)
Start the list complete event.
Definition manager.c:2078
astman_get_header
const char * astman_get_header(const struct message *m, char *var)
Get header from manager transaction.
Definition manager.c:1661
astman_send_list_complete_end
void astman_send_list_complete_end(struct mansession *s)
End the list complete event.
Definition manager.c:2086
astman_append
void astman_append(struct mansession *s, const char *fmt,...)
Definition manager.c:1921
ast_manager_unregister
int ast_manager_unregister(const char *action)
Unregister a registered manager command.
Definition manager.c:7716
ast_endpoint_blob_publish
void ast_endpoint_blob_publish(struct ast_endpoint *endpoint, struct stasis_message_type *type, struct ast_json *blob)
Creates and publishes a ast_endpoint_blob message.
Definition stasis_endpoints.c:331
ast_channel_stage_snapshot_done
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
Definition stasis_channels.c:1071
ast_endpoint_state_type
struct stasis_message_type * ast_endpoint_state_type(void)
Message type for endpoint state changes.
ast_channel_stage_snapshot
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
Definition stasis_channels.c:1066
iax2_prov_app
static int iax2_prov_app(struct ast_channel *chan, const char *data)
Definition chan_iax2.c:12494
ext
const char * ext
Definition http.c:151
IAX_IE_PASSWORD
#define IAX_IE_PASSWORD
Definition iax2.h:137
IAX_LINGER_TIMEOUT
#define IAX_LINGER_TIMEOUT
Definition iax2.h:126
IAX_IE_RR_PKTS
#define IAX_IE_RR_PKTS
Definition iax2.h:179
IAX_DPSTATUS_CANEXIST
#define IAX_DPSTATUS_CANEXIST
Definition iax2.h:218
IAX_COMMAND_FWDOWNL
@ IAX_COMMAND_FWDOWNL
Definition iax2.h:111
IAX_COMMAND_TXREL
@ IAX_COMMAND_TXREL
Definition iax2.h:91
IAX_COMMAND_TXMEDIA
@ IAX_COMMAND_TXMEDIA
Definition iax2.h:115
IAX_COMMAND_AUTHREP
@ IAX_COMMAND_AUTHREP
Definition iax2.h:60
IAX_COMMAND_PROVISION
@ IAX_COMMAND_PROVISION
Definition iax2.h:109
IAX_COMMAND_DPREP
@ IAX_COMMAND_DPREP
Definition iax2.h:79
IAX_COMMAND_REGAUTH
@ IAX_COMMAND_REGAUTH
Definition iax2.h:67
IAX_COMMAND_INVAL
@ IAX_COMMAND_INVAL
Definition iax2.h:61
IAX_COMMAND_REJECT
@ IAX_COMMAND_REJECT
Definition iax2.h:57
IAX_COMMAND_FWDATA
@ IAX_COMMAND_FWDATA
Definition iax2.h:113
IAX_COMMAND_ACK
@ IAX_COMMAND_ACK
Definition iax2.h:55
IAX_COMMAND_PONG
@ IAX_COMMAND_PONG
Definition iax2.h:54
IAX_COMMAND_LAGRQ
@ IAX_COMMAND_LAGRQ
Definition iax2.h:62
IAX_COMMAND_HANGUP
@ IAX_COMMAND_HANGUP
Definition iax2.h:56
IAX_COMMAND_TXREADY
@ IAX_COMMAND_TXREADY
Definition iax2.h:89
IAX_COMMAND_TXACC
@ IAX_COMMAND_TXACC
Definition iax2.h:87
IAX_COMMAND_QUELCH
@ IAX_COMMAND_QUELCH
Definition iax2.h:95
IAX_COMMAND_PING
@ IAX_COMMAND_PING
Definition iax2.h:53
IAX_COMMAND_TRANSFER
@ IAX_COMMAND_TRANSFER
Definition iax2.h:107
IAX_COMMAND_LAGRP
@ IAX_COMMAND_LAGRP
Definition iax2.h:63
IAX_COMMAND_TXCNT
@ IAX_COMMAND_TXCNT
Definition iax2.h:85
IAX_COMMAND_REGACK
@ IAX_COMMAND_REGACK
Definition iax2.h:69
IAX_COMMAND_AUTHREQ
@ IAX_COMMAND_AUTHREQ
Definition iax2.h:59
IAX_COMMAND_TXREJ
@ IAX_COMMAND_TXREJ
Definition iax2.h:93
IAX_COMMAND_REGREJ
@ IAX_COMMAND_REGREJ
Definition iax2.h:71
IAX_COMMAND_REGREL
@ IAX_COMMAND_REGREL
Definition iax2.h:73
IAX_COMMAND_CALLTOKEN
@ IAX_COMMAND_CALLTOKEN
Definition iax2.h:119
IAX_COMMAND_DIAL
@ IAX_COMMAND_DIAL
Definition iax2.h:81
IAX_COMMAND_ACCEPT
@ IAX_COMMAND_ACCEPT
Definition iax2.h:58
IAX_COMMAND_UNSUPPORT
@ IAX_COMMAND_UNSUPPORT
Definition iax2.h:105
IAX_COMMAND_NEW
@ IAX_COMMAND_NEW
Definition iax2.h:52
IAX_COMMAND_POKE
@ IAX_COMMAND_POKE
Definition iax2.h:99
IAX_COMMAND_REGREQ
@ IAX_COMMAND_REGREQ
Definition iax2.h:65
IAX_COMMAND_VNAK
@ IAX_COMMAND_VNAK
Definition iax2.h:75
IAX_COMMAND_UNQUELCH
@ IAX_COMMAND_UNQUELCH
Definition iax2.h:97
IAX_COMMAND_TXREQ
@ IAX_COMMAND_TXREQ
Definition iax2.h:83
IAX_COMMAND_RTKEY
@ IAX_COMMAND_RTKEY
Definition iax2.h:117
IAX_COMMAND_DPREQ
@ IAX_COMMAND_DPREQ
Definition iax2.h:77
IAX_IE_RR_JITTER
#define IAX_IE_RR_JITTER
Definition iax2.h:177
IAX_MAX_OSPBLOCK_SIZE
#define IAX_MAX_OSPBLOCK_SIZE
Definition iax2.h:192
IAX_IE_DNID
#define IAX_IE_DNID
Definition iax2.h:143
IAX_IE_CALLINGANI2
#define IAX_IE_CALLINGANI2
Definition iax2.h:190
IAX_FLAG_SC_LOG
#define IAX_FLAG_SC_LOG
Definition iax2.h:44
IAX_IE_DATETIME
#define IAX_IE_DATETIME
Definition iax2.h:161
IAX_IE_CAUSE
#define IAX_IE_CAUSE
Definition iax2.h:152
IAX_IE_DPSTATUS
#define IAX_IE_DPSTATUS
Definition iax2.h:150
IAX_IE_CALLING_NUMBER
#define IAX_IE_CALLING_NUMBER
Definition iax2.h:132
IAX_IE_TRANSFERID
#define IAX_IE_TRANSFERID
Definition iax2.h:157
IAX_IE_CALLTOKEN
#define IAX_IE_CALLTOKEN
Definition iax2.h:185
IAX_IE_CALLING_ANI
#define IAX_IE_CALLING_ANI
Definition iax2.h:133
IAX_DEFAULT_PORTNO
#define IAX_DEFAULT_PORTNO
Definition iax2.h:128
IAX_IE_CALLINGTNS
#define IAX_IE_CALLINGTNS
Definition iax2.h:170
IAX_IE_RSA_RESULT
#define IAX_IE_RSA_RESULT
Definition iax2.h:147
IAX_IE_MSGCOUNT
#define IAX_IE_MSGCOUNT
Definition iax2.h:154
IAX_META_TRUNK_SUPERMINI
#define IAX_META_TRUNK_SUPERMINI
Definition iax2.h:207
IAX_IE_IAX_UNKNOWN
#define IAX_IE_IAX_UNKNOWN
Definition iax2.h:153
iax2_format
int64_t iax2_format
Definition iax2.h:224
IAX_DPSTATUS_NONEXISTENT
#define IAX_DPSTATUS_NONEXISTENT
Definition iax2.h:219
IAX_IE_FORMAT2
#define IAX_IE_FORMAT2
Definition iax2.h:188
IAX_DPSTATUS_IGNOREPAT
#define IAX_DPSTATUS_IGNOREPAT
Definition iax2.h:220
IAX_IE_CAPABILITY2
#define IAX_IE_CAPABILITY2
Definition iax2.h:187
IAX_IE_CALLING_NAME
#define IAX_IE_CALLING_NAME
Definition iax2.h:134
IAX_DEFAULT_REG_EXPIRE
#define IAX_DEFAULT_REG_EXPIRE
Definition iax2.h:123
IAX_IE_ADSICPE
#define IAX_IE_ADSICPE
Definition iax2.h:142
IAX_IE_VARIABLE
#define IAX_IE_VARIABLE
Definition iax2.h:183
IAX_AUTH_RSA
#define IAX_AUTH_RSA
Definition iax2.h:199
IAX_IE_OSPTOKEN
#define IAX_IE_OSPTOKEN
Definition iax2.h:184
IAX_IE_LANGUAGE
#define IAX_IE_LANGUAGE
Definition iax2.h:140
IAX_MAX_OSPTOKEN_SIZE
#define IAX_MAX_OSPTOKEN_SIZE
Definition iax2.h:194
IAX_IE_RDNIS
#define IAX_IE_RDNIS
Definition iax2.h:158
IAX_FLAG_FULL
#define IAX_FLAG_FULL
Definition iax2.h:40
IAX_IE_RR_DROPPED
#define IAX_IE_RR_DROPPED
Definition iax2.h:181
IAX_MAX_SHIFT
#define IAX_MAX_SHIFT
Definition iax2.h:46
IAX_IE_FORMAT
#define IAX_IE_FORMAT
Definition iax2.h:139
IAX_IE_ENCRYPTION
#define IAX_IE_ENCRYPTION
Definition iax2.h:173
IAX_ENCRYPT_AES128
#define IAX_ENCRYPT_AES128
Definition iax2.h:201
IAX_AUTH_MD5
#define IAX_AUTH_MD5
Definition iax2.h:198
IAX_MAX_OSPBUFF_SIZE
#define IAX_MAX_OSPBUFF_SIZE
Definition iax2.h:195
IAX_IE_FIRMWAREVER
#define IAX_IE_FIRMWAREVER
Definition iax2.h:164
IAX_FLAG_RETRANS
#define IAX_FLAG_RETRANS
Definition iax2.h:42
IAX_IE_CODEC_PREFS
#define IAX_IE_CODEC_PREFS
Definition iax2.h:175
IAX_IE_CALLED_NUMBER
#define IAX_IE_CALLED_NUMBER
Definition iax2.h:131
IAX_IE_CAPABILITY
#define IAX_IE_CAPABILITY
Definition iax2.h:138
IAX_DPSTATUS_MATCHMORE
#define IAX_DPSTATUS_MATCHMORE
Definition iax2.h:221
IAX_IE_PROVISIONING
#define IAX_IE_PROVISIONING
Definition iax2.h:159
IAX_IE_MD5_RESULT
#define IAX_IE_MD5_RESULT
Definition iax2.h:146
IAX_PROTO_VERSION
#define IAX_PROTO_VERSION
Definition iax2.h:27
IAX_IE_AUTOANSWER
#define IAX_IE_AUTOANSWER
Definition iax2.h:155
IAX_IE_VERSION
#define IAX_IE_VERSION
Definition iax2.h:141
IAX_ENCRYPT_KEYROTATE
#define IAX_ENCRYPT_KEYROTATE
Definition iax2.h:202
IAX_IE_RR_OOO
#define IAX_IE_RR_OOO
Definition iax2.h:182
IAX_IE_CALLNO
#define IAX_IE_CALLNO
Definition iax2.h:151
IAX_IE_APPARENT_ADDR
#define IAX_IE_APPARENT_ADDR
Definition iax2.h:148
IAX_AUTH_PLAINTEXT
#define IAX_AUTH_PLAINTEXT
Definition iax2.h:197
IAX_IE_REFRESH
#define IAX_IE_REFRESH
Definition iax2.h:149
IAX_MAX_OSPBLOCK_NUM
#define IAX_MAX_OSPBLOCK_NUM
Definition iax2.h:193
IAX_META_TRUNK
#define IAX_META_TRUNK
Definition iax2.h:204
IAX_META_TRUNK_MINI
#define IAX_META_TRUNK_MINI
Definition iax2.h:208
IAX_IE_CALLINGPRES
#define IAX_IE_CALLINGPRES
Definition iax2.h:168
IAX_IE_CAUSECODE
#define IAX_IE_CAUSECODE
Definition iax2.h:172
IAX_IE_AUTHMETHODS
#define IAX_IE_AUTHMETHODS
Definition iax2.h:144
IAX_IE_RR_LOSS
#define IAX_IE_RR_LOSS
Definition iax2.h:178
IAX_MAX_CALLS
#define IAX_MAX_CALLS
Definition iax2.h:37
IAX_IE_CALLED_CONTEXT
#define IAX_IE_CALLED_CONTEXT
Definition iax2.h:135
IAX_IE_CALLINGTON
#define IAX_IE_CALLINGTON
Definition iax2.h:169
IAX_DPSTATUS_EXISTS
#define IAX_DPSTATUS_EXISTS
Definition iax2.h:217
IAX_IE_USERNAME
#define IAX_IE_USERNAME
Definition iax2.h:136
IAX_IE_CHALLENGE
#define IAX_IE_CHALLENGE
Definition iax2.h:145
IAX_IE_RR_DELAY
#define IAX_IE_RR_DELAY
Definition iax2.h:180
ast_app_inboxcount
int ast_app_inboxcount(const char *mailboxes, int *newmsgs, int *oldmsgs)
Determine number of new/old messages in a mailbox.
Definition main/app.c:604
ast_config_load
#define ast_config_load(filename, flags)
Load a config file.
Definition include/asterisk/config.h:185
CONFIG_FLAG_FILEUNCHANGED
@ CONFIG_FLAG_FILEUNCHANGED
Definition include/asterisk/config.h:43
ast_category_browse
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
Definition extconf.c:3324
ast_realtime_require_field
int ast_realtime_require_field(const char *family,...) attribute_sentinel
Inform realtime what fields that may be stored.
Definition main/config.c:3816
ast_variable_new
#define ast_variable_new(name, value, filename)
Definition include/asterisk/config.h:921
ast_unload_realtime
int ast_unload_realtime(const char *family)
Release any resources cached for a realtime family.
Definition main/config.c:3843
CONFIG_STATUS_FILEUNCHANGED
#define CONFIG_STATUS_FILEUNCHANGED
Definition include/asterisk/config.h:59
CONFIG_STATUS_FILEINVALID
#define CONFIG_STATUS_FILEINVALID
Definition include/asterisk/config.h:60
ast_parse_arg
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
Definition main/config.c:4094
ast_config_destroy
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition extconf.c:1287
ast_variable_list_replace
int ast_variable_list_replace(struct ast_variable **head, struct ast_variable *replacement)
Replace a variable in the given list with a new value.
Definition main/config.c:754
ast_variable_retrieve
const char * ast_variable_retrieve(struct ast_config *config, const char *category, const char *variable)
Definition main/config.c:870
ast_update_realtime
int ast_update_realtime(const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel
Update realtime configuration.
Definition main/config.c:3926
ast_load_realtime
struct ast_variable * ast_load_realtime(const char *family,...) attribute_sentinel
Definition main/config.c:3773
ast_variables_destroy
void ast_variables_destroy(struct ast_variable *var)
Free variable list.
Definition extconf.c:1260
ast_variable_browse
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
Definition extconf.c:1213
ast_format_compatibility_format2bitfield
uint64_t ast_format_compatibility_format2bitfield(const struct ast_format *format)
Convert a format structure to its respective bitfield.
Definition main/format_compatibility.c:39
ast_format_compatibility_bitfield2format
struct ast_format * ast_format_compatibility_bitfield2format(uint64_t bitfield)
Convert a bitfield to its respective format structure.
Definition main/format_compatibility.c:169
ast_frame_byteswap_be
#define ast_frame_byteswap_be(fr)
Definition include/asterisk/frame.h:603
AST_FRAME_DTMF
#define AST_FRAME_DTMF
Definition include/asterisk/frame.h:139
AST_OPTION_RELAXDTMF
#define AST_OPTION_RELAXDTMF
Definition include/asterisk/frame.h:443
AST_FRFLAG_HAS_TIMING_INFO
@ AST_FRFLAG_HAS_TIMING_INFO
Definition include/asterisk/frame.h:143
AST_OPTION_TONE_VERIFY
#define AST_OPTION_TONE_VERIFY
Definition include/asterisk/frame.h:435
AST_OPTION_RXGAIN
#define AST_OPTION_RXGAIN
Definition include/asterisk/frame.h:457
AST_OPTION_DIGIT_DETECT
#define AST_OPTION_DIGIT_DETECT
Definition include/asterisk/frame.h:507
AST_TRANSFER_SUCCESS
@ AST_TRANSFER_SUCCESS
Definition include/asterisk/frame.h:410
AST_OPTION_OPRMODE
#define AST_OPTION_OPRMODE
Definition include/asterisk/frame.h:463
ast_frfree
#define ast_frfree(fr)
Definition include/asterisk/frame.h:565
AST_OPTION_TDD
#define AST_OPTION_TDD
Definition include/asterisk/frame.h:439
AST_OPTION_SECURE_MEDIA
#define AST_OPTION_SECURE_MEDIA
Definition include/asterisk/frame.h:524
AST_OPTION_FLAG_REQUEST
#define AST_OPTION_FLAG_REQUEST
Definition include/asterisk/frame.h:425
AST_OPTION_FAX_DETECT
#define AST_OPTION_FAX_DETECT
Definition include/asterisk/frame.h:511
AST_OPTION_TXGAIN
#define AST_OPTION_TXGAIN
Definition include/asterisk/frame.h:452
AST_FRIENDLY_OFFSET
#define AST_FRIENDLY_OFFSET
Offset into a frame's data buffer.
Definition include/asterisk/frame.h:229
AST_OPTION_SECURE_SIGNALING
#define AST_OPTION_SECURE_SIGNALING
Definition include/asterisk/frame.h:523
AST_FRAME_DTMF_END
@ AST_FRAME_DTMF_END
Definition include/asterisk/frame.h:99
AST_FRAME_DTMF_BEGIN
@ AST_FRAME_DTMF_BEGIN
Definition include/asterisk/frame.h:125
AST_FRAME_CONTROL
@ AST_FRAME_CONTROL
Definition include/asterisk/frame.h:105
ast_control_frame_type
ast_control_frame_type
Internal control frame subtype field values.
Definition include/asterisk/frame.h:277
AST_CONTROL_SRCUPDATE
@ AST_CONTROL_SRCUPDATE
Definition include/asterisk/frame.h:297
AST_CONTROL_RECORD_CANCEL
@ AST_CONTROL_RECORD_CANCEL
Definition include/asterisk/frame.h:340
AST_CONTROL_PROGRESS
@ AST_CONTROL_PROGRESS
Definition include/asterisk/frame.h:291
AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED
@ AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED
Definition include/asterisk/frame.h:314
AST_CONTROL_OFFHOOK
@ AST_CONTROL_OFFHOOK
Definition include/asterisk/frame.h:284
AST_CONTROL_STREAM_RESTART
@ AST_CONTROL_STREAM_RESTART
Definition include/asterisk/frame.h:335
AST_CONTROL_STREAM_SUSPEND
@ AST_CONTROL_STREAM_SUSPEND
Definition include/asterisk/frame.h:334
AST_CONTROL_RADIO_UNKEY
@ AST_CONTROL_RADIO_UNKEY
Definition include/asterisk/frame.h:290
AST_CONTROL_UNHOLD
@ AST_CONTROL_UNHOLD
Definition include/asterisk/frame.h:294
AST_CONTROL_VIDUPDATE
@ AST_CONTROL_VIDUPDATE
Definition include/asterisk/frame.h:295
AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE
@ AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE
Definition include/asterisk/frame.h:312
AST_CONTROL_STREAM_REVERSE
@ AST_CONTROL_STREAM_REVERSE
Definition include/asterisk/frame.h:336
AST_CONTROL_PROCEEDING
@ AST_CONTROL_PROCEEDING
Definition include/asterisk/frame.h:292
AST_CONTROL_REDIRECTING
@ AST_CONTROL_REDIRECTING
Definition include/asterisk/frame.h:300
AST_CONTROL_TAKEOFFHOOK
@ AST_CONTROL_TAKEOFFHOOK
Definition include/asterisk/frame.h:283
AST_CONTROL_T38_PARAMETERS
@ AST_CONTROL_T38_PARAMETERS
Definition include/asterisk/frame.h:301
AST_CONTROL_READ_ACTION
@ AST_CONTROL_READ_ACTION
Definition include/asterisk/frame.h:304
AST_CONTROL_RECORD_STOP
@ AST_CONTROL_RECORD_STOP
Definition include/asterisk/frame.h:341
AST_CONTROL_CONGESTION
@ AST_CONTROL_CONGESTION
Definition include/asterisk/frame.h:285
AST_CONTROL_PLAYBACK_BEGIN
@ AST_CONTROL_PLAYBACK_BEGIN
Definition include/asterisk/frame.h:338
AST_CONTROL_ANSWER
@ AST_CONTROL_ANSWER
Definition include/asterisk/frame.h:281
AST_CONTROL_RECORD_MUTE
@ AST_CONTROL_RECORD_MUTE
Definition include/asterisk/frame.h:343
AST_CONTROL_RINGING
@ AST_CONTROL_RINGING
Definition include/asterisk/frame.h:280
AST_CONTROL_HANGUP
@ AST_CONTROL_HANGUP
Definition include/asterisk/frame.h:278
AST_CONTROL_STREAM_STOP
@ AST_CONTROL_STREAM_STOP
Definition include/asterisk/frame.h:333
AST_CONTROL_RADIO_KEY
@ AST_CONTROL_RADIO_KEY
Definition include/asterisk/frame.h:289
AST_CONTROL_OPTION
@ AST_CONTROL_OPTION
Definition include/asterisk/frame.h:288
AST_CONTROL_STREAM_TOPOLOGY_CHANGED
@ AST_CONTROL_STREAM_TOPOLOGY_CHANGED
Definition include/asterisk/frame.h:313
AST_CONTROL_CONNECTED_LINE
@ AST_CONTROL_CONNECTED_LINE
Definition include/asterisk/frame.h:299
AST_CONTROL_END_OF_Q
@ AST_CONTROL_END_OF_Q
Definition include/asterisk/frame.h:306
AST_CONTROL_TRANSFER
@ AST_CONTROL_TRANSFER
Definition include/asterisk/frame.h:298
AST_CONTROL_STREAM_FORWARD
@ AST_CONTROL_STREAM_FORWARD
Definition include/asterisk/frame.h:337
AST_CONTROL_FLASH
@ AST_CONTROL_FLASH
Definition include/asterisk/frame.h:286
AST_CONTROL_RECORD_SUSPEND
@ AST_CONTROL_RECORD_SUSPEND
Definition include/asterisk/frame.h:342
AST_CONTROL_SRCCHANGE
@ AST_CONTROL_SRCCHANGE
Definition include/asterisk/frame.h:303
AST_CONTROL_INCOMPLETE
@ AST_CONTROL_INCOMPLETE
Definition include/asterisk/frame.h:307
_XXX_AST_CONTROL_T38
@ _XXX_AST_CONTROL_T38
Definition include/asterisk/frame.h:296
AST_CONTROL_MASQUERADE_NOTIFY
@ AST_CONTROL_MASQUERADE_NOTIFY
Definition include/asterisk/frame.h:311
AST_CONTROL_PVT_CAUSE_CODE
@ AST_CONTROL_PVT_CAUSE_CODE
Definition include/asterisk/frame.h:310
AST_CONTROL_UPDATE_RTP_PEER
@ AST_CONTROL_UPDATE_RTP_PEER
Definition include/asterisk/frame.h:309
AST_OPTION_AUDIO_MODE
#define AST_OPTION_AUDIO_MODE
Definition include/asterisk/frame.h:447
ast_null_frame
struct ast_frame ast_null_frame
Definition main/frame.c:79
ast_callid_strnprint
void ast_callid_strnprint(char *buffer, size_t buffer_size, ast_callid callid)
copy a string representation of the callid into a target string
Definition logger.c:2258
ast_debug
#define ast_debug(level,...)
Log a DEBUG message.
Definition include/asterisk/logger.h:456
ast_read_threadstorage_callid
ast_callid ast_read_threadstorage_callid(void)
extracts the callid from the thread
Definition logger.c:2268
ast_callid_threadassoc_add
int ast_callid_threadassoc_add(ast_callid callid)
Adds a known callid to thread storage of the calling thread.
Definition logger.c:2290
AST_CALLID_BUFFER_LENGTH
#define AST_CALLID_BUFFER_LENGTH
Definition include/asterisk/logger.h:55
ast_create_callid
ast_callid ast_create_callid(void)
factory function to create a new uniquely identifying callid.
Definition logger.c:2263
ast_callid
unsigned int ast_callid
Definition include/asterisk/logger.h:96
VERBOSE_PREFIX_4
#define VERBOSE_PREFIX_4
Definition include/asterisk/logger.h:47
ast_callid_threadassoc_remove
int ast_callid_threadassoc_remove(void)
Removes callid from thread storage of the calling thread.
Definition logger.c:2309
LOG_ERROR
#define LOG_ERROR
Definition include/asterisk/logger.h:291
ast_verb
#define ast_verb(level,...)
Definition include/asterisk/logger.h:467
LOG_NOTICE
#define LOG_NOTICE
Definition include/asterisk/logger.h:269
LOG_WARNING
#define LOG_WARNING
Definition include/asterisk/logger.h:280
ast_verbose
#define ast_verbose(...)
Definition include/asterisk/logger.h:188
AST_IO_IN
#define AST_IO_IN
Definition io.h:34
io_context_create
struct io_context * io_context_create(void)
Creates a context Create a context for I/O operations Basically mallocs an IO structure and sets up s...
Definition io.c:81
ast_io_add
int * ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
Adds an IO context.
Definition io.c:162
AST_IO_PRI
#define AST_IO_PRI
Definition io.h:38
io_context_destroy
void io_context_destroy(struct io_context *ioc)
Destroys a context.
Definition io.c:107
ast_io_wait
int ast_io_wait(struct io_context *ioc, int howlong)
Waits for IO.
Definition io.c:278
jb_destroy
void jb_destroy(jitterbuf *jb)
destroy jitterbuf
Definition jitterbuf.c:99
jb_reset
void jb_reset(jitterbuf *jb)
reset jitterbuf
Definition jitterbuf.c:72
jb_get
enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frame, long now, long interpl)
get a frame for time now (receiver's time) return value is one of JB_OK: You've got frame!...
Definition jitterbuf.c:785
jb_new
jitterbuf * jb_new(void)
new jitterbuf
Definition jitterbuf.c:86
jb_setoutput
void jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg)
Definition jitterbuf.c:55
jb_put
enum jb_return_code jb_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, long ts, long now)
queue a frame
Definition jitterbuf.c:525
jb_next
long jb_next(jitterbuf *jb)
when is the next frame due out, in receiver's time (0=EMPTY) This value may change as frames are adde...
Definition jitterbuf.c:767
JB_TYPE_CONTROL
@ JB_TYPE_CONTROL
Definition jitterbuf.h:61
JB_TYPE_SILENCE
@ JB_TYPE_SILENCE
Definition jitterbuf.h:64
JB_TYPE_VOICE
@ JB_TYPE_VOICE
Definition jitterbuf.h:62
jb_setconf
enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf)
set jitterbuf conf
Definition jitterbuf.c:825
jb_getall
enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout)
unconditionally get frames from jitterbuf until empty
Definition jitterbuf.c:801
JB_EMPTY
@ JB_EMPTY
Definition jitterbuf.h:52
JB_SCHED
@ JB_SCHED
Definition jitterbuf.h:56
JB_DROP
@ JB_DROP
Definition jitterbuf.h:55
JB_NOFRAME
@ JB_NOFRAME
Definition jitterbuf.h:53
JB_INTERP
@ JB_INTERP
Definition jitterbuf.h:54
JB_OK
@ JB_OK
Definition jitterbuf.h:51
jb_getinfo
enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats)
get jitterbuf info: only "statistics" may be valid
Definition jitterbuf.c:815
ast_json_unref
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition json.c:73
ast_json_pack
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition json.c:612
ast_json_int_t
AST_JSON_INT_T ast_json_int_t
Primarily used to cast when packing to an "I" type.
Definition json.h:87
AST_LIST_HEAD_INIT_NOLOCK
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
Definition linkedlists.h:681
AST_LIST_HEAD_STATIC
#define AST_LIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a list of specified type, statically initialized.
Definition linkedlists.h:291
AST_LIST_HEAD_NOLOCK
#define AST_LIST_HEAD_NOLOCK(name, type)
Defines a structure to be used to hold a list of specified type (with no lock).
Definition linkedlists.h:225
AST_LIST_LAST
#define AST_LIST_LAST(head)
Returns the last entry contained in a list.
Definition linkedlists.h:429
AST_LIST_TRAVERSE
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition linkedlists.h:491
AST_LIST_HEAD_DESTROY
#define AST_LIST_HEAD_DESTROY(head)
Destroys a list head structure.
Definition linkedlists.h:653
AST_LIST_INSERT_TAIL
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition linkedlists.h:731
AST_LIST_ENTRY
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition linkedlists.h:410
AST_LIST_HEAD_INIT
#define AST_LIST_HEAD_INIT(head)
Initializes a list head structure.
Definition linkedlists.h:626
AST_LIST_TRAVERSE_SAFE_END
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition linkedlists.h:615
AST_LIST_INSERT_BEFORE_CURRENT
#define AST_LIST_INSERT_BEFORE_CURRENT(elm, field)
Inserts a list entry before the current entry during a traversal.
Definition linkedlists.h:599
AST_LIST_LOCK
#define AST_LIST_LOCK(head)
Locks a list.
Definition linkedlists.h:40
AST_LIST_INSERT_HEAD
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
Definition linkedlists.h:711
AST_LIST_REMOVE
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
Definition linkedlists.h:856
AST_LIST_TRAVERSE_SAFE_BEGIN
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition linkedlists.h:529
AST_LIST_REMOVE_CURRENT
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition linkedlists.h:557
AST_LIST_REMOVE_HEAD
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition linkedlists.h:833
AST_LIST_UNLOCK
#define AST_LIST_UNLOCK(head)
Attempts to unlock a list.
Definition linkedlists.h:140
AST_LIST_HEAD
#define AST_LIST_HEAD(name, type)
Defines a structure to be used to hold a list of specified type.
Definition linkedlists.h:173
ast_localtime
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
Definition localtime.c:1739
ast_cond_destroy
#define ast_cond_destroy(cond)
Definition lock.h:209
ast_cond_wait
#define ast_cond_wait(cond, mutex)
Definition lock.h:212
AST_PTHREADT_NULL
#define AST_PTHREADT_NULL
Definition lock.h:73
ast_cond_init
#define ast_cond_init(cond, attr)
Definition lock.h:208
ast_cond_timedwait
#define ast_cond_timedwait(cond, mutex, time)
Definition lock.h:213
ast_mutex_init
#define ast_mutex_init(pmutex)
Definition lock.h:193
DEADLOCK_AVOIDANCE
#define DEADLOCK_AVOIDANCE(lock)
Definition lock.h:486
ast_mutex_unlock
#define ast_mutex_unlock(a)
Definition lock.h:197
ast_atomic_fetchadd_int
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition lock.h:764
ast_mutex_trylock
#define ast_mutex_trylock(a)
Definition lock.h:198
ast_cond_t
pthread_cond_t ast_cond_t
Definition lock.h:185
ast_mutex_destroy
#define ast_mutex_destroy(a)
Definition lock.h:195
ast_mutex_lock
#define ast_mutex_lock(a)
Definition lock.h:196
AST_MUTEX_DEFINE_STATIC
#define AST_MUTEX_DEFINE_STATIC(mutex)
Definition lock.h:527
ast_atomic_dec_and_test
int ast_atomic_dec_and_test(volatile int *p)
decrement *p by 1 and return true if the variable has reached 0.
Definition lock.h:774
ast_cond_signal
#define ast_cond_signal(cond)
Definition lock.h:210
hostname
static char hostname[MAXHOSTNAMELEN]
Definition logger.c:116
errno
int errno
EVENT_FLAG_REPORTING
#define EVENT_FLAG_REPORTING
Definition manager.h:84
EVENT_FLAG_SYSTEM
#define EVENT_FLAG_SYSTEM
Definition manager.h:75
ast_manager_register_xml
#define ast_manager_register_xml(action, authority, func)
Register a manager callback using XML documentation to describe the manager.
Definition manager.h:193
MD5Update
void MD5Update(struct MD5Context *context, unsigned char const *buf, unsigned len)
Definition md5.c:72
MD5Init
void MD5Init(struct MD5Context *context)
Definition md5.c:57
MD5Final
void MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], struct MD5Context *context)
Definition md5.c:120
AST_MODFLAG_LOAD_ORDER
@ AST_MODFLAG_LOAD_ORDER
Definition module.h:331
ast_module_unref
#define ast_module_unref(mod)
Release a reference to the module.
Definition module.h:483
ast_module_ref
#define ast_module_ref(mod)
Hold a reference to the module.
Definition module.h:457
AST_MODULE_INFO
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
Definition module.h:557
AST_MODPRI_CHANNEL_DRIVER
@ AST_MODPRI_CHANNEL_DRIVER
Definition module.h:341
AST_MODULE_SUPPORT_CORE
@ AST_MODULE_SUPPORT_CORE
Definition module.h:121
ASTERISK_GPL_KEY
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition module.h:46
ast_unregister_application
int ast_unregister_application(const char *app)
Unregister an application.
Definition pbx_app.c:404
AST_MODULE_LOAD_SUCCESS
@ AST_MODULE_LOAD_SUCCESS
Definition module.h:70
AST_MODULE_LOAD_DECLINE
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition module.h:78
ast_register_application_xml
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
Definition module.h:640
ast_moh_start
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition channel.c:7802
ast_moh_stop
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition channel.c:7812
ast_mwi_state_type
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
ast_mwi_unsubscribe
void * ast_mwi_unsubscribe(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic and MWI.
Definition mwi.c:254
ast_mwi_state_cache
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
Definition mwi.c:94
ast_mwi_subscribe_pool
struct ast_mwi_subscriber * ast_mwi_subscribe_pool(const char *mailbox, stasis_subscription_cb callback, void *data)
Add an MWI state subscriber, and stasis subscription to the mailbox.
Definition mwi.c:235
env.meta
meta
below block is needed for mssql
Definition env.py:22
ast_sockaddr_stringify
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
Definition netsock2.h:256
ast_sockaddr_port
#define ast_sockaddr_port(addr)
Get the port number of a socket address.
Definition netsock2.h:517
ast_sockaddr_copy
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
Definition netsock2.h:167
ast_sockaddr_is_ipv6
int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr)
Determine if this is an IPv6 address.
Definition netsock2.c:524
ast_bind
int ast_bind(int sockfd, const struct ast_sockaddr *addr)
Wrapper around bind(2) that uses struct ast_sockaddr.
Definition netsock2.c:590
ast_sockaddr_apply_netmask
int ast_sockaddr_apply_netmask(const struct ast_sockaddr *addr, const struct ast_sockaddr *netmask, struct ast_sockaddr *result)
Apply a netmask to an address and store the result in a separate structure.
Definition netsock2.c:357
ast_sockaddr_cmp_addr
int ast_sockaddr_cmp_addr(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares the addresses of two ast_sockaddr structures.
Definition netsock2.c:413
ast_sendto
ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags, const struct ast_sockaddr *dest_addr)
Wrapper around sendto(2) that uses ast_sockaddr.
Definition netsock2.c:614
ast_sockaddr_split_hostport
int ast_sockaddr_split_hostport(char *str, char **host, char **port, int flags)
Splits a string into its host and port components.
Definition netsock2.c:164
ast_sockaddr_resolve
int ast_sockaddr_resolve(struct ast_sockaddr **addrs, const char *str, int flags, int family)
Parses a string with an IPv4 or IPv6 address and place results into an array.
Definition netsock2.c:280
ast_sockaddr_parse
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
Definition netsock2.c:230
ast_sockaddr_isnull
static int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
Checks if the ast_sockaddr is null. "null" in this sense essentially means uninitialized,...
Definition netsock2.h:127
AST_AF_UNSPEC
@ AST_AF_UNSPEC
Definition netsock2.h:54
ast_recvfrom
ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags, struct ast_sockaddr *src_addr)
Wrapper around recvfrom(2) that uses struct ast_sockaddr.
Definition netsock2.c:606
ast_sockaddr_cmp
int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares two ast_sockaddr structures.
Definition netsock2.c:388
ast_sockaddr_stringify_port
static char * ast_sockaddr_stringify_port(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return a port only.
Definition netsock2.h:358
ast_sockaddr_set_port
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
Definition netsock2.h:532
ast_sockaddr_stringify_addr
static char * ast_sockaddr_stringify_addr(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return an address only.
Definition netsock2.h:286
ast_sockaddr_setnull
static void ast_sockaddr_setnull(struct ast_sockaddr *addr)
Sets address addr to null.
Definition netsock2.h:138
ast_sockaddr_is_ipv4_mapped
int ast_sockaddr_is_ipv4_mapped(const struct ast_sockaddr *addr)
Determine if this is an IPv4-mapped IPv6 address.
Definition netsock2.c:507
ast_sockaddr_hash
int ast_sockaddr_hash(const struct ast_sockaddr *addr)
Computes a hash value from the address. The port is ignored.
Definition netsock2.c:548
ast_netsock_release
int ast_netsock_release(struct ast_netsock_list *list)
Definition netsock.c:85
ast_netsock_list_alloc
struct ast_netsock_list * ast_netsock_list_alloc(void)
Definition netsock.c:72
ast_netsock_bind
struct ast_netsock * ast_netsock_bind(struct ast_netsock_list *list, struct io_context *ioc, const char *bindinfo, int defaultport, int tos, int cos, ast_io_cb callback, void *data)
Definition netsock.c:167
ast_netsock_unref
void ast_netsock_unref(struct ast_netsock *ns)
Definition netsock.c:198
ast_netsock_sockfd
int ast_netsock_sockfd(const struct ast_netsock *ns)
Definition netsock.c:183
ast_netsock_find
struct ast_netsock * ast_netsock_find(struct ast_netsock_list *list, struct ast_sockaddr *addr)
Definition netsock.c:94
ast_netsock_init
int ast_netsock_init(struct ast_netsock_list *list)
Definition netsock.c:77
ast_netsock_bindaddr
struct ast_netsock * ast_netsock_bindaddr(struct ast_netsock_list *list, struct io_context *ioc, struct ast_sockaddr *bindaddr, int tos, int cos, ast_io_cb callback, void *data)
Definition netsock.c:109
ast_inet_ntoa
const char * ast_inet_ntoa(struct in_addr ia)
thread-safe replacement for inet_ntoa().
Definition utils.c:962
iax_parse_ies
int iax_parse_ies(struct iax_ies *ies, unsigned char *data, int datalen)
Definition parser.c:795
iax_get_iframes
int iax_get_iframes(void)
Definition parser.c:1354
DIRECTION_OUTGRESS
#define DIRECTION_OUTGRESS
Definition parser.h:89
iax_ie_append_addr
int iax_ie_append_addr(struct iax_ie_data *ied, unsigned char ie, const struct ast_sockaddr *addr)
Definition parser.c:741
iax_frame_subclass2str
void iax_frame_subclass2str(enum iax_frame_subclass subclass, char *str, size_t len)
Definition parser.c:463
iax_ie_append_byte
int iax_ie_append_byte(struct iax_ie_data *ied, unsigned char ie, unsigned char dat)
Definition parser.c:775
iax_frame_free
void iax_frame_free(struct iax_frame *fr)
Definition parser.c:1299
iax_ie_append
int iax_ie_append(struct iax_ie_data *ied, unsigned char ie)
Definition parser.c:780
iax_ie_append_versioned_uint64
int iax_ie_append_versioned_uint64(struct iax_ie_data *ied, unsigned char ie, unsigned char version, uint64_t value)
Definition parser.c:746
iax_frame_new
struct iax_frame * iax_frame_new(int direction, int datalen, unsigned int cacheable)
Definition parser.c:1230
iax_ie_append_raw
int iax_ie_append_raw(struct iax_ie_data *ied, unsigned char ie, const void *data, int datalen)
Definition parser.c:726
iax_ie_append_int
int iax_ie_append_int(struct iax_ie_data *ied, unsigned char ie, unsigned int value)
Definition parser.c:756
iax_set_output
void iax_set_output(void(*output)(const char *data))
iax_get_oframes
int iax_get_oframes(void)
Definition parser.c:1355
DIRECTION_INGRESS
#define DIRECTION_INGRESS
Definition parser.h:88
iax_frame_wrap
void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f)
Definition parser.c:1196
iax_ie_append_short
int iax_ie_append_short(struct iax_ie_data *ied, unsigned char ie, unsigned short value)
Definition parser.c:763
iax_showframe
void iax_showframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct ast_sockaddr *addr, int datalen)
Definition parser.c:595
iax_ie_append_str
int iax_ie_append_str(struct iax_ie_data *ied, unsigned char ie, const char *str)
Definition parser.c:770
iax_get_frames
int iax_get_frames(void)
Definition parser.c:1353
iax_set_error
void iax_set_error(void(*output)(const char *data))
ast_config_AST_SYSTEM_NAME
const char * ast_config_AST_SYSTEM_NAME
Definition options.c:171
totalcalls
static int totalcalls
Definition pbx.c:423
ast_add_extension
int ast_add_extension(const char *context, int replace, const char *extension, int priority, const char *label, const char *callerid, const char *application, void *data, void(*datad)(void *), const char *registrar)
Add and extension to an extension context.
Definition pbx.c:5206
ast_context_destroy_by_name
int ast_context_destroy_by_name(const char *context, const char *registrar)
Destroy a context by name.
Definition pbx.c:6491
ast_unregister_switch
void ast_unregister_switch(struct ast_switch *sw)
Unregister an alternative switch.
Definition pbx_switch.c:76
ast_register_switch
int ast_register_switch(struct ast_switch *sw)
Register an alternative dialplan switch.
Definition pbx_switch.c:58
pbx_builtin_getvar_helper
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
Definition pbx_variables.c:1162
ast_exists_extension
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
Definition pbx.c:2735
ast_context_find_or_create
struct ast_context * ast_context_find_or_create(struct ast_context **extcontexts, struct ast_hashtab *exttable, const char *name, const char *registrar)
Register a new context or find an existing one.
Definition pbx.c:4542
pbx_exec
int pbx_exec(struct ast_channel *c, struct ast_app *app, const char *data)
Execute an application.
Definition pbx_app.c:483
pbx_builtin_setvar_helper
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
Definition pbx_variables.c:1233
ast_context_remove_extension
int ast_context_remove_extension(const char *context, const char *extension, int priority, const char *registrar)
Simply remove extension from context.
Definition pbx.c:3508
ast_custom_function_register
#define ast_custom_function_register(acf)
Register a custom function.
Definition pbx.h:1563
ast_canmatch_extension
int ast_canmatch_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks for a valid matching extension.
Definition pbx.c:2750
ast_custom_function_unregister
int ast_custom_function_unregister(struct ast_custom_function *acf)
Unregister a custom function.
Definition pbx_functions.c:268
ast_pbx_start
enum ast_pbx_result ast_pbx_start(struct ast_channel *c)
Create a new thread and start the PBX.
Definition pbx.c:3268
ast_ignore_pattern
int ast_ignore_pattern(const char *context, const char *pattern)
Checks to see if a number should be ignored.
Definition pbx.c:5177
ast_matchmore_extension
int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
Definition pbx.c:2755
pbx_findapp
struct ast_app * pbx_findapp(const char *app)
Look up an application.
Definition ael_main.c:165
netsocket
static int netsocket
Definition pbx_dundi.c:195
matchmore
static int matchmore(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
Definition pbx_lua.c:1386
ast_poll
#define ast_poll(a, b, c)
Definition poll-compat.h:88
iax_provision_reload
int iax_provision_reload(int reload)
Definition provision.c:526
iax_provision_build
int iax_provision_build(struct iax_ie_data *provdata, unsigned int *signature, const char *template, int force)
Definition provision.c:209
iax_provision_unload
int iax_provision_unload(void)
Definition provision.c:517
iax_prov_complete_template
char * iax_prov_complete_template(const char *line, const char *word, int pos, int state)
Definition provision.c:179
iax_provision_version
int iax_provision_version(unsigned int *signature, const char *template, int force)
Definition provision.c:258
total
static int total
Definition res_adsi.c:970
sub
static struct stasis_subscription * sub
Statsd channel stats. Exmaple of how to subscribe to Stasis events.
Definition res_chan_stats.c:44
methods
static struct @486 methods[]
challenge
static void challenge(const char *endpoint_id, struct ast_sip_auth *auth, pjsip_tx_data *tdata, const pjsip_rx_data *rdata, int is_stale, const pjsip_auth_algorithm *algorithm)
Send a WWW-Authenticate challenge.
Definition res_pjsip_authenticator_digest.c:532
cleanup
static void cleanup(void)
Clean up any old apps that we don't need any more.
Definition res_stasis.c:327
args
static struct @522 args
refresh
unsigned int refresh
Definition res_stun_monitor.c:64
NULL
#define NULL
Definition resample.c:96
AST_SCHED_DEL
#define AST_SCHED_DEL(sched, id)
Remove a scheduler entry.
Definition sched.h:46
ast_sched_clean_by_callback
void ast_sched_clean_by_callback(struct ast_sched_context *con, ast_sched_cb match, ast_sched_cb cleanup_cb)
Clean all scheduled events with matching callback.
Definition sched.c:409
ast_sched_replace
int ast_sched_replace(int old_id, struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
replace a scheduler entry
Definition sched.c:559
ast_sched_add
int ast_sched_add(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
Adds a scheduled event.
Definition sched.c:567
ast_sched_context_destroy
void ast_sched_context_destroy(struct ast_sched_context *c)
destroys a schedule context
Definition sched.c:271
ast_sched_start_thread
int ast_sched_start_thread(struct ast_sched_context *con)
Start a thread for processing scheduler entries.
Definition sched.c:197
ast_sched_cb
int(* ast_sched_cb)(const void *data)
scheduler callback
Definition sched.h:178
ast_sched_context_create
struct ast_sched_context * ast_sched_context_create(void)
Create a scheduler context.
Definition sched.c:238
ast_security_topic
struct stasis_topic * ast_security_topic(void)
A stasis_topic which publishes messages for security related issues.
Definition main/security_events.c:425
STASIS_SUBSCRIPTION_FILTER_SELECTIVE
@ STASIS_SUBSCRIPTION_FILTER_SELECTIVE
Definition stasis.h:297
stasis_subscription_accept_message_type
int stasis_subscription_accept_message_type(struct stasis_subscription *subscription, const struct stasis_message_type *type)
Indicate to a subscription that we are interested in a message type.
Definition stasis.c:1101
stasis_subscription_set_filter
int stasis_subscription_set_filter(struct stasis_subscription *subscription, enum stasis_subscription_message_filter filter)
Set the message type filtering level on a subscription.
Definition stasis.c:1155
stasis_subscription_cb_noop
void stasis_subscription_cb_noop(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Stasis subscription callback function that does nothing.
Definition stasis.c:876
stasis_message_data
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
Definition stasis_message.c:195
stasis_unsubscribe_and_join
struct stasis_subscription * stasis_unsubscribe_and_join(struct stasis_subscription *subscription)
Cancel a subscription, blocking until the last message is processed.
Definition stasis.c:1212
stasis_cache_get
struct stasis_message * stasis_cache_get(struct stasis_cache *cache, struct stasis_message_type *type, const char *id)
Retrieve an item from the cache for the ast_eid_default entity.
Definition stasis_cache.c:686
stasis_subscribe
#define stasis_subscribe(topic, callback, data)
Definition stasis.h:649
ast_system_publish_registry
void ast_system_publish_registry(const char *channeltype, const char *username, const char *domain, const char *status, const char *cause)
Publish a channel driver outgoing registration message.
Definition stasis_system.c:121
ast_system_topic
struct stasis_topic * ast_system_topic(void)
A Stasis Message Bus API topic which publishes messages regarding system changes.
Definition stasis_system.c:350
ast_network_change_type
struct stasis_message_type * ast_network_change_type(void)
A stasis_message_type for network changes.
AST_DECLARE_STRING_FIELDS
#define AST_DECLARE_STRING_FIELDS(field_list)
Declare the fields needed in a structure.
Definition stringfields.h:341
AST_STRING_FIELD
#define AST_STRING_FIELD(name)
Declare a string field.
Definition stringfields.h:303
ast_string_field_set
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition stringfields.h:521
ast_string_field_init
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition stringfields.h:359
ast_string_field_build
#define ast_string_field_build(x, field, fmt, args...)
Set a field to a complex (built) value.
Definition stringfields.h:555
ast_string_field_free_memory
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition stringfields.h:374
ast_str_append
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition strings.h:1139
ast_str_strlen
size_t attribute_pure ast_str_strlen(const struct ast_str *buf)
Returns the current length of the string stored within buf.
Definition strings.h:730
S_OR
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition strings.h:80
ast_str_hash
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition strings.h:1259
ast_true
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition utils.c:2233
S_COR
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition strings.h:87
ast_get_time_t
int ast_get_time_t(const char *src, time_t *dst, time_t _default, int *consumed)
Parse a time (integer) string.
Definition utils.c:2480
ast_strlen_zero
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition strings.h:65
ast_false
int attribute_pure ast_false(const char *val)
Make sure something is false. Determine if a string containing a boolean value is "false"....
Definition utils.c:2250
ast_str_alloca
#define ast_str_alloca(init_len)
Definition strings.h:848
ast_strip_quoted
char * ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
Strip leading/trailing whitespace and quotes from a string.
Definition utils.c:1852
ast_str_set
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition strings.h:1113
ast_str_buffer
char *attribute_pure ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition strings.h:761
ast_copy_string
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition strings.h:425
active_list
Definition chan_iax2.c:1190
addr_range
Definition chan_iax2.c:1078
addr_range::ha
struct ast_ha ha
Definition chan_iax2.c:1080
addr_range::delme
unsigned char delme
Definition chan_iax2.c:1084
addr_range::limit
uint16_t limit
Definition chan_iax2.c:1082
aes_key
Definition crypto.h:39
aes_key::raw
unsigned char raw[AST_CRYPTO_AES_BLOCKSIZE/8]
Definition crypto.h:40
ao2_container
Generic container type.
Definition astobj2_container_private.h:270
ao2_iterator
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition astobj2.h:1821
ao2_iterator::flags
int flags
Definition astobj2.h:1829
ast_acl_list
Wrapper for an ast_acl linked list.
Definition acl.h:76
ast_app
ast_app: A registered application
Definition pbx_app.c:45
ast_assigned_ids
Structure to pass both assignedid values to channel drivers.
Definition channel.h:606
ast_channel_tech
Structure to describe a channel "technology", ie a channel driver See for examples:
Definition channel.h:648
ast_channel_tech::capabilities
struct ast_format_cap * capabilities
Definition channel.h:652
ast_channel_tech::type
const char *const type
Definition channel.h:649
ast_channel
Main Channel structure associated with a channel.
Definition channel_private.h:48
ast_channel::data
const char * data
Definition channel_private.h:58
ast_channel::context
char context[AST_MAX_CONTEXT]
Definition channel_private.h:183
ast_cli_args
Definition cli.h:158
ast_cli_entry
descriptor for a cli entry.
Definition cli.h:171
ast_cli_entry::args
int args
This gets set in ast_cli_register()
Definition cli.h:185
ast_cli_entry::command
char * command
Definition cli.h:186
ast_cli_entry::usage
const char * usage
Definition cli.h:177
ast_config
Definition main/config.c:251
ast_control_pvt_cause_code
Definition include/asterisk/frame.h:417
ast_control_pvt_cause_code::ast_cause
int ast_cause
Definition include/asterisk/frame.h:420
ast_control_pvt_cause_code::chan_name
char chan_name[AST_CHANNEL_NAME]
Definition include/asterisk/frame.h:418
ast_control_pvt_cause_code::code
char code[1]
Definition include/asterisk/frame.h:421
ast_custom_function
Data structure associated with a custom dialplan function.
Definition pbx.h:118
ast_custom_function::name
const char * name
Definition pbx.h:119
ast_datastore_info
Structure for a data store type.
Definition datastore.h:31
ast_datastore_info::type
const char * type
Definition datastore.h:32
ast_datastore
Structure for a data store object.
Definition datastore.h:64
ast_datastore::data
void * data
Definition datastore.h:66
ast_datastore::inheritance
unsigned int inheritance
Definition datastore.h:69
ast_dnsmgr_entry
Definition dnsmgr.c:66
ast_endpoint
Definition main/endpoints.c:53
ast_flags64
Structure used to handle a large number of boolean flags == used only in app_dial?
Definition utils.h:225
ast_flags
Structure used to handle boolean flags.
Definition utils.h:220
ast_format_cap
Format capabilities structure, holds formats + preference order + etc.
Definition format_cap.c:54
ast_format
Definition of a media format.
Definition format.c:43
ast_frame_subclass::frame_ending
unsigned int frame_ending
Definition include/asterisk/frame.h:160
ast_frame_subclass::format
struct ast_format * format
Definition include/asterisk/frame.h:155
ast_frame_subclass::integer
int integer
Definition include/asterisk/frame.h:152
ast_frame
Data structure associated with a single frame of data.
Definition include/asterisk/frame.h:165
ast_frame::ts
long ts
Definition include/asterisk/frame.h:191
ast_frame::subclass
struct ast_frame_subclass subclass
Definition include/asterisk/frame.h:169
ast_frame::samples
int samples
Definition include/asterisk/frame.h:173
ast_frame::delivery
struct timeval delivery
Definition include/asterisk/frame.h:185
ast_frame::frametype
enum ast_frame_type frametype
Definition include/asterisk/frame.h:167
ast_frame::data
union ast_frame::@237 data
ast_frame::len
long len
Definition include/asterisk/frame.h:193
ast_frame::next
struct ast_frame * next
Definition include/asterisk/frame.h:187
ast_frame::seqno
int seqno
Definition include/asterisk/frame.h:195
ast_frame::datalen
int datalen
Definition include/asterisk/frame.h:171
ast_frame::ptr
void * ptr
Definition include/asterisk/frame.h:183
ast_frame::mallocd
int mallocd
Definition include/asterisk/frame.h:175
ast_frame::offset
int offset
Definition include/asterisk/frame.h:179
ast_frame::src
const char * src
Definition include/asterisk/frame.h:181
ast_ha
internal representation of ACL entries In principle user applications would have no need for this,...
Definition acl.h:51
ast_ha::addr
struct ast_sockaddr addr
Definition acl.h:53
ast_ha::netmask
struct ast_sockaddr netmask
Definition acl.h:54
ast_iax2_firmware_header
Definition iax2.h:295
ast_iax2_full_enc_hdr
Definition iax2.h:242
ast_iax2_full_enc_hdr::encdata
unsigned char encdata[0]
Definition iax2.h:245
ast_iax2_full_hdr
Definition iax2.h:230
ast_iax2_full_hdr::dcallno
unsigned short dcallno
Definition iax2.h:232
ast_iax2_full_hdr::scallno
unsigned short scallno
Definition iax2.h:231
ast_iax2_full_hdr::ts
unsigned int ts
Definition iax2.h:233
ast_iax2_full_hdr::iseqno
unsigned char iseqno
Definition iax2.h:235
ast_iax2_full_hdr::csub
unsigned char csub
Definition iax2.h:237
ast_iax2_full_hdr::oseqno
unsigned char oseqno
Definition iax2.h:234
ast_iax2_full_hdr::type
unsigned char type
Definition iax2.h:236
ast_iax2_meta_hdr
Definition iax2.h:263
ast_iax2_meta_trunk_entry
Definition iax2.h:282
ast_iax2_meta_trunk_entry::callno
unsigned short callno
Definition iax2.h:283
ast_iax2_meta_trunk_entry::len
unsigned short len
Definition iax2.h:284
ast_iax2_meta_trunk_hdr
Definition iax2.h:277
ast_iax2_meta_trunk_hdr::ts
unsigned int ts
Definition iax2.h:278
ast_iax2_meta_trunk_hdr::data
unsigned char data[0]
Definition iax2.h:279
ast_iax2_meta_trunk_mini
Definition iax2.h:288
ast_iax2_meta_trunk_mini::len
unsigned short len
Definition iax2.h:289
ast_iax2_meta_trunk_mini::mini
struct ast_iax2_mini_hdr mini
Definition iax2.h:290
ast_iax2_mini_enc_hdr
Definition iax2.h:258
ast_iax2_mini_enc_hdr::callno
unsigned short callno
Definition iax2.h:259
ast_iax2_mini_enc_hdr::encdata
unsigned char encdata[0]
Definition iax2.h:260
ast_iax2_mini_hdr
Definition iax2.h:249
ast_iax2_mini_hdr::callno
unsigned short callno
Definition iax2.h:250
ast_iax2_mini_hdr::ts
unsigned short ts
Definition iax2.h:251
ast_iax2_video_hdr
Definition iax2.h:270
ast_iax2_video_hdr::zeros
unsigned short zeros
Definition iax2.h:271
ast_iax2_video_hdr::callno
unsigned short callno
Definition iax2.h:272
ast_iax2_video_hdr::ts
unsigned short ts
Definition iax2.h:273
ast_json
Abstract JSON element (object, array, string, int, ...).
ast_key
Definition res_crypto.c:80
ast_module_info
Definition module.h:350
ast_module_info::self
struct ast_module * self
Definition module.h:356
ast_mutex_info
Structure for mutex and tracking information.
Definition lock.h:142
ast_mwi_state
The structure that contains MWI state.
Definition mwi.h:455
ast_mwi_state::old_msgs
int old_msgs
Definition mwi.h:460
ast_mwi_state::new_msgs
int new_msgs
Definition mwi.h:459
ast_mwi_subscriber
Definition mwi.c:224
ast_netsock
Definition netsock.c:51
ast_netsock::sockfd
int sockfd
Definition netsock.c:54
ast_option_header
Definition include/asterisk/frame.h:531
ast_option_header::option
uint16_t option
Definition include/asterisk/frame.h:535
ast_option_header::data
uint8_t data[0]
Definition include/asterisk/frame.h:544
ast_option_header::flag
uint16_t flag
Definition include/asterisk/frame.h:534
ast_party_caller::id
struct ast_party_id id
Caller party ID.
Definition channel.h:422
ast_party_caller::ani2
int ani2
Automatic Number Identification 2 (Info Digits)
Definition channel.h:435
ast_party_caller::ani
struct ast_party_id ani
Automatic Number Identification (ANI)
Definition channel.h:429
ast_party_connected_line
Connected Line/Party information.
Definition channel.h:458
ast_party_connected_line::id
struct ast_party_id id
Connected party ID.
Definition channel.h:460
ast_party_dialed::number
struct ast_party_dialed::@218 number
Dialed/Called number.
ast_party_dialed::str
char * str
Subscriber phone number (Malloced)
Definition channel.h:388
ast_party_dialed::transit_network_select
int transit_network_select
Transit Network Select.
Definition channel.h:399
ast_party_id::name
struct ast_party_name name
Subscriber name.
Definition channel.h:342
ast_party_id::number
struct ast_party_number number
Subscriber phone number.
Definition channel.h:344
ast_party_name::presentation
int presentation
Q.931 encoded presentation-indicator encoded field.
Definition channel.h:279
ast_party_name::valid
unsigned char valid
TRUE if the name information is valid/present.
Definition channel.h:281
ast_party_name::str
char * str
Subscriber name (Malloced)
Definition channel.h:266
ast_party_number::presentation
int presentation
Q.931 presentation-indicator and screening-indicator encoded fields.
Definition channel.h:297
ast_party_number::valid
unsigned char valid
TRUE if the number information is valid/present.
Definition channel.h:299
ast_party_number::str
char * str
Subscriber phone number (Malloced)
Definition channel.h:293
ast_party_number::plan
int plan
Q.931 Type-Of-Number and Numbering-Plan encoded fields.
Definition channel.h:295
ast_party_redirecting::from
struct ast_party_id from
Who is redirecting the call (Sent to the party the call is redirected toward)
Definition channel.h:529
ast_sched_context
Definition sched.c:111
ast_sockaddr
Socket address structure.
Definition netsock2.h:97
ast_sockaddr::ss
struct sockaddr_storage ss
Definition netsock2.h:98
ast_str
Support for dynamic strings.
Definition strings.h:623
ast_switch
Definition pbx.h:162
ast_switch::name
const char * name
Definition pbx.h:164
ast_taskprocessor
A ast_taskprocessor structure is a singleton by name.
Definition taskprocessor.c:83
ast_tm
Definition localtime.h:35
ast_var_t
Definition chanvars.h:28
ast_var_t::entries
struct ast_var_t::@221 entries
ast_variable
Structure for variables, used for configurations and for channel variables.
Definition include/asterisk/config.h:83
ast_variable::lineno
int lineno
Definition include/asterisk/config.h:95
ast_variable::value
const char * value
Definition include/asterisk/config.h:87
ast_variable::name
const char * name
Definition include/asterisk/config.h:85
ast_variable::file
const char * file
Definition include/asterisk/config.h:93
ast_variable::next
struct ast_variable * next
Definition include/asterisk/config.h:90
call_number_pool
Definition chan_iax2.c:995
call_number_pool::available
size_t available
Definition chan_iax2.c:997
call_number_pool::numbers
callno_entry numbers[IAX_MAX_CALLS/2+1]
Definition chan_iax2.c:998
call_number_pool::capacity
size_t capacity
Definition chan_iax2.c:996
chan_iax2_pvt
Definition chan_iax2.c:779
chan_iax2_pvt::semirand
unsigned char semirand[32]
Definition chan_iax2.c:918
chan_iax2_pvt::frames_dropped
int frames_dropped
Definition chan_iax2.c:965
chan_iax2_pvt::mohinterpret
const ast_string_field mohinterpret
Definition chan_iax2.c:899
chan_iax2_pvt::first_iax_message
int first_iax_message
Definition chan_iax2.c:803
chan_iax2_pvt::peeradsicpe
int peeradsicpe
Definition chan_iax2.c:939
chan_iax2_pvt::addr
struct ast_sockaddr addr
Definition chan_iax2.c:813
chan_iax2_pvt::error
int error
Definition chan_iax2.c:844
chan_iax2_pvt::vars
struct ast_variable * vars
Definition chan_iax2.c:957
chan_iax2_pvt::language
const ast_string_field language
Definition chan_iax2.c:899
chan_iax2_pvt::frames_received
int frames_received
Definition chan_iax2.c:967
chan_iax2_pvt::calling_ani2
int calling_ani2
Definition chan_iax2.c:953
chan_iax2_pvt::cid_num
const ast_string_field cid_num
Definition chan_iax2.c:899
chan_iax2_pvt::signaling_queue
struct chan_iax2_pvt::signaling_queue signaling_queue
chan_iax2_pvt::svideoformat
iax2_format svideoformat
Definition chan_iax2.c:791
chan_iax2_pvt::lastsent
unsigned int lastsent
Definition chan_iax2.c:797
chan_iax2_pvt::authfail
int authfail
Definition chan_iax2.c:948
chan_iax2_pvt::inkeys
const ast_string_field inkeys
Definition chan_iax2.c:899
chan_iax2_pvt::keyrotateid
int keyrotateid
Definition chan_iax2.c:916
chan_iax2_pvt::outkey
const ast_string_field outkey
Definition chan_iax2.c:899
chan_iax2_pvt::nextpred
unsigned int nextpred
Definition chan_iax2.c:801
chan_iax2_pvt::capability
iax2_format capability
Definition chan_iax2.c:793
chan_iax2_pvt::min
int min
Definition chan_iax2.c:963
chan_iax2_pvt::destroy_initiated
int destroy_initiated
Definition chan_iax2.c:969
chan_iax2_pvt::pingtime
unsigned int pingtime
Definition chan_iax2.c:809
chan_iax2_pvt::authmethods
int authmethods
Definition chan_iax2.c:903
chan_iax2_pvt::dproot
const ast_string_field dproot
Definition chan_iax2.c:899
chan_iax2_pvt::mohsuggest
const ast_string_field mohsuggest
Definition chan_iax2.c:899
chan_iax2_pvt::maxtime
int maxtime
Definition chan_iax2.c:811
chan_iax2_pvt::bridgecallno
unsigned short bridgecallno
Definition chan_iax2.c:942
chan_iax2_pvt::accountcode
const ast_string_field accountcode
Definition chan_iax2.c:899
chan_iax2_pvt::calling_ton
int calling_ton
Definition chan_iax2.c:950
chan_iax2_pvt::username
const ast_string_field username
Definition chan_iax2.c:899
chan_iax2_pvt::peercapability
iax2_format peercapability
Definition chan_iax2.c:832
chan_iax2_pvt::iaxvars
struct ast_variable * iaxvars
Definition chan_iax2.c:959
chan_iax2_pvt::autoid
int autoid
Definition chan_iax2.c:946
chan_iax2_pvt::state
struct ast_flags state
Definition chan_iax2.c:848
chan_iax2_pvt::notsilenttx
unsigned int notsilenttx
Definition chan_iax2.c:807
chan_iax2_pvt::adsi
int adsi
Definition chan_iax2.c:925
chan_iax2_pvt::lastvsent
unsigned int lastvsent
Definition chan_iax2.c:799
chan_iax2_pvt::callid
ast_callid callid
Definition chan_iax2.c:783
chan_iax2_pvt::iseqno
unsigned char iseqno
Definition chan_iax2.c:856
chan_iax2_pvt::hold_signaling
char hold_signaling
Definition chan_iax2.c:973
chan_iax2_pvt::rxcore
struct timeval rxcore
Definition chan_iax2.c:836
chan_iax2_pvt::transfer
struct ast_sockaddr transfer
Definition chan_iax2.c:932
chan_iax2_pvt::jbid
int jbid
Definition chan_iax2.c:840
chan_iax2_pvt::pingid
int pingid
Definition chan_iax2.c:944
chan_iax2_pvt::calling_tns
int calling_tns
Definition chan_iax2.c:951
chan_iax2_pvt::voiceformat
iax2_format voiceformat
Definition chan_iax2.c:785
chan_iax2_pvt::context
const ast_string_field context
Definition chan_iax2.c:899
chan_iax2_pvt::peercallno
unsigned short peercallno
Definition chan_iax2.c:823
chan_iax2_pvt::prefs
struct iax2_codec_pref prefs
Definition chan_iax2.c:815
chan_iax2_pvt::callno
unsigned short callno
Definition chan_iax2.c:819
chan_iax2_pvt::calltoken_ie_len
unsigned char calltoken_ie_len
Definition chan_iax2.c:971
chan_iax2_pvt::parkinglot
const ast_string_field parkinglot
Definition chan_iax2.c:899
chan_iax2_pvt::videoformat
iax2_format videoformat
Definition chan_iax2.c:787
chan_iax2_pvt::rseqno
unsigned char rseqno
Definition chan_iax2.c:854
chan_iax2_pvt::host
const ast_string_field host
Definition chan_iax2.c:899
chan_iax2_pvt::callno_entry
callno_entry callno_entry
Definition chan_iax2.c:821
chan_iax2_pvt::flags
uint64_t flags
Definition chan_iax2.c:924
chan_iax2_pvt::authrej
int authrej
Definition chan_iax2.c:901
chan_iax2_pvt::transfercallno
unsigned short transfercallno
Definition chan_iax2.c:934
chan_iax2_pvt::owner
struct ast_channel * owner
Definition chan_iax2.c:846
chan_iax2_pvt::authid
int authid
Definition chan_iax2.c:947
chan_iax2_pvt::encmethods
int encmethods
Definition chan_iax2.c:907
chan_iax2_pvt::rdnis
const ast_string_field rdnis
Definition chan_iax2.c:899
chan_iax2_pvt::oseqno
unsigned char oseqno
Definition chan_iax2.c:852
chan_iax2_pvt::offset
struct timeval offset
Definition chan_iax2.c:834
chan_iax2_pvt::aseqno
unsigned char aseqno
Definition chan_iax2.c:858
chan_iax2_pvt::svoiceformat
iax2_format svoiceformat
Definition chan_iax2.c:789
chan_iax2_pvt::calling_pres
int calling_pres
Definition chan_iax2.c:952
chan_iax2_pvt::challenge
const ast_string_field challenge
Definition chan_iax2.c:899
chan_iax2_pvt::lagid
int lagid
Definition chan_iax2.c:945
chan_iax2_pvt::exten
const ast_string_field exten
Definition chan_iax2.c:899
chan_iax2_pvt::dcx
ast_aes_decrypt_key dcx
Definition chan_iax2.c:913
chan_iax2_pvt::remote_rr
struct iax_rr remote_rr
Definition chan_iax2.c:961
chan_iax2_pvt::last
unsigned int last
Definition chan_iax2.c:795
chan_iax2_pvt::tdcx
ast_aes_encrypt_key tdcx
Definition chan_iax2.c:936
chan_iax2_pvt::ani
const ast_string_field ani
Definition chan_iax2.c:899
chan_iax2_pvt::peerformat
iax2_format peerformat
Definition chan_iax2.c:830
chan_iax2_pvt::rprefs
struct iax2_codec_pref rprefs
Definition chan_iax2.c:817
chan_iax2_pvt::jb
jitterbuf * jb
Definition chan_iax2.c:838
chan_iax2_pvt::reg
struct iax2_registry * reg
Definition chan_iax2.c:920
chan_iax2_pvt::mydcx
ast_aes_decrypt_key mydcx
Definition chan_iax2.c:911
chan_iax2_pvt::expiry
int expiry
Definition chan_iax2.c:850
chan_iax2_pvt::cid_name
const ast_string_field cid_name
Definition chan_iax2.c:899
chan_iax2_pvt::transferring
enum iax_transfer_state transferring
Definition chan_iax2.c:928
chan_iax2_pvt::last_iax_message
int last_iax_message
Definition chan_iax2.c:805
chan_iax2_pvt::sockfd
int sockfd
Definition chan_iax2.c:781
chan_iax2_pvt::amaflags
int amaflags
Definition chan_iax2.c:954
chan_iax2_pvt::eff_auth_method
int eff_auth_method
Definition chan_iax2.c:905
chan_iax2_pvt::lag
int lag
Definition chan_iax2.c:842
chan_iax2_pvt::secret
const ast_string_field secret
Definition chan_iax2.c:899
chan_iax2_pvt::ecx
ast_aes_encrypt_key ecx
Definition chan_iax2.c:909
chan_iax2_pvt::dnid
const ast_string_field dnid
Definition chan_iax2.c:899
chan_iax2_pvt::osptoken
const ast_string_field osptoken
Definition chan_iax2.c:899
chan_iax2_pvt::peerpoke
struct iax2_peer * peerpoke
Definition chan_iax2.c:922
chan_iax2_pvt::peer
const ast_string_field peer
Definition chan_iax2.c:899
chan_iax2_pvt::transferid
int transferid
Definition chan_iax2.c:930
chan_iax2_pvt::chosenformat
iax2_format chosenformat
Definition chan_iax2.c:828
chan_iax2_pvt::dpentries
struct chan_iax2_pvt::@124 dpentries
chan_iax2_pvt::initid
int initid
Definition chan_iax2.c:949
create_addr_info
Definition chan_iax2.c:4697
create_addr_info::outkey
char outkey[80]
Definition chan_iax2.c:4709
create_addr_info::capability
iax2_format capability
Definition chan_iax2.c:4698
create_addr_info::authmethods
int authmethods
Definition chan_iax2.c:4703
create_addr_info::maxtime
int maxtime
Definition chan_iax2.c:4701
create_addr_info::username
char username[80]
Definition chan_iax2.c:4707
create_addr_info::adsi
int adsi
Definition chan_iax2.c:4706
create_addr_info::cid_num
char cid_num[80]
Definition chan_iax2.c:4711
create_addr_info::prefs
struct iax2_codec_pref prefs
Definition chan_iax2.c:4700
create_addr_info::flags
uint64_t flags
Definition chan_iax2.c:4699
create_addr_info::encmethods
int encmethods
Definition chan_iax2.c:4702
create_addr_info::timezone
char timezone[80]
Definition chan_iax2.c:4710
create_addr_info::secret
char secret[80]
Definition chan_iax2.c:4708
create_addr_info::cid_name
char cid_name[80]
Definition chan_iax2.c:4712
create_addr_info::context
char context[AST_MAX_CONTEXT]
Definition chan_iax2.c:4713
create_addr_info::found
int found
Definition chan_iax2.c:4704
create_addr_info::peercontext
char peercontext[AST_MAX_CONTEXT]
Definition chan_iax2.c:4714
create_addr_info::sockfd
int sockfd
Definition chan_iax2.c:4705
create_addr_info::mohsuggest
char mohsuggest[MAX_MUSICCLASS]
Definition chan_iax2.c:4716
create_addr_info::mohinterpret
char mohinterpret[MAX_MUSICCLASS]
Definition chan_iax2.c:4715
dpreq_data
Definition chan_iax2.c:9726
dpreq_data::callno
int callno
Definition chan_iax2.c:9727
dpreq_data::context
char context[AST_MAX_EXTENSION]
Definition chan_iax2.c:9728
dpreq_data::callednum
char callednum[AST_MAX_EXTENSION]
Definition chan_iax2.c:9729
dpreq_data::callerid
char * callerid
Definition chan_iax2.c:9730
dynamic_list
Definition chan_iax2.c:1191
formats
Definition file.c:70
iax2_codec_pref
Definition codec_pref.h:34
iax2_codec_pref::order
char order[IAX2_CODEC_PREF_SIZE]
Definition codec_pref.h:36
iax2_context
Definition chan_iax2.c:529
iax2_context::context
char context[AST_MAX_CONTEXT]
Definition chan_iax2.c:530
iax2_context::next
struct iax2_context * next
Definition chan_iax2.c:531
iax2_dpcache
Definition chan_iax2.c:1106
iax2_dpcache::waiters
int waiters[256]
Definition chan_iax2.c:1113
iax2_dpcache::peer_list
struct iax2_dpcache::@127 peer_list
iax2_dpcache::expiry
struct timeval expiry
Definition chan_iax2.c:1110
iax2_dpcache::exten
char exten[AST_MAX_EXTENSION]
Definition chan_iax2.c:1108
iax2_dpcache::callno
unsigned short callno
Definition chan_iax2.c:1112
iax2_dpcache::orig
struct timeval orig
Definition chan_iax2.c:1109
iax2_dpcache::cache_list
struct iax2_dpcache::@126 cache_list
iax2_dpcache::flags
int flags
Definition chan_iax2.c:1111
iax2_dpcache::peercontext
char peercontext[AST_MAX_CONTEXT]
Definition chan_iax2.c:1107
iax2_peer
Definition chan_iax2.c:615
iax2_peer::peercontext
const ast_string_field peercontext
Definition chan_iax2.c:636
iax2_peer::mohinterpret
const ast_string_field mohinterpret
Definition chan_iax2.c:636
iax2_peer::pokefreqok
int pokefreqok
Definition chan_iax2.c:661
iax2_peer::addr
struct ast_sockaddr addr
Definition chan_iax2.c:639
iax2_peer::callno
int callno
Definition chan_iax2.c:656
iax2_peer::dnsmgr
struct ast_dnsmgr_entry * dnsmgr
Definition chan_iax2.c:638
iax2_peer::cid_num
const ast_string_field cid_num
Definition chan_iax2.c:636
iax2_peer::inkeys
const ast_string_field inkeys
Definition chan_iax2.c:636
iax2_peer::outkey
const ast_string_field outkey
Definition chan_iax2.c:636
iax2_peer::mwi_event_sub
struct ast_mwi_subscriber * mwi_event_sub
Definition chan_iax2.c:667
iax2_peer::expire
int expire
Definition chan_iax2.c:651
iax2_peer::calltoken_required
enum calltoken_peer_enum calltoken_required
Definition chan_iax2.c:670
iax2_peer::capability
iax2_format capability
Definition chan_iax2.c:653
iax2_peer::pokefreqnotok
int pokefreqnotok
Definition chan_iax2.c:662
iax2_peer::historicms
int historicms
Definition chan_iax2.c:663
iax2_peer::authmethods
int authmethods
Definition chan_iax2.c:648
iax2_peer::regexten
const ast_string_field regexten
Definition chan_iax2.c:636
iax2_peer::mohsuggest
const ast_string_field mohsuggest
Definition chan_iax2.c:636
iax2_peer::username
const ast_string_field username
Definition chan_iax2.c:636
iax2_peer::lastms
int lastms
Definition chan_iax2.c:658
iax2_peer::zonetag
const ast_string_field zonetag
Definition chan_iax2.c:636
iax2_peer::adsi
int adsi
Definition chan_iax2.c:643
iax2_peer::defaddr
struct ast_sockaddr defaddr
Definition chan_iax2.c:647
iax2_peer::maxcallno
uint16_t maxcallno
Definition chan_iax2.c:665
iax2_peer::description
const ast_string_field description
Definition chan_iax2.c:636
iax2_peer::context
const ast_string_field context
Definition chan_iax2.c:636
iax2_peer::prefs
struct iax2_codec_pref prefs
Definition chan_iax2.c:637
iax2_peer::parkinglot
const ast_string_field parkinglot
Definition chan_iax2.c:636
iax2_peer::flags
uint64_t flags
Definition chan_iax2.c:644
iax2_peer::dbsecret
const ast_string_field dbsecret
Definition chan_iax2.c:636
iax2_peer::mask
struct ast_sockaddr mask
Definition chan_iax2.c:642
iax2_peer::encmethods
int encmethods
Definition chan_iax2.c:649
iax2_peer::endpoint
struct ast_endpoint * endpoint
Definition chan_iax2.c:672
iax2_peer::pokeexpire
int pokeexpire
Definition chan_iax2.c:657
iax2_peer::formats
int formats
Definition chan_iax2.c:640
iax2_peer::acl
struct ast_acl_list * acl
Definition chan_iax2.c:669
iax2_peer::expiry
int expiry
Definition chan_iax2.c:652
iax2_peer::name
const ast_string_field name
Definition chan_iax2.c:636
iax2_peer::cid_name
const ast_string_field cid_name
Definition chan_iax2.c:636
iax2_peer::maxms
int maxms
Definition chan_iax2.c:659
iax2_peer::sockfd
int sockfd
Definition chan_iax2.c:641
iax2_peer::smoothing
int smoothing
Definition chan_iax2.c:664
iax2_peer::secret
const ast_string_field secret
Definition chan_iax2.c:636
iax2_peer::mailbox
const ast_string_field mailbox
Definition chan_iax2.c:636
iax2_pkt_buf
Definition chan_iax2.c:1140
iax2_pkt_buf::buf
unsigned char buf[1]
Definition chan_iax2.c:1143
iax2_pkt_buf::entry
struct iax2_pkt_buf::@128 entry
iax2_pkt_buf::len
size_t len
Definition chan_iax2.c:1142
iax2_registry
Definition chan_iax2.c:722
iax2_registry::addr
struct ast_sockaddr addr
Definition chan_iax2.c:723
iax2_registry::callno
int callno
Definition chan_iax2.c:730
iax2_registry::refresh
int refresh
Definition chan_iax2.c:727
iax2_registry::dnsmgr
struct ast_dnsmgr_entry * dnsmgr
Definition chan_iax2.c:732
iax2_registry::hostname
char hostname[]
Definition chan_iax2.c:735
iax2_registry::regstate
enum iax_reg_state regstate
Definition chan_iax2.c:728
iax2_registry::expire
int expire
Definition chan_iax2.c:726
iax2_registry::entry
struct iax2_registry::@123 entry
iax2_registry::username
char username[80]
Definition chan_iax2.c:724
iax2_registry::port
int port
Definition chan_iax2.c:734
iax2_registry::messages
int messages
Definition chan_iax2.c:729
iax2_registry::secret
char secret[80]
Definition chan_iax2.c:725
iax2_registry::us
struct ast_sockaddr us
Definition chan_iax2.c:731
iax2_thread
Definition chan_iax2.c:1146
iax2_thread::addr
struct ast_sockaddr addr
Definition chan_iax2.c:1177
iax2_thread::readbuf
unsigned char readbuf[4096]
Definition chan_iax2.c:1161
iax2_thread::cond
ast_cond_t cond
Definition chan_iax2.c:1168
iax2_thread::init_cond
ast_cond_t init_cond
Definition chan_iax2.c:1170
iax2_thread::checktime
time_t checktime
Definition chan_iax2.c:1166
iax2_thread::ffinfo
struct iax2_thread::@130 ffinfo
iax2_thread::iofd
int iofd
Definition chan_iax2.c:1165
iax2_thread::threadnum
int threadnum
Definition chan_iax2.c:1159
iax2_thread::stop
unsigned char stop
Definition chan_iax2.c:1185
iax2_thread::csub
unsigned char csub
Definition chan_iax2.c:1179
iax2_thread::threadid
pthread_t threadid
Definition chan_iax2.c:1158
iax2_thread::callno
unsigned short callno
Definition chan_iax2.c:1176
iax2_thread::actions
int actions
Definition chan_iax2.c:1157
iax2_thread::ioaddr
struct ast_sockaddr ioaddr
Definition chan_iax2.c:1160
iax2_thread::init_lock
ast_mutex_t init_lock
Definition chan_iax2.c:1169
iax2_thread::list
struct iax2_thread::@129 list
iax2_thread::full_frames
struct iax2_thread::@131 full_frames
iax2_thread::buf
unsigned char * buf
Definition chan_iax2.c:1162
iax2_thread::iostate
enum iax2_thread_iostate iostate
Definition chan_iax2.c:1149
iax2_thread::lock
ast_mutex_t lock
Definition chan_iax2.c:1167
iax2_thread::scheddata
const void * scheddata
Definition chan_iax2.c:1152
iax2_thread::buf_size
size_t buf_size
Definition chan_iax2.c:1164
iax2_thread::type
enum iax2_thread_type type
Definition chan_iax2.c:1148
iax2_thread::schedfunc
void(* schedfunc)(const void *)
Definition chan_iax2.c:1151
iax2_thread::curfunc
char curfunc[80]
Definition chan_iax2.c:1155
iax2_thread::buf_len
ssize_t buf_len
Definition chan_iax2.c:1163
iax2_trunk_peer
Definition chan_iax2.c:677
iax2_trunk_peer::addr
struct ast_sockaddr addr
Definition chan_iax2.c:680
iax2_trunk_peer::lasttxtime
struct timeval lasttxtime
Definition chan_iax2.c:683
iax2_trunk_peer::lastsent
unsigned int lastsent
Definition chan_iax2.c:685
iax2_trunk_peer::rxtrunktime
struct timeval rxtrunktime
Definition chan_iax2.c:682
iax2_trunk_peer::list
struct iax2_trunk_peer::@122 list
iax2_trunk_peer::calls
int calls
Definition chan_iax2.c:692
iax2_trunk_peer::trunkmaxmtu
int trunkmaxmtu
Definition chan_iax2.c:690
iax2_trunk_peer::trunkdataalloc
unsigned int trunkdataalloc
Definition chan_iax2.c:689
iax2_trunk_peer::trunkdatalen
unsigned int trunkdatalen
Definition chan_iax2.c:688
iax2_trunk_peer::trunkdata
unsigned char * trunkdata
Definition chan_iax2.c:687
iax2_trunk_peer::trunkact
struct timeval trunkact
Definition chan_iax2.c:684
iax2_trunk_peer::trunkerror
int trunkerror
Definition chan_iax2.c:691
iax2_trunk_peer::sockfd
int sockfd
Definition chan_iax2.c:679
iax2_trunk_peer::lock
ast_mutex_t lock
Definition chan_iax2.c:678
iax2_trunk_peer::txtrunktime
struct timeval txtrunktime
Definition chan_iax2.c:681
iax2_user
Definition chan_iax2.c:585
iax2_user::mohinterpret
const ast_string_field mohinterpret
Definition chan_iax2.c:598
iax2_user::vars
struct ast_variable * vars
Definition chan_iax2.c:611
iax2_user::language
const ast_string_field language
Definition chan_iax2.c:598
iax2_user::cid_num
const ast_string_field cid_num
Definition chan_iax2.c:598
iax2_user::inkeys
const ast_string_field inkeys
Definition chan_iax2.c:598
iax2_user::contexts
struct iax2_context * contexts
Definition chan_iax2.c:610
iax2_user::calltoken_required
enum calltoken_peer_enum calltoken_required
Definition chan_iax2.c:612
iax2_user::capability
iax2_format capability
Definition chan_iax2.c:605
iax2_user::authmethods
int authmethods
Definition chan_iax2.c:600
iax2_user::mohsuggest
const ast_string_field mohsuggest
Definition chan_iax2.c:598
iax2_user::accountcode
const ast_string_field accountcode
Definition chan_iax2.c:598
iax2_user::adsi
int adsi
Definition chan_iax2.c:603
iax2_user::prefs
struct iax2_codec_pref prefs
Definition chan_iax2.c:608
iax2_user::parkinglot
const ast_string_field parkinglot
Definition chan_iax2.c:598
iax2_user::flags
uint64_t flags
Definition chan_iax2.c:604
iax2_user::dbsecret
const ast_string_field dbsecret
Definition chan_iax2.c:598
iax2_user::encmethods
int encmethods
Definition chan_iax2.c:601
iax2_user::maxauthreq
int maxauthreq
Definition chan_iax2.c:606
iax2_user::curauthreq
int curauthreq
Definition chan_iax2.c:607
iax2_user::acl
struct ast_acl_list * acl
Definition chan_iax2.c:609
iax2_user::name
const ast_string_field name
Definition chan_iax2.c:598
iax2_user::cid_name
const ast_string_field cid_name
Definition chan_iax2.c:598
iax2_user::amaflags
int amaflags
Definition chan_iax2.c:602
iax2_user::secret
const ast_string_field secret
Definition chan_iax2.c:598
iax_frame
Definition parser.h:91
iax_frame::semirand
unsigned char semirand[32]
Definition parser.h:138
iax_frame::dcallno
unsigned short dcallno
Definition parser.h:102
iax_frame::list
struct iax_frame::@144 list
iax_frame::final
unsigned int final
Definition parser.h:120
iax_frame::sentyet
unsigned int sentyet
Definition parser.h:116
iax_frame::retrans
int retrans
Definition parser.h:130
iax_frame::ts
unsigned int ts
Definition parser.h:110
iax_frame::afdata
unsigned char afdata[0]
Definition parser.h:146
iax_frame::outoforder
unsigned int outoforder
Definition parser.h:114
iax_frame::data
void * data
Definition parser.h:104
iax_frame::callno
unsigned short callno
Definition parser.h:100
iax_frame::retries
int retries
Definition parser.h:108
iax_frame::encmethods
int encmethods
Definition parser.h:132
iax_frame::iseqno
int iseqno
Definition parser.h:128
iax_frame::afdatalen
size_t afdatalen
Definition parser.h:144
iax_frame::direction
unsigned int direction
Definition parser.h:122
iax_frame::mydcx
ast_aes_decrypt_key mydcx
Definition parser.h:136
iax_frame::next
struct iax_frame * next
Definition parser.h:140
iax_frame::datalen
int datalen
Definition parser.h:106
iax_frame::retrytime
int retrytime
Definition parser.h:112
iax_frame::transfer
unsigned int transfer
Definition parser.h:118
iax_frame::ecx
ast_aes_encrypt_key ecx
Definition parser.h:134
iax_frame::af
struct ast_frame af
Definition parser.h:142
iax_frame::cacheable
unsigned int cacheable
Definition parser.h:124
iax_frame::oseqno
int oseqno
Definition parser.h:126
iax_ie_data
Definition parser.h:149
iax_ie_data::pos
int pos
Definition parser.h:151
iax_ie_data::buf
unsigned char buf[1024]
Definition parser.h:150
iax_ies
Definition parser.h:27
iax_ies::apparent_addr
struct ast_sockaddr apparent_addr
Definition parser.h:52
iax_ies::adsicpe
unsigned short adsicpe
Definition parser.h:44
iax_ies::rr_jitter
unsigned int rr_jitter
Definition parser.h:75
iax_ies::provver
unsigned int provver
Definition parser.h:72
iax_ies::calltokendata
unsigned char * calltokendata
Definition parser.h:85
iax_ies::rr_pkts
unsigned int rr_pkts
Definition parser.h:77
iax_ies::vars
struct ast_variable * vars
Definition parser.h:81
iax_ies::calltoken
unsigned char calltoken
Definition parser.h:84
iax_ies::iax_unknown
unsigned char iax_unknown
Definition parser.h:58
iax_ies::calling_ani2
int calling_ani2
Definition parser.h:35
iax_ies::rr_loss
unsigned int rr_loss
Definition parser.h:76
iax_ies::authmethods
unsigned int authmethods
Definition parser.h:47
iax_ies::challenge
char * challenge
Definition parser.h:49
iax_ies::dnid
char * dnid
Definition parser.h:45
iax_ies::calling_name
char * calling_name
Definition parser.h:31
iax_ies::capability
iax2_format capability
Definition parser.h:39
iax_ies::called_context
char * called_context
Definition parser.h:36
iax_ies::calling_number
char * calling_number
Definition parser.h:29
iax_ies::fwdesc
unsigned int fwdesc
Definition parser.h:67
iax_ies::calling_ani
char * calling_ani
Definition parser.h:30
iax_ies::calling_ton
int calling_ton
Definition parser.h:32
iax_ies::password
char * password
Definition parser.h:38
iax_ies::transferid
unsigned int transferid
Definition parser.h:62
iax_ies::rr_dropped
unsigned int rr_dropped
Definition parser.h:79
iax_ies::causecode
unsigned char causecode
Definition parser.h:57
iax_ies::ospblocklength
unsigned int ospblocklength[IAX_MAX_OSPBLOCK_NUM]
Definition parser.h:83
iax_ies::msgcount
int msgcount
Definition parser.h:59
iax_ies::calling_tns
int calling_tns
Definition parser.h:33
iax_ies::called_number
char * called_number
Definition parser.h:28
iax_ies::callno
unsigned short callno
Definition parser.h:55
iax_ies::md5_result
char * md5_result
Definition parser.h:50
iax_ies::provverpres
int provverpres
Definition parser.h:74
iax_ies::language
char * language
Definition parser.h:42
iax_ies::codec_prefs
char * codec_prefs
Definition parser.h:41
iax_ies::format
iax2_format format
Definition parser.h:40
iax_ies::encmethods
unsigned int encmethods
Definition parser.h:48
iax_ies::dpstatus
unsigned short dpstatus
Definition parser.h:54
iax_ies::username
char * username
Definition parser.h:37
iax_ies::rsa_result
char * rsa_result
Definition parser.h:51
iax_ies::calling_pres
int calling_pres
Definition parser.h:34
iax_ies::version
int version
Definition parser.h:43
iax_ies::cause
char * cause
Definition parser.h:56
iax_ies::musiconhold
int musiconhold
Definition parser.h:61
iax_ies::refresh
unsigned short refresh
Definition parser.h:53
iax_ies::serviceident
char * serviceident
Definition parser.h:65
iax_ies::rr_ooo
unsigned int rr_ooo
Definition parser.h:80
iax_ies::devicetype
char * devicetype
Definition parser.h:64
iax_ies::rdnis
char * rdnis
Definition parser.h:46
iax_ies::rr_delay
unsigned short rr_delay
Definition parser.h:78
iax_ies::osptokenblock
char * osptokenblock[IAX_MAX_OSPBLOCK_NUM]
Definition parser.h:82
iax_rr
Definition chan_iax2.c:763
iax_rr::ooo
int ooo
Definition chan_iax2.c:770
iax_rr::losscnt
int losscnt
Definition chan_iax2.c:766
iax_rr::delay
int delay
Definition chan_iax2.c:768
iax_rr::losspct
int losspct
Definition chan_iax2.c:765
iax_rr::dropped
int dropped
Definition chan_iax2.c:769
iax_rr::jitter
int jitter
Definition chan_iax2.c:764
iax_rr::packets
int packets
Definition chan_iax2.c:767
idle_list
Definition chan_iax2.c:1189
io_context
Global IO variables are now in a struct in order to be made threadsafe.
Definition io.c:71
jb_conf
Definition jitterbuf.h:67
jb_conf::target_extra
long target_extra
Definition jitterbuf.h:72
jb_conf::max_jitterbuf
long max_jitterbuf
Definition jitterbuf.h:69
jb_conf::resync_threshold
long resync_threshold
Definition jitterbuf.h:70
jb_conf::max_contig_interp
long max_contig_interp
Definition jitterbuf.h:71
jb_frame
Definition jitterbuf.h:101
jb_frame::ms
long ms
Definition jitterbuf.h:104
jb_frame::data
void * data
Definition jitterbuf.h:102
jb_info
Definition jitterbuf.h:75
jb_info::min
long min
Definition jitterbuf.h:87
jb_info::current
long current
Definition jitterbuf.h:88
jb_info::frames_in
long frames_in
Definition jitterbuf.h:79
jb_info::losspct
long losspct
Definition jitterbuf.h:90
jb_info::frames_lost
long frames_lost
Definition jitterbuf.h:82
jb_info::frames_ooo
long frames_ooo
Definition jitterbuf.h:84
jb_info::frames_dropped
long frames_dropped
Definition jitterbuf.h:83
jb_info::jitter
long jitter
Definition jitterbuf.h:86
mansession
In case you didn't read that giant block of text above the mansession_session struct,...
Definition manager.c:323
number
Number structure.
Definition app_followme.c:157
parsed_dial_string
Definition chan_iax2.c:4872
parsed_dial_string::context
char * context
Definition chan_iax2.c:4879
parsed_dial_string::key
char * key
Definition chan_iax2.c:4875
parsed_dial_string::password
char * password
Definition chan_iax2.c:4874
parsed_dial_string::peer
char * peer
Definition chan_iax2.c:4876
parsed_dial_string::username
char * username
Definition chan_iax2.c:4873
parsed_dial_string::exten
char * exten
Definition chan_iax2.c:4878
parsed_dial_string::options
char * options
Definition chan_iax2.c:4880
parsed_dial_string::port
char * port
Definition chan_iax2.c:4877
peercnt::addr
struct ast_sockaddr addr
Definition chan_iax2.c:1067
peercnt::reg
unsigned char reg
Definition chan_iax2.c:1074
peercnt::limit
uint16_t limit
Definition chan_iax2.c:1071
peercnt::cur
uint16_t cur
Definition chan_iax2.c:1069
sched_id
Scheduler ID holder.
Definition sched.c:70
sched
Definition sched.c:76
show_peers_context
Definition chan_iax2.c:6983
show_peers_context::total_peers
int total_peers
Definition chan_iax2.c:6989
show_peers_context::regexbuf
regex_t regexbuf
Definition chan_iax2.c:6984
show_peers_context::online_peers
int online_peers
Definition chan_iax2.c:6990
show_peers_context::havepattern
int havepattern
Definition chan_iax2.c:6985
show_peers_context::peerlist
int peerlist
Definition chan_iax2.c:6988
show_peers_context::unmonitored_peers
int unmonitored_peers
Definition chan_iax2.c:6992
show_peers_context::idtext
char idtext[256]
Definition chan_iax2.c:6986
show_peers_context::offline_peers
int offline_peers
Definition chan_iax2.c:6991
show_peers_context::registeredonly
int registeredonly
Definition chan_iax2.c:6987
signaling_queue_entry
Definition chan_iax2.c:978
signaling_queue_entry::f
struct ast_frame f
Definition chan_iax2.c:979
signaling_queue_entry::next
struct signaling_queue_entry * next
Definition chan_iax2.c:980
stasis_message_type
Definition stasis_message.c:38
stasis_message
Definition stasis_message.c:121
stasis_subscription
Definition stasis.c:747
user
structure to hold users read from phoneprov_users.conf
Definition res_phoneprov.c:318
users
list of users found in the config file
Definition app_voicemail.c:1102
value
int value
Definition syslog.c:37
ast_taskprocessor_get
struct ast_taskprocessor * ast_taskprocessor_get(const char *name, enum ast_tps_options create)
Get a reference to a taskprocessor with the specified name and create the taskprocessor if necessary.
Definition taskprocessor.c:1235
ast_taskprocessor_unreference
void * ast_taskprocessor_unreference(struct ast_taskprocessor *tps)
Unreference the specified taskprocessor and its reference count will decrement.
Definition taskprocessor.c:1300
TPS_REF_DEFAULT
@ TPS_REF_DEFAULT
return a reference to a taskprocessor, create one if it does not exist
Definition taskprocessor.h:76
ast_taskprocessor_push
#define ast_taskprocessor_push(tps, task_exe, datap)
Definition taskprocessor.h:219
done
int done
Definition test_amihooks.c:48
a
static struct test_val a
Definition test_linkedlists.c:46
c
static struct test_val c
Definition test_linkedlists.c:48
ast_samp2tv
struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate)
Returns a timeval corresponding to the duration of n samples at rate r. Useful to convert samples to ...
Definition time.h:282
ast_tvzero
int ast_tvzero(const struct timeval t)
Returns true if the argument is 0,0.
Definition time.h:117
ast_tvcmp
int ast_tvcmp(struct timeval _a, struct timeval _b)
Compress two struct timeval instances returning -1, 0, 1 if the first arg is smaller,...
Definition time.h:137
ast_tvadd
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition extconf.c:2280
ast_tvsub
struct timeval ast_tvsub(struct timeval a, struct timeval b)
Returns the difference of two timevals a - b.
Definition extconf.c:2295
ast_tvdiff_ms
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition time.h:107
ast_tvnow
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition time.h:159
ast_tv
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition time.h:235
ast_timer_close
void ast_timer_close(struct ast_timer *handle)
Close an opened timing handle.
Definition timing.c:154
ast_timer_ack
int ast_timer_ack(const struct ast_timer *handle, unsigned int quantity)
Acknowledge a timer event.
Definition timing.c:171
ast_timer_set_rate
int ast_timer_set_rate(const struct ast_timer *handle, unsigned int rate)
Set the timing tick rate.
Definition timing.c:166
ast_timer_open
struct ast_timer * ast_timer_open(void)
Open a timer.
Definition timing.c:122
ast_timer_fd
int ast_timer_fd(const struct ast_timer *handle)
Get a poll()-able file descriptor for a timer.
Definition timing.c:161
ast_translator_best_choice
int ast_translator_best_choice(struct ast_format_cap *dst_cap, struct ast_format_cap *src_cap, struct ast_format **dst_fmt_out, struct ast_format **src_fmt_out)
Chooses the best translation path.
Definition translate.c:1676
error
int error(const char *format,...)
Definition utils/frame.c:999
ast_test_flag
#define ast_test_flag(p, flag)
Definition utils.h:64
RAII_VAR
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition utils.h:981
ast_set2_flag64
#define ast_set2_flag64(p, value, flag)
Definition utils.h:171
ast_test_flag64
#define ast_test_flag64(p, flag)
Definition utils.h:140
ast_assert
#define ast_assert(a)
Definition utils.h:779
ast_set_flags_to64
#define ast_set_flags_to64(p, flag, value)
Definition utils.h:181
ast_clear_flag64
#define ast_clear_flag64(p, flag)
Definition utils.h:154
MIN
#define MIN(a, b)
Definition utils.h:252
ast_pthread_create_background
#define ast_pthread_create_background(a, b, c, d)
Definition utils.h:632
ast_assert_return
#define ast_assert_return(a,...)
Definition utils.h:780
ast_clear_flag
#define ast_clear_flag(p, flag)
Definition utils.h:78
ast_random
long int ast_random(void)
Definition utils.c:2346
ast_pthread_create_detached
#define ast_pthread_create_detached(a, b, c, d)
Definition utils.h:628
ast_copy_flags64
#define ast_copy_flags64(dest, src, flagz)
Definition utils.h:161
ast_set_flag64
#define ast_set_flag64(p, flag)
Definition utils.h:147
ast_set_flag
#define ast_set_flag(p, flag)
Definition utils.h:71
ARRAY_LEN
#define ARRAY_LEN(a)
Definition utils.h:706
ast_sha1_hash
void ast_sha1_hash(char *output, const char *input)
Produces SHA1 hash based on input string.
Definition utils.c:266

◆ IAX_CAPABILITY_FULLBANDWIDTH

#define IAX_CAPABILITY_FULLBANDWIDTH   0xFFFF

Definition at line 410 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 422 of file chan_iax2.c.

◆ IAX_CAPABILITY_LOWFREE

#define IAX_CAPABILITY_LOWFREE
Value:
(IAX_CAPABILITY_LOWBANDWIDTH & \
~AST_FORMAT_G723)

Definition at line 427 of file chan_iax2.c.

◆ IAX_CAPABILITY_MEDBANDWIDTH

#define IAX_CAPABILITY_MEDBANDWIDTH

Definition at line 412 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 551 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 550 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 549 of file chan_iax2.c.

◆ IAX_DEBUGDIGEST

#define IAX_DEBUGDIGEST (   msg,
  key 
)

Definition at line 480 of file chan_iax2.c.

480 { \
481 int idx; \
482 char digest[33] = ""; \
483 \
484 if (!iaxdebug) \
485 break; \
486 \
487 for (idx = 0; idx < 16; idx++) \
488 sprintf(digest + (idx << 1), "%02hhx", (unsigned char) key[idx]); \
489 \
490 ast_log(LOG_NOTICE, msg " IAX_COMMAND_RTKEY to rotate key to '%s'\n", digest); \
491 } while(0)

◆ 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 559 of file chan_iax2.c.

◆ IAX_DELME

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

Needs to be deleted

Definition at line 536 of file chan_iax2.c.

◆ IAX_DYNAMIC

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

dynamic peer

Definition at line 541 of file chan_iax2.c.

◆ IAX_ENCRYPTED

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

Whether we should assume encrypted tx/rx

Definition at line 547 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 564 of file chan_iax2.c.

◆ IAX_HASCALLERID

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

CallerID has been specified

Definition at line 535 of file chan_iax2.c.

◆ IAX_IMMEDIATE

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

Allow immediate off-hook to extension s

Definition at line 561 of file chan_iax2.c.

◆ IAX_KEYPOPULATED

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

Whether we have a key populated

Definition at line 548 of file chan_iax2.c.

◆ IAX_MAXAUTHREQ

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

Maximum outstanding AUTHREQ restriction is in place

Definition at line 558 of file chan_iax2.c.

◆ IAX_NOTRANSFER

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

Don't native bridge

Definition at line 539 of file chan_iax2.c.

◆ IAX_PROVISION

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

This is a provisioning request

Definition at line 545 of file chan_iax2.c.

◆ IAX_QUELCH

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

Whether or not we quelch audio

Definition at line 546 of file chan_iax2.c.

◆ IAX_RECVCONNECTEDLINE

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

Allow receiving of connected line updates

Definition at line 563 of file chan_iax2.c.

◆ IAX_RTAUTOCLEAR

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

erase me on expire

Definition at line 554 of file chan_iax2.c.

◆ IAX_RTCACHEFRIENDS

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

let realtime stay till your reload

Definition at line 552 of file chan_iax2.c.

◆ IAX_RTIGNOREREGEXPIRE

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

When using realtime, ignore registration expiration

Definition at line 555 of file chan_iax2.c.

◆ IAX_RTSAVE_SYSNAME

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

Save Systname on Realtime Updates

Definition at line 543 of file chan_iax2.c.

◆ IAX_RTUPDATE

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

Send a realtime update

Definition at line 553 of file chan_iax2.c.

◆ IAX_SENDANI

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

Send ANI along with CallerID

Definition at line 542 of file chan_iax2.c.

◆ IAX_SENDCONNECTEDLINE

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

Allow sending of connected line updates

Definition at line 562 of file chan_iax2.c.

◆ IAX_SHRINKCALLERID

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

Turn on and off caller id shrinking

Definition at line 565 of file chan_iax2.c.

◆ IAX_TEMPONLY

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

Temporary (realtime)

Definition at line 537 of file chan_iax2.c.

◆ IAX_TRANSFERMEDIA

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

When doing IAX2 transfers, transfer media only

Definition at line 557 of file chan_iax2.c.

◆ IAX_TRUNK

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

Treat as a trunk

Definition at line 538 of file chan_iax2.c.

◆ IAX_TRUNKTIMESTAMPS

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

Send trunk timestamps

Definition at line 556 of file chan_iax2.c.

◆ IAX_USEJITTERBUF

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

Use jitter buffer

Definition at line 540 of file chan_iax2.c.

◆ MARK_IAX_SUBCLASS_TX

#define MARK_IAX_SUBCLASS_TX   0x8000

Definition at line 755 of file chan_iax2.c.

◆ MAX_JITTER_BUFFER

#define MAX_JITTER_BUFFER   50

Definition at line 744 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 1036 of file chan_iax2.c.

◆ MAX_RETRY_TIME

#define MAX_RETRY_TIME   10000

Definition at line 742 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 749 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 352 of file chan_iax2.c.

◆ MAX_TRUNKDATA

#define MAX_TRUNKDATA   640 * 200

40ms, uncompressed linear * 200 channels

Definition at line 377 of file chan_iax2.c.

◆ MAX_USER_BUCKETS

#define MAX_USER_BUCKETS   MAX_PEER_BUCKETS

Definition at line 1040 of file chan_iax2.c.

◆ MEMORY_SIZE

#define MEMORY_SIZE   100

Definition at line 335 of file chan_iax2.c.

◆ MIN_JITTER_BUFFER

#define MIN_JITTER_BUFFER   10

Definition at line 745 of file chan_iax2.c.

◆ MIN_RETRY_TIME

#define MIN_RETRY_TIME   100

Definition at line 741 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 340 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 6996 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 6995 of file chan_iax2.c.

◆ PTR_TO_CALLNO

#define PTR_TO_CALLNO (   a)    ((unsigned short)(unsigned long)(a))

Definition at line 329 of file chan_iax2.c.

◆ PTR_TO_CALLNO_ENTRY

#define PTR_TO_CALLNO_ENTRY (   a)    ((uint16_t)(unsigned long)(a))

Definition at line 988 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 318 of file chan_iax2.c.

◆ schedule_action

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

Definition at line 1763 of file chan_iax2.c.

◆ TRUNK_CALL_START

#define TRUNK_CALL_START   (IAX_MAX_CALLS / 2)

Definition at line 1260 of file chan_iax2.c.

◆ TS_GAP_FOR_JB_RESYNC

#define TS_GAP_FOR_JB_RESYNC   5000

Definition at line 752 of file chan_iax2.c.

Typedef Documentation

◆ callno_entry

typedef uint16_t callno_entry

Definition at line 777 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 1087 of file chan_iax2.c.

1087 {
1088 /*! Extension exists */
1089 CACHE_FLAG_EXISTS = (1 << 0),
1090 /*! Extension is nonexistent */
1091 CACHE_FLAG_NONEXISTENT = (1 << 1),
1092 /*! Extension can exist */
1093 CACHE_FLAG_CANEXIST = (1 << 2),
1094 /*! Waiting to hear back response */
1095 CACHE_FLAG_PENDING = (1 << 3),
1096 /*! Timed out */
1097 CACHE_FLAG_TIMEOUT = (1 << 4),
1098 /*! Request transmitted */
1099 CACHE_FLAG_TRANSMITTED = (1 << 5),
1100 /*! Timeout */
1101 CACHE_FLAG_UNKNOWN = (1 << 6),
1102 /*! Matchmore */
1103 CACHE_FLAG_MATCHMORE = (1 << 7),
1104};

◆ anonymous enum

anonymous enum
Enumerator
NEW_PREVENT 
NEW_ALLOW 
NEW_FORCE 
NEW_ALLOW_CALLTOKEN_VALIDATED 

Definition at line 2389 of file chan_iax2.c.

2389 {
2390 /* do not allow a new call number, only search ones in use for match */
2391 NEW_PREVENT = 0,
2392 /* search for match first, then allow a new one to be allocated */
2393 NEW_ALLOW = 1,
2394 /* do not search for match, force a new call number */
2395 NEW_FORCE = 2,
2396 /* do not search for match, force a new call number. Signifies call number
2397 * has been calltoken validated */
2398 NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
2399};

◆ callno_type

enum callno_type
Enumerator
CALLNO_TYPE_NORMAL 
CALLNO_TYPE_TRUNK 

Definition at line 983 of file chan_iax2.c.

983 {
984 CALLNO_TYPE_NORMAL,
985 CALLNO_TYPE_TRUNK,
986};

◆ 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 573 of file chan_iax2.c.

573 {
574 /*! \brief Default calltoken required unless the ip is in the ignorelist */
575 CALLTOKEN_DEFAULT = 0,
576 /*! \brief Require call token validation. */
577 CALLTOKEN_YES = 1,
578 /*! \brief Require call token validation after a successful registration
579 * using call token validation occurs. */
580 CALLTOKEN_AUTO = 2,
581 /*! \brief Do not require call token validation. */
582 CALLTOKEN_NO = 3,
583};

◆ iax2_state

enum iax2_state
Enumerator
IAX_STATE_STARTED 
IAX_STATE_AUTHENTICATED 
IAX_STATE_TBD 

Definition at line 523 of file chan_iax2.c.

523 {
524 IAX_STATE_STARTED = (1 << 0),
525 IAX_STATE_AUTHENTICATED = (1 << 1),
526 IAX_STATE_TBD = (1 << 2),
527};

◆ iax2_thread_iostate

enum iax2_thread_iostate
Enumerator
IAX_IOSTATE_IDLE 
IAX_IOSTATE_READY 
IAX_IOSTATE_PROCESSING 
IAX_IOSTATE_SCHEDREADY 

Definition at line 1128 of file chan_iax2.c.

1128 {
1129 IAX_IOSTATE_IDLE,
1130 IAX_IOSTATE_READY,
1131 IAX_IOSTATE_PROCESSING,
1132 IAX_IOSTATE_SCHEDREADY,
1133};

◆ iax2_thread_type

enum iax2_thread_type
Enumerator
IAX_THREAD_TYPE_POOL 
IAX_THREAD_TYPE_DYNAMIC 

Definition at line 1135 of file chan_iax2.c.

1135 {
1136 IAX_THREAD_TYPE_POOL,
1137 IAX_THREAD_TYPE_DYNAMIC,
1138};

◆ 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 698 of file chan_iax2.c.

698 {
699 REG_STATE_UNREGISTERED = 0,
700 REG_STATE_REGSENT,
701 REG_STATE_AUTHSENT,
702 REG_STATE_REGISTERED,
703 REG_STATE_REJECTED,
704 REG_STATE_TIMEOUT,
705 REG_STATE_NOAUTH
706};

◆ 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 708 of file chan_iax2.c.

708 {
709 TRANSFER_NONE = 0,
710 TRANSFER_BEGIN,
711 TRANSFER_READY,
712 TRANSFER_RELEASED,
713 TRANSFER_PASSTHROUGH,
714 TRANSFER_MBEGIN,
715 TRANSFER_MREADY,
716 TRANSFER_MRELEASED,
717 TRANSFER_MPASSTHROUGH,
718 TRANSFER_MEDIA,
719 TRANSFER_MEDIAPASS
720};

Function Documentation

◆ __attempt_transmit()

static void __attempt_transmit ( const void *  data)
static

Definition at line 3634 of file chan_iax2.c.

3635{
3636 /* Attempt to transmit the frame to the remote peer...
3637 Called without iaxsl held. */
3638 struct iax_frame *f = (struct iax_frame *)data;
3639 int freeme = 0;
3640 int callno = f->callno;
3641
3642 /* Make sure this call is still active */
3643 if (callno)
3644 ast_mutex_lock(&iaxsl[callno]);
3645 if (callno && iaxs[callno]) {
3646 if (f->retries < 0) {
3647 /* Already ACK'd */
3648 freeme = 1;
3649 } else if (f->retries >= max_retries) {
3650 /* Too many attempts. Record an error. */
3651 if (f->transfer) {
3652 /* Transfer timeout */
3653 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
3654 } else if (f->final) {
3655 iax2_destroy(callno);
3656 } else {
3657 if (iaxs[callno]->owner) {
3658 ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %u, subclass = %d, ts=%u, seqno=%d)\n",
3659 ast_sockaddr_stringify_addr(&iaxs[f->callno]->addr),
3660 ast_channel_name(iaxs[f->callno]->owner),
3661 f->af.frametype,
3662 f->af.subclass.integer,
3663 f->ts,
3664 f->oseqno);
3665 }
3666 iaxs[callno]->error = ETIMEDOUT;
3667 if (iaxs[callno]->owner) {
3668 struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
3669 /* Hangup the fd */
3670 iax2_queue_frame(callno, &fr); /* XXX */
3671 /* Remember, owner could disappear */
3672 if (iaxs[callno] && iaxs[callno]->owner)
3673 ast_channel_hangupcause_set(iaxs[callno]->owner, AST_CAUSE_DESTINATION_OUT_OF_ORDER);
3674 } else {
3675 if (iaxs[callno]->reg) {
3676 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
3677 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
3678 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
3679 }
3680 iax2_destroy(callno);
3681 }
3682 }
3683 freeme = 1;
3684 } else {
3685 /* Update it if it needs it */
3686 update_packet(f);
3687 /* Attempt transmission */
3688 send_packet(f);
3689 f->retries++;
3690 /* Try again later after 10 times as long */
3691 f->retrytime *= 10;
3692 if (f->retrytime > MAX_RETRY_TIME)
3693 f->retrytime = MAX_RETRY_TIME;
3694 /* Transfer messages max out at one second */
3695 if (f->transfer && (f->retrytime > 1000))
3696 f->retrytime = 1000;
3697 f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
3698 }
3699 } else {
3700 /* Make sure it gets freed */
3701 f->retries = -1;
3702 freeme = 1;
3703 }
3704
3705 if (freeme) {
3706 /* Don't attempt delivery, just remove it from the queue */
3707 AST_LIST_REMOVE(&frame_queue[callno], f, list);
3708 ast_mutex_unlock(&iaxsl[callno]);
3709 f->retrans = -1; /* this is safe because this is the scheduled function */
3710 /* Free the IAX frame */
3711 iax2_frame_free(f);
3712 } else if (callno) {
3713 ast_mutex_unlock(&iaxsl[callno]);
3714 }
3715}
ast_frame::uint32
uint32_t uint32
Definition include/asterisk/frame.h:183

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, ast_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, ast_frame::uint32, update_packet(), and iax2_registry::us.

Referenced by attempt_transmit().

◆ __auth_reject()

static void __auth_reject ( const void *  nothing)
static

Definition at line 9477 of file chan_iax2.c.

9478{
9479 /* Called from IAX thread only, without iaxs lock */
9480 int callno = (int)(long)(nothing);
9481 struct iax_ie_data ied;
9482 ast_mutex_lock(&iaxsl[callno]);
9483 if (iaxs[callno]) {
9484 memset(&ied, 0, sizeof(ied));
9485 if (iaxs[callno]->authfail == IAX_COMMAND_REGREJ) {
9486 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Registration Refused");
9487 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_REJECTED);
9488 } else if (iaxs[callno]->authfail == IAX_COMMAND_REJECT) {
9489 iax_ie_append_str(&ied, IAX_IE_CAUSE, "No authority found");
9490 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
9491 }
9492 send_command_final(iaxs[callno], AST_FRAME_IAX, iaxs[callno]->authfail, 0, ied.buf, ied.pos, -1);
9493 }
9494 ast_mutex_unlock(&iaxsl[callno]);
9495}

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 4835 of file chan_iax2.c.

4836{
4837 int callno = PTR_TO_CALLNO(nothing);
4838 struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_CONGESTION } };
4839 ast_mutex_lock(&iaxsl[callno]);
4840 if (iaxs[callno]) {
4841 iaxs[callno]->initid = -1;
4842 iax2_queue_frame(callno, &f);
4843 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
4844 }
4845 ast_mutex_unlock(&iaxsl[callno]);
4846}

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 9526 of file chan_iax2.c.

9527{
9528 /* Called from IAX thread only, without iaxs lock */
9529 int callno = (int)(long)(nothing);
9530 struct iax_ie_data ied;
9531 ast_mutex_lock(&iaxsl[callno]);
9532 if (iaxs[callno]) {
9533 memset(&ied, 0, sizeof(ied));
9534 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Timeout");
9535 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_NO_USER_RESPONSE);
9536 send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
9537 }
9538 ast_mutex_unlock(&iaxsl[callno]);
9539}

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 3426 of file chan_iax2.c.

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

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 9093 of file chan_iax2.c.

9094{
9095 struct iax2_peer *peer = (struct iax2_peer *) data;
9096 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
9097
9098 if (!peer)
9099 return;
9100 if (peer->expire == -1) {
9101 /* Removed already (possibly through CLI), ignore */
9102 return;
9103 }
9104
9105 peer->expire = -1;
9106
9107 ast_debug(1, "Expiring registration for peer '%s'\n", peer->name);
9108 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(peer, IAX_TEMPONLY|IAX_RTCACHEFRIENDS)))
9109 realtime_update_peer(peer->name, &peer->addr, 0);
9110 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
9111 blob = ast_json_pack("{s: s, s: s}",
9112 "peer_status", "Unregistered",
9113 "cause", "Expired");
9114 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
9115 /* modify entry in peercnts table as _not_ registered */
9116 peercnt_modify((unsigned char) 0, 0, &peer->addr);
9117 /* Reset the address */
9118 ast_sockaddr_setnull(&peer->addr);
9119 /* Reset expiry value */
9120 peer->expiry = min_reg_expire;
9121 if (!ast_test_flag64(peer, IAX_TEMPONLY))
9122 ast_db_del("IAX/Registry", peer->name);
9123 register_peer_exten(peer, 0);
9124 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
9125 if (iax2_regfunk)
9126 iax2_regfunk(peer->name, 0);
9127
9128 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR))
9129 unlink_peer(peer);
9130
9131 peer_unref(peer);
9132}

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 3194 of file chan_iax2.c.

3195{
3196 int res = 0;
3197 int x;
3198 /* this call is calltoken validated as long as it is either NEW_FORCE
3199 * or NEW_ALLOW_CALLTOKEN_VALIDATED */
3200 int validated = (new > NEW_ALLOW) ? 1 : 0;
3201 char host[80];
3202
3203 if (new <= NEW_ALLOW) {
3204 if (callno) {
3205 struct chan_iax2_pvt *pvt;
3206 struct chan_iax2_pvt tmp_pvt = {
3207 .callno = dcallno,
3208 .peercallno = callno,
3209 .transfercallno = callno,
3210 /* hack!! */
3211 .frames_received = check_dcallno,
3212 };
3213
3214 ast_sockaddr_copy(&tmp_pvt.addr, addr);
3215 /* this works for finding normal call numbers not involving transferring */
3216 if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3217 if (return_locked) {
3218 ast_mutex_lock(&iaxsl[pvt->callno]);
3219 }
3220 res = pvt->callno;
3221 ao2_ref(pvt, -1);
3222 pvt = NULL;
3223 return res;
3224 }
3225 /* this searches for transfer call numbers that might not get caught otherwise */
3226 memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
3227 ast_sockaddr_copy(&tmp_pvt.transfer, addr);
3228 if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3229 if (return_locked) {
3230 ast_mutex_lock(&iaxsl[pvt->callno]);
3231 }
3232 res = pvt->callno;
3233 ao2_ref(pvt, -1);
3234 pvt = NULL;
3235 return res;
3236 }
3237 }
3238 /* This will occur on the first response to a message that we initiated,
3239 * such as a PING. */
3240 if (dcallno) {
3241 ast_mutex_lock(&iaxsl[dcallno]);
3242 }
3243 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(addr, callno, dcallno, iaxs[dcallno], check_dcallno)) {
3244 iaxs[dcallno]->peercallno = callno;
3245 res = dcallno;
3246 store_by_peercallno(iaxs[dcallno]);
3247 if (!res || !return_locked) {
3248 ast_mutex_unlock(&iaxsl[dcallno]);
3249 }
3250 return res;
3251 }
3252 if (dcallno) {
3253 ast_mutex_unlock(&iaxsl[dcallno]);
3254 }
3255 }
3256 if (!res && (new >= NEW_ALLOW)) {
3257 callno_entry entry;
3258
3259 /* It may seem odd that we look through the peer list for a name for
3260 * this *incoming* call. Well, it is weird. However, users don't
3261 * have an IP address/port number that we can match against. So,
3262 * this is just checking for a peer that has that IP/port and
3263 * assuming that we have a user of the same name. This isn't always
3264 * correct, but it will be changed if needed after authentication. */
3265 if (!iax2_getpeername(*addr, host, sizeof(host)))
3266 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(addr));
3267
3268 if (peercnt_add(addr)) {
3269 /* This address has hit its callnumber limit. When the limit
3270 * is reached, the connection is not added to the peercnts table.*/
3271 return 0;
3272 }
3273
3274 if (get_unused_callno(CALLNO_TYPE_NORMAL, validated, &entry)) {
3275 /* since we ran out of space, remove the peercnt
3276 * entry we added earlier */
3277 peercnt_remove_by_addr(addr);
3278 ast_log(LOG_WARNING, "No more space\n");
3279 return 0;
3280 }
3281 x = CALLNO_ENTRY_GET_CALLNO(entry);
3282 ast_mutex_lock(&iaxsl[x]);
3283
3284 iaxs[x] = new_iax(addr, host);
3285 if (iaxs[x]) {
3286 if (iaxdebug)
3287 ast_debug(1, "Creating new call structure %d\n", x);
3288 iaxs[x]->callno_entry = entry;
3289 iaxs[x]->sockfd = sockfd;
3290 ast_sockaddr_copy(&iaxs[x]->addr, addr);
3291 iaxs[x]->peercallno = callno;
3292 iaxs[x]->callno = x;
3293 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
3294 iaxs[x]->expiry = min_reg_expire;
3295 iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
3296 iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
3297 iaxs[x]->amaflags = amaflags;
3298 ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
3299 ast_string_field_set(iaxs[x], accountcode, accountcode);
3300 ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
3301 ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
3302 ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
3303
3304 if (iaxs[x]->peercallno) {
3305 store_by_peercallno(iaxs[x]);
3306 }
3307 } else {
3308 ast_log(LOG_WARNING, "Out of resources\n");
3309 ast_mutex_unlock(&iaxsl[x]);
3310 replace_callno(CALLNO_ENTRY_TO_PTR(entry));
3311 return 0;
3312 }
3313 if (!return_locked)
3314 ast_mutex_unlock(&iaxsl[x]);
3315 res = x;
3316 }
3317 return res;
3318}

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 4211 of file chan_iax2.c.

4212{
4213 int callno = PTR_TO_CALLNO(p);
4214 struct chan_iax2_pvt *pvt = NULL;
4215 struct iax_frame *fr;
4216 jb_frame frame;
4217 int ret;
4218 long ms;
4219 long next;
4220 struct timeval now = ast_tvnow();
4221 struct ast_format *voicefmt;
4222
4223 /* Make sure we have a valid private structure before going on */
4224 ast_mutex_lock(&iaxsl[callno]);
4225 pvt = iaxs[callno];
4226 if (!pvt) {
4227 /* No go! */
4228 ast_mutex_unlock(&iaxsl[callno]);
4229 return;
4230 }
4231
4232 pvt->jbid = -1;
4233
4234 /* round up a millisecond since ast_sched_runq does; */
4235 /* prevents us from spinning while waiting for our now */
4236 /* to catch up with runq's now */
4237 now.tv_usec += 1000;
4238
4239 ms = ast_tvdiff_ms(now, pvt->rxcore);
4240 if (ms >= (next = jb_next(pvt->jb))) {
4241 voicefmt = ast_format_compatibility_bitfield2format(pvt->voiceformat);
4242 if (!voicefmt) {
4243 /* pvt->voiceformat won't be set if we haven't received any voice frames yet.
4244 * In this case, fall back to using the format negotiated during call setup,
4245 * so we don't stall the jitterbuffer completely. */
4246 voicefmt = ast_format_compatibility_bitfield2format(pvt->peerformat);
4247 if (!voicefmt) {
4248 /* As a last resort, we can use pvt->chosenformat.
4249 * This is set when we receive a call (either authenticated or unauthenticated),
4250 * so even if we haven't received any voice frames yet, we can still use the
4251 * right format.
4252 *
4253 * If we have to do this, in most cases, we aren't even processing voice frames
4254 * anyways, it's likely a non-voice frame. In that case, the format doesn't
4255 * really matter so much, because we could just pass 20 to jb_get instead
4256 * of calling ast_format_get_default_ms. However, until jb_get returns,
4257 * we don't actually know what kind of frame it is for sure, so use
4258 * the right format just to be safe. */
4259 voicefmt = ast_format_compatibility_bitfield2format(pvt->chosenformat);
4260 }
4261 }
4262 if (!voicefmt) {
4263 /* This should never happen, since we should always be able to have an acceptable format to use. */
4264 ast_log(LOG_ERROR, "No voice, peer, or chosen format available on %s, backlogging frame\n", ast_channel_name(pvt->owner));
4265 goto cleanup; /* Don't crash if there's no voice format */
4266 }
4267 ret = jb_get(pvt->jb, &frame, ms, ast_format_get_default_ms(voicefmt));
4268 switch(ret) {
4269 case JB_OK:
4270 fr = frame.data;
4271 __do_deliver(fr);
4272 /* __do_deliver() can cause the call to disappear */
4273 pvt = iaxs[callno];
4274 break;
4275 case JB_INTERP:
4276 {
4277 struct ast_frame af = { 0, };
4278
4279 /* create an interpolation frame */
4280 af.frametype = AST_FRAME_VOICE;
4281 af.subclass.format = voicefmt;
4282 af.samples = frame.ms * (ast_format_get_sample_rate(voicefmt) / 1000);
4283 af.src = "IAX2 JB interpolation";
4284 af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
4285 af.offset = AST_FRIENDLY_OFFSET;
4286
4287 /* queue the frame: For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
4288 * which we'd need to malloc, and then it would free it. That seems like a drag */
4289 if (!ast_test_flag64(iaxs[callno], IAX_ALREADYGONE)) {
4290 iax2_queue_frame(callno, &af);
4291 /* iax2_queue_frame() could cause the call to disappear */
4292 pvt = iaxs[callno];
4293 }
4294 }
4295 break;
4296 case JB_DROP:
4297 iax2_frame_free(frame.data);
4298 break;
4299 case JB_NOFRAME:
4300 case JB_EMPTY:
4301 /* do nothing */
4302 break;
4303 default:
4304 /* shouldn't happen */
4305 break;
4306 }
4307 }
4308cleanup:
4309 if (pvt)
4310 update_jbsched(pvt);
4311 ast_mutex_unlock(&iaxsl[callno]);
4312}

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 8736 of file chan_iax2.c.

8737{
8738 struct iax2_registry *reg = (struct iax2_registry *)data;
8739
8740 if (ast_sockaddr_isnull(&reg->addr)) {
8741 reg->addr.ss.ss_family = AST_AF_UNSPEC;
8742 ast_dnsmgr_lookup(reg->hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL);
8743 if (!ast_sockaddr_port(&reg->addr)) {
8744 ast_sockaddr_set_port(&reg->addr, reg->port);
8745 } else {
8746 reg->port = ast_sockaddr_port(&reg->addr);
8747 }
8748 }
8749
8750 reg->expire = -1;
8751 iax2_do_register(reg);
8752}

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 12562 of file chan_iax2.c.

12563{
12564 struct iax2_peer *peer = (struct iax2_peer *)data;
12565 int callno;
12566
12567 if (peer->lastms > -1) {
12568 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
12569
12570 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Time: %d\n", peer->name, peer->lastms);
12571 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_OFFLINE);
12572 blob = ast_json_pack("{s: s, s: i}",
12573 "peer_status", "Unreachable",
12574 "time", peer->lastms);
12575 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
12576 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
12577 }
12578 if ((callno = peer->callno) > 0) {
12579 ast_mutex_lock(&iaxsl[callno]);
12580 iax2_destroy(callno);
12581 ast_mutex_unlock(&iaxsl[callno]);
12582 }
12583 peer->callno = 0;
12584 peer->lastms = -1;
12585 /* Try again quickly */
12586 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
12587 if (peer->pokeexpire == -1)
12588 peer_unref(peer);
12589}

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 9586 of file chan_iax2.c.

9587{
9588 struct iax2_peer *peer = (struct iax2_peer *)data;
9589 iax2_poke_peer(peer, 0);
9590 peer_unref(peer);
9591}

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 7099 of file chan_iax2.c.

7100{
7101 struct show_peers_context cont = {
7102 .havepattern = 0,
7103 .idtext = "",
7104 .registeredonly = 0,
7105
7106 .peerlist = 0,
7107
7108 .total_peers = 0,
7109 .online_peers = 0,
7110 .offline_peers = 0,
7111 .unmonitored_peers = 0,
7112 };
7113
7114 struct ao2_iterator i;
7115
7116 struct iax2_peer *peer = NULL;
7117
7118 switch (argc) {
7119 case 6:
7120 if (!strcasecmp(argv[3], "registered"))
7121 cont.registeredonly = 1;
7122 else
7123 return RESULT_SHOWUSAGE;
7124 if (!strcasecmp(argv[4], "like")) {
7125 if (regcomp(&cont.regexbuf, argv[5], REG_EXTENDED | REG_NOSUB))
7126 return RESULT_SHOWUSAGE;
7127 cont.havepattern = 1;
7128 } else
7129 return RESULT_SHOWUSAGE;
7130 break;
7131 case 5:
7132 if (!strcasecmp(argv[3], "like")) {
7133 if (regcomp(&cont.regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
7134 return RESULT_SHOWUSAGE;
7135 cont.havepattern = 1;
7136 } else
7137 return RESULT_SHOWUSAGE;
7138 break;
7139 case 4:
7140 if (!strcasecmp(argv[3], "registered")) {
7141 cont.registeredonly = 1;
7142 } else {
7143 return RESULT_SHOWUSAGE;
7144 }
7145 break;
7146 case 3:
7147 break;
7148 default:
7149 return RESULT_SHOWUSAGE;
7150 }
7151
7152
7153 if (!s) {
7154 ast_cli(fd, PEERS_FORMAT2, "Name/Username", "Host", " ", "Mask", "Port", " ", "Status", "Description");
7155 }
7156
7157 i = ao2_iterator_init(peers, 0);
7158 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
7159
7160 if (cont.registeredonly && ast_sockaddr_isnull(&peer->addr)) {
7161 continue;
7162 }
7163 if (cont.havepattern && regexec(&cont.regexbuf, peer->name, 0, NULL, 0)) {
7164 continue;
7165 }
7166
7167 _iax2_show_peers_one(fd, s, &cont, peer);
7168
7169 }
7170 ao2_iterator_destroy(&i);
7171
7172 if (!s) {
7173 ast_cli(fd,"%d iax2 peers [%d online, %d offline, %d unmonitored]\n",
7174 cont.total_peers, cont.online_peers, cont.offline_peers, cont.unmonitored_peers);
7175 }
7176
7177 if (cont.havepattern) {
7178 regfree(&cont.regexbuf);
7179 }
7180
7181 if (total) {
7182 *total = cont.total_peers;
7183 }
7184
7185 return RESULT_SUCCESS;
7186
7187}

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 15138 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 1738 of file chan_iax2.c.

1739{
1740 struct iax2_thread *thread;
1741 static time_t lasterror;
1742 time_t t;
1743
1744 thread = find_idle_thread();
1745 if (thread != NULL) {
1746 thread->schedfunc = func;
1747 thread->scheddata = data;
1748 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1749#ifdef DEBUG_SCHED_MULTITHREAD
1750 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1751#endif
1752 signal_condition(&thread->lock, &thread->cond);
1753 return 0;
1754 }
1755 time(&t);
1756 if (t != lasterror) {
1757 lasterror = t;
1758 ast_debug(1, "Out of idle IAX2 threads for scheduling! (%s)\n", funcname);
1759 }
1760
1761 return -1;
1762}

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 7865 of file chan_iax2.c.

7867{
7868 struct ast_frame f = { 0, };
7869 int res = 0;
7870
7871 f.frametype = type;
7872 f.subclass.integer = command;
7873 f.datalen = datalen;
7874 f.src = __FUNCTION__;
7875 f.data.ptr = (void *) data;
7876
7877 if ((res = queue_signalling(i, &f)) <= 0) {
7878 return res;
7879 }
7880
7881 return iax2_send(i, &f, ts, seqno, now, transfer, final);
7882}

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 1866 of file chan_iax2.c.

1867{
1868 int callno = PTR_TO_CALLNO(data);
1869
1870 if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1871 ast_debug(3, "Hangup initiated on call %d, aborting __send_lagrq\n", callno);
1872 return;
1873 }
1874
1875 /* Mark lagid as invalid scheduler id. */
1876 iaxs[callno]->lagid = -1;
1877
1878 /* callno is now locked. */
1879 if (iaxs[callno]->peercallno) {
1880 /* Send LAGRQ packet. */
1881 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1882
1883 /* Schedule sending next lagrq. */
1884 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1885 }
1886
1887 ast_mutex_unlock(&iaxsl[callno]);
1888}

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 1802 of file chan_iax2.c.

1803{
1804 int callno = PTR_TO_CALLNO(data);
1805
1806 if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1807 ast_debug(3, "Hangup initiated on call %d, aborting __send_ping\n", callno);
1808 return;
1809 }
1810
1811 /* Mark pingid as invalid scheduler id. */
1812 iaxs[callno]->pingid = -1;
1813
1814 /* callno is now locked. */
1815 if (iaxs[callno]->peercallno) {
1816 /* Send PING packet. */
1817 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1818
1819 /* Schedule sending next ping. */
1820 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1821 }
1822
1823 ast_mutex_unlock(&iaxsl[callno]);
1824}

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 14765 of file chan_iax2.c.

14766{
14767 int x;
14768
14769 network_change_stasis_unsubscribe();
14770 acl_change_stasis_unsubscribe();
14771
14772 ast_manager_unregister("IAXpeers");
14773 ast_manager_unregister("IAXpeerlist");
14774 ast_manager_unregister("IAXnetstats");
14775 ast_manager_unregister("IAXregistry");
14776 ast_unregister_application(papp);
14777 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14778 ast_unregister_switch(&iax2_switch);
14779 ast_channel_unregister(&iax2_tech);
14780
14781 if (netthreadid != AST_PTHREADT_NULL) {
14782 pthread_cancel(netthreadid);
14783 pthread_kill(netthreadid, SIGURG);
14784 pthread_join(netthreadid, NULL);
14785 }
14786
14787 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14788 if (iaxs[x]) {
14789 iax2_destroy(x);
14790 }
14791 }
14792
14793 /* Call for all threads to halt */
14794 cleanup_thread_list(&active_list);
14795 cleanup_thread_list(&dynamic_list);
14796 cleanup_thread_list(&idle_list);
14797
14798 ast_netsock_release(netsock);
14799 ast_netsock_release(outsock);
14800 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14801 if (iaxs[x]) {
14802 iax2_destroy(x);
14803 }
14804 }
14805 ast_manager_unregister( "IAXpeers" );
14806 ast_manager_unregister( "IAXpeerlist" );
14807 ast_manager_unregister( "IAXnetstats" );
14808 ast_manager_unregister( "IAXregistry" );
14809 ast_unregister_application(papp);
14810 ast_cli_unregister_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
14811 ast_unregister_switch(&iax2_switch);
14812 ast_channel_unregister(&iax2_tech);
14813 delete_users();
14814 iax_provision_unload();
14815 iax_firmware_unload();
14816
14817 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
14818 ast_mutex_destroy(&iaxsl[x]);
14819 }
14820
14821 ao2_ref(peers, -1);
14822 ao2_ref(users, -1);
14823 ao2_ref(iax_peercallno_pvts, -1);
14824 ao2_ref(iax_transfercallno_pvts, -1);
14825 ao2_ref(callno_limits, -1);
14826 ao2_ref(calltoken_ignores, -1);
14827 if (timer) {
14828 ast_timer_close(timer);
14829 timer = NULL;
14830 }
14831 transmit_processor = ast_taskprocessor_unreference(transmit_processor);
14832
14833 ast_sched_clean_by_callback(sched, peercnt_remove_cb, peercnt_remove_cb);
14834 ast_sched_context_destroy(sched);
14835 sched = NULL;
14836 ao2_ref(peercnts, -1);
14837
14838 ast_context_destroy_by_name(regcontext, "IAX2");
14839 ast_unload_realtime("iaxpeers");
14840
14841 ao2_ref(iax2_tech.capabilities, -1);
14842 iax2_tech.capabilities = NULL;
14843 return 0;
14844}

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 15138 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 6998 of file chan_iax2.c.

6999{
7000 char name[256] = "";
7001 char status[64];
7002 int retstatus;
7003 struct ast_str *encmethods = ast_str_alloca(256);
7004
7005 char *tmp_host, *tmp_mask, *tmp_port;
7006
7007 tmp_host = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
7008 tmp_mask = ast_strdupa(ast_sockaddr_stringify_addr(&peer->mask));
7009 tmp_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
7010
7011 if (!ast_strlen_zero(peer->username)) {
7012 snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
7013 } else {
7014 ast_copy_string(name, peer->name, sizeof(name));
7015 }
7016
7017 encmethods_to_str(peer->encmethods, &encmethods);
7018 retstatus = peer_status(peer, status, sizeof(status));
7019 if (retstatus > 0) {
7020 cont->online_peers++;
7021 } else if (!retstatus) {
7022 cont->offline_peers++;
7023 } else {
7024 cont->unmonitored_peers++;
7025 }
7026
7027 if (s) {
7028 if (cont->peerlist) { /* IAXpeerlist */
7029 astman_append(s,
7030 "Event: PeerEntry\r\n%s"
7031 "Channeltype: IAX\r\n",
7032 cont->idtext);
7033 if (!ast_strlen_zero(peer->username)) {
7034 astman_append(s,
7035 "ObjectName: %s\r\n"
7036 "ObjectUsername: %s\r\n",
7037 peer->name,
7038 peer->username);
7039 } else {
7040 astman_append(s,
7041 "ObjectName: %s\r\n",
7042 name);
7043 }
7044 } else { /* IAXpeers */
7045 astman_append(s,
7046 "Event: PeerEntry\r\n%s"
7047 "Channeltype: IAX2\r\n"
7048 "ObjectName: %s\r\n",
7049 cont->idtext,
7050 name);
7051 }
7052 astman_append(s,
7053 "ChanObjectType: peer\r\n"
7054 "IPaddress: %s\r\n",
7055 tmp_host);
7056 if (cont->peerlist) { /* IAXpeerlist */
7057 astman_append(s,
7058 "Mask: %s\r\n"
7059 "Port: %s\r\n",
7060 tmp_mask,
7061 tmp_port);
7062 } else { /* IAXpeers */
7063 astman_append(s,
7064 "IPport: %s\r\n",
7065 tmp_port);
7066 }
7067 astman_append(s,
7068 "Dynamic: %s\r\n"
7069 "Trunk: %s\r\n"
7070 "Encryption: %s\r\n"
7071 "Status: %s\r\n",
7072 ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no",
7073 ast_test_flag64(peer, IAX_TRUNK) ? "yes" : "no",
7074 peer->encmethods ? ast_str_buffer(encmethods) : "no",
7075 status);
7076 if (cont->peerlist) { /* IAXpeerlist */
7077 astman_append(s, "\r\n");
7078 } else { /* IAXpeers */
7079 astman_append(s,
7080 "Description: %s\r\n\r\n",
7081 peer->description);
7082 }
7083 } else {
7084 ast_cli(fd, PEERS_FORMAT,
7085 name,
7086 tmp_host,
7087 ast_test_flag64(peer, IAX_DYNAMIC) ? "(D)" : "(S)",
7088 tmp_mask,
7089 tmp_port,
7090 ast_test_flag64(peer, IAX_TRUNK) ? "(T)" : " ",
7091 peer->encmethods ? "(E)" : " ",
7092 status,
7093 peer->description);
7094 }
7095
7096 cont->total_peers++;
7097}

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 14629 of file chan_iax2.c.

14630{
14631 struct chan_iax2_pvt *pvt;
14632 unsigned int callno;
14633 int res = 0;
14634
14635 if (!chan || ast_channel_tech(chan) != &iax2_tech) {
14636 ast_log(LOG_ERROR, "This function requires a valid IAX2 channel\n");
14637 return -1;
14638 }
14639
14640 callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
14641 ast_mutex_lock(&iaxsl[callno]);
14642 if (!(pvt = iaxs[callno])) {
14643 ast_mutex_unlock(&iaxsl[callno]);
14644 return -1;
14645 }
14646
14647 if (!strcasecmp(args, "osptoken")) {
14648 ast_copy_string(buf, pvt->osptoken, buflen);
14649 } else if (!strcasecmp(args, "peerip")) {
14650 ast_copy_string(buf, !ast_sockaddr_isnull(&pvt->addr) ? ast_sockaddr_stringify_addr(&pvt->addr) : "", buflen);
14651 } else if (!strcasecmp(args, "peername")) {
14652 ast_copy_string(buf, pvt->username, buflen);
14653 } else if (!strcasecmp(args, "auth_method")) {
14654 ast_copy_string(buf, auth_method_labels[pvt->eff_auth_method], buflen);
14655 } else if (!strcasecmp(args, "secure_signaling") || !strcasecmp(args, "secure_media")) {
14656 snprintf(buf, buflen, "%s", IAX_CALLENCRYPTED(pvt) ? "1" : "");
14657 } else {
14658 res = -1;
14659 }
14660
14661 ast_mutex_unlock(&iaxsl[callno]);
14662
14663 return res;
14664}

References chan_iax2_pvt::addr, args, ast_channel_tech_pvt(), ast_copy_string(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sockaddr_isnull(), ast_sockaddr_stringify_addr(), auth_method_labels, buf, chan_iax2_pvt::callno, chan_iax2_pvt::eff_auth_method, 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 10172 of file chan_iax2.c.

10173{
10174 struct ast_datastore *variablestore;
10175 AST_LIST_HEAD(, ast_var_t) *varlist;
10176 struct ast_var_t *var;
10177
10178 if (!chan) {
10179 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
10180 return -1;
10181 }
10182
10183 variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
10184 if (!variablestore) {
10185 *buf = '\0';
10186 return 0;
10187 }
10188 varlist = variablestore->data;
10189
10190 AST_LIST_LOCK(varlist);
10191 AST_LIST_TRAVERSE(varlist, var, entries) {
10192 if (strcmp(var->name, data) == 0) {
10193 ast_copy_string(buf, var->value, len);
10194 break;
10195 }
10196 }
10197 AST_LIST_UNLOCK(varlist);
10198 return 0;
10199}

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 10201 of file chan_iax2.c.

10202{
10203 struct ast_datastore *variablestore;
10204 AST_LIST_HEAD(, ast_var_t) *varlist;
10205 struct ast_var_t *var;
10206
10207 if (!chan) {
10208 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
10209 return -1;
10210 }
10211
10212 variablestore = ast_channel_datastore_find(chan, &iax2_variable_datastore_info, NULL);
10213 if (!variablestore) {
10214 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
10215 if (!variablestore) {
10216 ast_log(LOG_ERROR, "Memory allocation error\n");
10217 return -1;
10218 }
10219 varlist = ast_calloc(1, sizeof(*varlist));
10220 if (!varlist) {
10221 ast_datastore_free(variablestore);
10222 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
10223 return -1;
10224 }
10225
10226 AST_LIST_HEAD_INIT(varlist);
10227 variablestore->data = varlist;
10228 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
10229 ast_channel_datastore_add(chan, variablestore);
10230 } else
10231 varlist = variablestore->data;
10232
10233 AST_LIST_LOCK(varlist);
10234 AST_LIST_TRAVERSE_SAFE_BEGIN(varlist, var, entries) {
10235 if (strcmp(var->name, data) == 0) {
10236 AST_LIST_REMOVE_CURRENT(entries);
10237 ast_var_delete(var);
10238 break;
10239 }
10240 }
10241 AST_LIST_TRAVERSE_SAFE_END;
10242 var = ast_var_assign(data, value);
10243 if (var)
10244 AST_LIST_INSERT_TAIL(varlist, var, entries);
10245 else
10246 ast_log(LOG_ERROR, "Unable to assign new variable '%s'\n", data);
10247 AST_LIST_UNLOCK(varlist);
10248 return 0;
10249}

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 1597 of file chan_iax2.c.

1599{
1600 if (stasis_message_type(message) != ast_named_acl_change_type()) {
1601 return;
1602 }
1603
1604 ast_log(LOG_NOTICE, "Reloading chan_iax2 in response to ACL change event.\n");
1605 reload_config(1);
1606}

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

Referenced by acl_change_stasis_subscribe(), and rtp_reload().

◆ acl_change_stasis_subscribe()

static void acl_change_stasis_subscribe ( void  )
static

Definition at line 1555 of file chan_iax2.c.

1556{
1557 if (!acl_change_sub) {
1558 acl_change_sub = stasis_subscribe(ast_security_topic(),
1559 acl_change_stasis_cb, NULL);
1560 stasis_subscription_accept_message_type(acl_change_sub, ast_named_acl_change_type());
1561 stasis_subscription_set_filter(acl_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
1562 }
1563}

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 1565 of file chan_iax2.c.

1566{
1567 acl_change_sub = stasis_unsubscribe_and_join(acl_change_sub);
1568}

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 2881 of file chan_iax2.c.

2882{
2883 struct addr_range tmp;
2884 struct addr_range *addr_range = NULL;
2885 struct ast_ha *ha = NULL;
2886 int error = 0;
2887
2888 if (ast_strlen_zero(addr)) {
2889 ast_log(LOG_WARNING, "invalid calltokenoptional (null)\n");
2890 return -1;
2891 }
2892
2893 ha = ast_append_ha("permit", addr, NULL, &error);
2894
2895 /* check for valid config information */
2896 if (error) {
2897 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2898 return -1;
2899 }
2900
2901 ast_copy_ha(ha, &tmp.ha);
2902 /* find or create the addr_range */
2903 if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2904 ao2_lock(addr_range);
2905 addr_range->delme = 0;
2906 ao2_unlock(addr_range);
2907 } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2908 /* copy over config data into addr_range object */
2909 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2910 ao2_link(calltoken_ignores, addr_range);
2911 } else {
2912 ast_free_ha(ha);
2913 return -1;
2914 }
2915
2916 ast_free_ha(ha);
2917 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2918
2919 return 0;
2920}

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 4911 of file chan_iax2.c.

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

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 2537 of file chan_iax2.c.

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

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 2524 of file chan_iax2.c.

2525{
2526 struct addr_range *lim = obj;
2527 lim->delme = 1;
2528 return 0;
2529}

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 2531 of file chan_iax2.c.

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

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 2561 of file chan_iax2.c.

2562{
2563 struct addr_range *addr_range = obj;
2564 struct ast_sockaddr *addr = arg;
2565 struct ast_sockaddr tmp_addr;
2566
2567 ast_sockaddr_apply_netmask(addr, &addr_range->ha.netmask, &tmp_addr);
2568
2569 if (!ast_sockaddr_cmp_addr(&tmp_addr, &addr_range->ha.addr)) {
2570 return CMP_MATCH | CMP_STOP;
2571 }
2572 return 0;
2573}

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 7929 of file chan_iax2.c.

7930{
7931 while(con) {
7932 if (!strcmp(con->context, context) || !strcmp(con->context, "*"))
7933 return -1;
7934 con = con->next;
7935 }
7936 return 0;
7937}

References iax2_context::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 7630 of file chan_iax2.c.

7631{
7632 int x;
7633 int numchans = 0;
7634 char first_message[10] = { 0, };
7635 char last_message[10] = { 0, };
7636#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"
7637#define ACN_FORMAT2 "%s %u %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s%s %s%s\n"
7638 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
7639 ast_mutex_lock(&iaxsl[x]);
7640 if (iaxs[x]) {
7641 int localjitter, localdelay, locallost, locallosspct, localdropped, localooo;
7642 jb_info jbinfo;
7643 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
7644 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
7645
7646 if(ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
7647 jb_getinfo(iaxs[x]->jb, &jbinfo);
7648 localjitter = jbinfo.jitter;
7649 localdelay = jbinfo.current - jbinfo.min;
7650 locallost = jbinfo.frames_lost;
7651 locallosspct = jbinfo.losspct/1000;
7652 localdropped = jbinfo.frames_dropped;
7653 localooo = jbinfo.frames_ooo;
7654 } else {
7655 localjitter = -1;
7656 localdelay = 0;
7657 locallost = -1;
7658 locallosspct = -1;
7659 localdropped = 0;
7660 localooo = -1;
7661 }
7662 if (s)
7663 astman_append(s, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
7664 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7665 iaxs[x]->pingtime,
7666 localjitter,
7667 localdelay,
7668 locallost,
7669 locallosspct,
7670 localdropped,
7671 localooo,
7672 iaxs[x]->frames_received/1000,
7673 iaxs[x]->remote_rr.jitter,
7674 iaxs[x]->remote_rr.delay,
7675 iaxs[x]->remote_rr.losscnt,
7676 iaxs[x]->remote_rr.losspct,
7677 iaxs[x]->remote_rr.dropped,
7678 iaxs[x]->remote_rr.ooo,
7679 iaxs[x]->remote_rr.packets/1000,
7680 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7681 first_message,
7682 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7683 last_message);
7684 else
7685 ast_cli(fd, limit_fmt ? ACN_FORMAT1 : ACN_FORMAT2,
7686 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7687 iaxs[x]->pingtime,
7688 localjitter,
7689 localdelay,
7690 locallost,
7691 locallosspct,
7692 localdropped,
7693 localooo,
7694 iaxs[x]->frames_received/1000,
7695 iaxs[x]->remote_rr.jitter,
7696 iaxs[x]->remote_rr.delay,
7697 iaxs[x]->remote_rr.losscnt,
7698 iaxs[x]->remote_rr.losspct,
7699 iaxs[x]->remote_rr.dropped,
7700 iaxs[x]->remote_rr.ooo,
7701 iaxs[x]->remote_rr.packets/1000,
7702 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7703 first_message,
7704 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7705 last_message);
7706 numchans++;
7707 }
7708 ast_mutex_unlock(&iaxsl[x]);
7709 }
7710
7711 return numchans;
7712}

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, chan_iax2_pvt::frames_received, iax_frame_subclass2str(), IAX_USEJITTERBUF, iaxs, iaxsl, jb_getinfo(), iax_rr::jitter, 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, chan_iax2_pvt::owner, iax_rr::packets, chan_iax2_pvt::pingtime, 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 5959 of file chan_iax2.c.

5962{
5963 struct ast_channel *tmp = NULL;
5964 struct chan_iax2_pvt *i;
5965 struct iax2_peer *peer;
5966 struct ast_variable *v = NULL;
5967 struct ast_format_cap *native;
5968 struct ast_format *tmpfmt;
5969 ast_callid callid;
5970 char *peer_name = NULL;
5971
5972 if (!(i = iaxs[callno])) {
5973 ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
5974 return NULL;
5975 }
5976
5977 if (!capability) {
5978 ast_log(LOG_WARNING, "No formats specified for call to: IAX2/%s-%d\n",
5979 i->host, i->callno);
5980 return NULL;
5981 }
5982 native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
5983 if (!native) {
5984 return NULL;
5985 }
5986 if (iax2_codec_pref_best_bitfield2cap(capability, prefs, native)
5987 || !ast_format_cap_count(native)) {
5988 ast_log(LOG_WARNING, "No requested formats available for call to: IAX2/%s-%d\n",
5989 i->host, i->callno);
5990 ao2_ref(native, -1);
5991 return NULL;
5992 }
5993
5994 if (!ast_strlen_zero(i->peer)) {
5995 peer_name = ast_strdupa(i->peer);
5996 } else if (!ast_strlen_zero(i->host)) {
5997 peer_name = ast_strdupa(i->host);
5998 }
5999
6000 /* Don't hold call lock while making a channel or looking up a peer */
6001 ast_mutex_unlock(&iaxsl[callno]);
6002
6003 if (!ast_strlen_zero(peer_name)) {
6004 peer = find_peer(peer_name, 1);
6005 if (peer && peer->endpoint) {
6006 tmp = ast_channel_alloc_with_endpoint(1, state, i->cid_num, i->cid_name,
6007 i->accountcode, i->exten, i->context, assignedids, requestor,
6008 i->amaflags, peer->endpoint, "IAX2/%s-%d", i->host, i->callno);
6009 }
6010 ao2_cleanup(peer);
6011 }
6012
6013 if (!tmp) {
6014 tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode,
6015 i->exten, i->context, assignedids, requestor, i->amaflags, "IAX2/%s-%d",
6016 i->host, i->callno);
6017 }
6018
6019 ast_mutex_lock(&iaxsl[callno]);
6020 if (i != iaxs[callno]) {
6021 if (tmp) {
6022 /* unlock and relock iaxsl[callno] to preserve locking order */
6023 ast_mutex_unlock(&iaxsl[callno]);
6024 ast_channel_unlock(tmp);
6025 tmp = ast_channel_release(tmp);
6026 ast_mutex_lock(&iaxsl[callno]);
6027 }
6028 ao2_ref(native, -1);
6029 return NULL;
6030 }
6031 if (!tmp) {
6032 ao2_ref(native, -1);
6033 return NULL;
6034 }
6035
6036 ast_channel_stage_snapshot(tmp);
6037
6038 if ((callid = iaxs[callno]->callid)) {
6039 ast_channel_callid_set(tmp, callid);
6040 }
6041
6042 ast_channel_tech_set(tmp, &iax2_tech);
6043
6044 /* We can support any format by default, until we get restricted */
6045 ast_channel_nativeformats_set(tmp, native);
6046 tmpfmt = ast_format_cap_get_format(native, 0);
6047
6048 ast_channel_set_readformat(tmp, tmpfmt);
6049 ast_channel_set_rawreadformat(tmp, tmpfmt);
6050 ast_channel_set_writeformat(tmp, tmpfmt);
6051 ast_channel_set_rawwriteformat(tmp, tmpfmt);
6052
6053 ao2_ref(tmpfmt, -1);
6054 ao2_ref(native, -1);
6055
6056 ast_channel_tech_pvt_set(tmp, CALLNO_TO_PTR(i->callno));
6057
6058 if (!ast_strlen_zero(i->parkinglot))
6059 ast_channel_parkinglot_set(tmp, i->parkinglot);
6060 /* Don't use ast_set_callerid() here because it will
6061 * generate a NewCallerID event before the NewChannel event */
6062 if (!ast_strlen_zero(i->ani)) {
6063 ast_channel_caller(tmp)->ani.number.valid = 1;
6064 ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->ani);
6065 } else if (!ast_strlen_zero(i->cid_num)) {
6066 ast_channel_caller(tmp)->ani.number.valid = 1;
6067 ast_channel_caller(tmp)->ani.number.str = ast_strdup(i->cid_num);
6068 }
6069 ast_channel_dialed(tmp)->number.str = ast_strdup(i->dnid);
6070 if (!ast_strlen_zero(i->rdnis)) {
6071 ast_channel_redirecting(tmp)->from.number.valid = 1;
6072 ast_channel_redirecting(tmp)->from.number.str = ast_strdup(i->rdnis);
6073 }
6074 ast_channel_caller(tmp)->ani2 = i->calling_ani2;
6075 ast_channel_caller(tmp)->id.name.presentation = i->calling_pres;
6076 ast_channel_caller(tmp)->id.number.presentation = i->calling_pres;
6077 ast_channel_caller(tmp)->id.number.plan = i->calling_ton;
6078 ast_channel_dialed(tmp)->transit_network_select = i->calling_tns;
6079 if (!ast_strlen_zero(i->language))
6080 ast_channel_language_set(tmp, i->language);
6081 if (!ast_strlen_zero(i->accountcode))
6082 ast_channel_accountcode_set(tmp, i->accountcode);
6083 if (i->amaflags)
6084 ast_channel_amaflags_set(tmp, i->amaflags);
6085 ast_channel_context_set(tmp, i->context);
6086 ast_channel_exten_set(tmp, i->exten);
6087 if (i->adsi)
6088 ast_channel_adsicpe_set(tmp, i->peeradsicpe);
6089 else
6090 ast_channel_adsicpe_set(tmp, AST_ADSI_UNAVAILABLE);
6091 i->owner = tmp;
6092 i->capability = capability;
6093
6094 if (!cachable) {
6095 ast_set_flag(ast_channel_flags(tmp), AST_FLAG_DISABLE_DEVSTATE_CACHE);
6096 }
6097
6098 /* Set inherited variables */
6099 if (i->vars) {
6100 for (v = i->vars ; v ; v = v->next)
6101 pbx_builtin_setvar_helper(tmp, v->name, v->value);
6102 }
6103 if (i->iaxvars) {
6104 struct ast_datastore *variablestore;
6105 struct ast_variable *var, *prev = NULL;
6106 AST_LIST_HEAD(, ast_var_t) *varlist;
6107 ast_debug(1, "Loading up the channel with IAXVARs\n");
6108 varlist = ast_calloc(1, sizeof(*varlist));
6109 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
6110 if (variablestore && varlist) {
6111 variablestore->data = varlist;
6112 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
6113 AST_LIST_HEAD_INIT(varlist);
6114 for (var = i->iaxvars; var; var = var->next) {
6115 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
6116 if (prev)
6117 ast_free(prev);
6118 prev = var;
6119 if (!newvar) {
6120 /* Don't abort list traversal, as this would leave i->iaxvars in an inconsistent state. */
6121 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
6122 } else {
6123 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
6124 }
6125 }
6126 if (prev)
6127 ast_free(prev);
6128 i->iaxvars = NULL;
6129 ast_channel_datastore_add(i->owner, variablestore);
6130 } else {
6131 if (variablestore) {
6132 ast_datastore_free(variablestore);
6133 }
6134 if (varlist) {
6135 ast_free(varlist);
6136 }
6137 }
6138 }
6139
6140 ast_channel_stage_snapshot_done(tmp);
6141 ast_channel_unlock(tmp);
6142
6143 if (state != AST_STATE_DOWN) {
6144 if (ast_pbx_start(tmp)) {
6145 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast_channel_name(tmp));
6146 /* unlock and relock iaxsl[callno] to preserve locking order */
6147 ast_mutex_unlock(&iaxsl[callno]);
6148 ast_hangup(tmp);
6149 ast_mutex_lock(&iaxsl[callno]);
6150 return NULL;
6151 }
6152 }
6153
6154 ast_module_ref(ast_module_info->self);
6155 return tmp;
6156}

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 15138 of file chan_iax2.c.

◆ attempt_transmit()

static int attempt_transmit ( const void *  data)
static

Definition at line 3717 of file chan_iax2.c.

3718{
3719#ifdef SCHED_MULTITHREADED
3720 if (schedule_action(__attempt_transmit, data))
3721#endif
3722 __attempt_transmit(data);
3723 return 0;
3724}

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 9511 of file chan_iax2.c.

9512{
9513 /* Schedule sending the authentication failure in one second, to prevent
9514 guessing */
9515 if (iaxs[callno]) {
9516 iaxs[callno]->authfail = failcode;
9517 if (delayreject) {
9518 iaxs[callno]->authid = iax2_sched_replace(iaxs[callno]->authid,
9519 sched, 1000, auth_reject, (void *)(long)callno);
9520 } else
9521 auth_reject((void *)(long)callno);
9522 }
9523 return 0;
9524}

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
Bitfield of auth methods
[out]bufBuffer into which to write the names. Must be of size AUTH_METHOD_NAMES_BUFSIZE.
Returns
Auth methods name

Definition at line 452 of file chan_iax2.c.

453{
454 char *pos = buf;
455
456 *pos = '\0';
457
458 if (authmethods & IAX_AUTH_RSA) {
459 pos += sprintf(pos, "|RSA");
460 }
461 if (authmethods & IAX_AUTH_MD5) {
462 pos += sprintf(pos, "|MD5");
463 }
464 if (authmethods & IAX_AUTH_PLAINTEXT) {
465 pos += sprintf(pos, "|plaintext");
466 }
467
468 if (pos == buf) { /* No auth methods */
469 strcpy(buf, "none");
470 return buf;
471 }
472
473 return buf + 1; /* Skip leading | */
474}

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 9497 of file chan_iax2.c.

9498{
9499 int callno = (int)(long)(data);
9500 ast_mutex_lock(&iaxsl[callno]);
9501 if (iaxs[callno])
9502 iaxs[callno]->authid = -1;
9503 ast_mutex_unlock(&iaxsl[callno]);
9504#ifdef SCHED_MULTITHREADED
9505 if (schedule_action(__auth_reject, data))
9506#endif
9507 __auth_reject(data);
9508 return 0;
9509}

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 8518 of file chan_iax2.c.

8519{
8520 int res = -1;
8521 int x;
8522 if (!ast_strlen_zero(keyn)) {
8523 if (!(authmethods & IAX_AUTH_RSA)) {
8524 if (ast_strlen_zero(secret)) {
8525 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));
8526 }
8527 } else if (ast_strlen_zero(challenge)) {
8528 ast_log(LOG_WARNING, "No challenge provided for RSA authentication to %s\n", ast_sockaddr_stringify_addr(addr));
8529 } else {
8530 char sig[256];
8531 struct ast_key *key;
8532 key = ast_key_get(keyn, AST_KEY_PRIVATE);
8533 if (!key) {
8534 ast_log(LOG_WARNING, "Unable to find private key '%s'\n", keyn);
8535 } else {
8536 if (ast_sign(key, (char*)challenge, sig)) {
8537 ast_log(LOG_WARNING, "Unable to sign challenge with key\n");
8538 res = -1;
8539 } else {
8540 iax_ie_append_str(ied, IAX_IE_RSA_RESULT, sig);
8541 if (pvt) {
8542 pvt->eff_auth_method = IAX_AUTH_RSA;
8543 }
8544 res = 0;
8545 }
8546 }
8547
8548 if (pvt && !ast_strlen_zero(secret)) {
8549 struct MD5Context md5;
8550 unsigned char digest[16];
8551
8552 MD5Init(&md5);
8553 MD5Update(&md5, (unsigned char *) challenge, strlen(challenge));
8554 MD5Update(&md5, (unsigned char *) secret, strlen(secret));
8555 MD5Final(digest, &md5);
8556
8557 build_encryption_keys(digest, pvt);
8558 }
8559 }
8560 }
8561 /* Fall back */
8562 if (res && !ast_strlen_zero(secret)) {
8563 if ((authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(challenge)) {
8564 struct MD5Context md5;
8565 unsigned char digest[16];
8566 char digres[128];
8567 MD5Init(&md5);
8568 MD5Update(&md5, (unsigned char *)challenge, strlen(challenge));
8569 MD5Update(&md5, (unsigned char *)secret, strlen(secret));
8570 MD5Final(digest, &md5);
8571 /* If they support md5, authenticate with it. */
8572 for (x=0;x<16;x++)
8573 sprintf(digres + (x << 1), "%02hhx", digest[x]); /* safe */
8574 if (pvt) {
8575 build_encryption_keys(digest, pvt);
8576 pvt->eff_auth_method = IAX_AUTH_MD5;
8577 }
8578 iax_ie_append_str(ied, IAX_IE_MD5_RESULT, digres);
8579 res = 0;
8580 } else if (authmethods & IAX_AUTH_PLAINTEXT) {
8581 iax_ie_append_str(ied, IAX_IE_PASSWORD, secret);
8582 if (pvt) {
8583 pvt->eff_auth_method = IAX_AUTH_PLAINTEXT;
8584 }
8585 res = 0;
8586 } else
8587 ast_log(LOG_WARNING, "No way to send secret to peer '%s' (their methods: %d)\n", ast_sockaddr_stringify_addr(addr), authmethods);
8588 }
8589 return res;
8590}

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 8596 of file chan_iax2.c.

8597{
8598 struct iax2_peer *peer = NULL;
8599 /* Start pessimistic */
8600 int res = -1;
8601 int authmethods = 0;
8602 struct iax_ie_data ied;
8603 uint16_t callno = p->callno;
8604
8605 memset(&ied, 0, sizeof(ied));
8606
8607 if (ies->username)
8608 ast_string_field_set(p, username, ies->username);
8609 if (ies->challenge)
8610 ast_string_field_set(p, challenge, ies->challenge);
8611 if (ies->authmethods)
8612 authmethods = ies->authmethods;
8613 if (authmethods & IAX_AUTH_MD5)
8614 merge_encryption(p, ies->encmethods);
8615 else
8616 p->encmethods = 0;
8617
8618 /* Check for override RSA authentication first */
8619 if (!ast_strlen_zero(override) || !ast_strlen_zero(okey)) {
8620 /* Normal password authentication */
8621 res = authenticate(p->challenge, override, okey, authmethods, &ied, addr, p);
8622 } else {
8623 struct ao2_iterator i = ao2_iterator_init(peers, 0);
8624 while ((peer = ao2_iterator_next(&i))) {
8625 struct ast_sockaddr peer_addr;
8626 struct ast_sockaddr tmp_sockaddr1;
8627 struct ast_sockaddr tmp_sockaddr2;
8628
8629 ast_sockaddr_copy(&peer_addr, &peer->addr);
8630
8631 ast_sockaddr_apply_netmask(addr, &peer->mask, &tmp_sockaddr1);
8632 ast_sockaddr_apply_netmask(&peer_addr, &peer->mask, &tmp_sockaddr2);
8633
8634 if ((ast_strlen_zero(p->peer) || !strcmp(p->peer, peer->name))
8635 /* No peer specified at our end, or this is the peer */
8636 && (ast_strlen_zero(peer->username) || (!strcmp(peer->username, p->username)))
8637 /* No username specified in peer rule, or this is the right username */
8638 && (ast_sockaddr_isnull(&peer_addr) || !(ast_sockaddr_cmp_addr(&tmp_sockaddr1, &tmp_sockaddr2)))
8639 /* No specified host, or this is our host */
8640 ) {
8641 res = authenticate(p->challenge, peer->secret, peer->outkey, authmethods, &ied, addr, p);
8642 if (!res) {
8643 peer_unref(peer);
8644 break;
8645 }
8646 }
8647 peer_unref(peer);
8648 }
8649 ao2_iterator_destroy(&i);
8650 if (!peer) {
8651 /* We checked our list and didn't find one. It's unlikely, but possible,
8652 that we're trying to authenticate *to* a realtime peer */
8653 const char *peer_name = ast_strdupa(p->peer);
8654 ast_mutex_unlock(&iaxsl[callno]);
8655 if ((peer = realtime_peer(peer_name, NULL))) {
8656 ast_mutex_lock(&iaxsl[callno]);
8657 if (!(p = iaxs[callno])) {
8658 peer_unref(peer);
8659 return -1;
8660 }
8661 res = authenticate(p->challenge, peer->secret,peer->outkey, authmethods, &ied, addr, p);
8662 peer_unref(peer);
8663 }
8664 if (!peer) {
8665 ast_mutex_lock(&iaxsl[callno]);
8666 if (!(p = iaxs[callno]))
8667 return -1;
8668 }
8669 }
8670 }
8671
8672 if (!(ies->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT)) && (ies->authmethods & IAX_AUTH_RSA) && ast_strlen_zero(okey)) {
8673 /* If the only thing available is RSA, and we don't have an outkey, we can't do it... */
8674 ast_log(LOG_WARNING, "Call terminated. RSA authentication requires an outkey\n");
8675 return -1;
8676 }
8677
8678 if (ies->encmethods) {
8679 if (ast_strlen_zero(p->secret) &&
8680 ((ies->authmethods & IAX_AUTH_RSA) || (ies->authmethods & IAX_AUTH_MD5) || (ies->authmethods & IAX_AUTH_PLAINTEXT))) {
8681 ast_log(LOG_WARNING, "Call terminated. Encryption requested by peer but no secret available locally\n");
8682 return -1;
8683 }
8684 /* Don't even THINK about trying to encrypt or decrypt anything if we don't have valid keys, for some reason... */
8685 /* If either of these happens, it's our fault, not the user's. But we should abort rather than crash. */
8686 ast_assert_return(!invalid_key(&p->ecx), -1);
8687 ast_assert_return(!invalid_key(&p->dcx), -1);
8688 ast_set_flag64(p, IAX_ENCRYPTED | IAX_KEYPOPULATED);
8689 } else if (ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
8690 ast_log(LOG_NOTICE, "Call initiated without encryption while forceencryption=yes option is set\n");
8691 return -1; /* if force encryption is yes, and no encryption methods, then return -1 to hangup */
8692 }
8693 if (!res) {
8694 struct ast_datastore *variablestore;
8695 struct ast_variable *var, *prev = NULL;
8696 AST_LIST_HEAD(, ast_var_t) *varlist;
8697 varlist = ast_calloc(1, sizeof(*varlist));
8698 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
8699 if (variablestore && varlist && p->owner) {
8700 variablestore->data = varlist;
8701 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
8702 AST_LIST_HEAD_INIT(varlist);
8703 for (var = ies->vars; var; var = var->next) {
8704 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
8705 if (prev)
8706 ast_free(prev);
8707 prev = var;
8708 if (!newvar) {
8709 /* Don't abort list traversal, as this would leave ies->vars in an inconsistent state. */
8710 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
8711 } else {
8712 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
8713 }
8714 }
8715 if (prev)
8716 ast_free(prev);
8717 ies->vars = NULL;
8718 ast_channel_datastore_add(p->owner, variablestore);
8719 } else {
8720 if (p->owner)
8721 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
8722 if (variablestore)
8723 ast_datastore_free(variablestore);
8724 if (varlist)
8725 ast_free(varlist);
8726 }
8727 }
8728
8729 if (!res)
8730 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1);
8731 return res;
8732}

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 8210 of file chan_iax2.c.

8211{
8212 struct iax_ie_data ied;
8213 int res = -1, authreq_restrict = 0;
8214 char challenge[10];
8215 struct chan_iax2_pvt *p = iaxs[call_num];
8216
8217 memset(&ied, 0, sizeof(ied));
8218
8219 /* If an AUTHREQ restriction is in place, make sure we can send an AUTHREQ back */
8220 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
8221 struct iax2_user *user;
8222
8223 user = ao2_find(users, p->username, OBJ_KEY);
8224 if (user) {
8225 if (user->curauthreq == user->maxauthreq)
8226 authreq_restrict = 1;
8227 else
8228 user->curauthreq++;
8229 user = user_unref(user);
8230 }
8231 }
8232
8233 /* If the AUTHREQ limit test failed, send back an error */
8234 if (authreq_restrict) {
8235 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Unauthenticated call limit reached");
8236 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, AST_CAUSE_CALL_REJECTED);
8237 send_command_final(p, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
8238 return 0;
8239 }
8240
8241 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, p->authmethods);
8242 if (p->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA)) {
8243 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
8244 ast_string_field_set(p, challenge, challenge);
8245 /* snprintf(p->challenge, sizeof(p->challenge), "%d", (int)ast_random()); */
8246 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, p->challenge);
8247 }
8248 if (p->encmethods)
8249 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, p->encmethods);
8250
8251 iax_ie_append_str(&ied,IAX_IE_USERNAME, p->username);
8252
8253 res = send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREQ, 0, ied.buf, ied.pos, -1);
8254
8255 if (p->encmethods)
8256 ast_set_flag64(p, IAX_ENCRYPTED);
8257
8258 return res;
8259}

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_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 8261 of file chan_iax2.c.

8262{
8263 char requeststr[256];
8264 char md5secret[256] = "";
8265 char secret[256] = "";
8266 char rsasecret[256] = "";
8267 int res = -1;
8268 int x;
8269 struct iax2_user *user;
8270
8271 if (p->authrej) {
8272 return res;
8273 }
8274
8275 user = ao2_find(users, p->username, OBJ_KEY);
8276 if (user) {
8277 if (ast_test_flag64(p, IAX_MAXAUTHREQ)) {
8278 ast_atomic_fetchadd_int(&user->curauthreq, -1);
8279 ast_clear_flag64(p, IAX_MAXAUTHREQ);
8280 }
8281 ast_string_field_set(p, host, user->name);
8282 user = user_unref(user);
8283 }
8284 if (ast_test_flag64(p, IAX_FORCE_ENCRYPT) && !p->encmethods) {
8285 ast_log(LOG_WARNING, "Call Terminated, incoming call is unencrypted while force encrypt is enabled.\n");
8286 return res;
8287 }
8288 if (!ast_test_flag(&p->state, IAX_STATE_AUTHENTICATED))
8289 return res;
8290 if (ies->password)
8291 ast_copy_string(secret, ies->password, sizeof(secret));
8292 if (ies->md5_result)
8293 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
8294 if (ies->rsa_result)
8295 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
8296 if ((p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(rsasecret) && !ast_strlen_zero(p->inkeys)) {
8297 struct ast_key *key;
8298 char *keyn;
8299 char *tmpkey;
8300 char *stringp=NULL;
8301 if (!(tmpkey = ast_strdup(p->inkeys))) {
8302 ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
8303 return res;
8304 }
8305 stringp = tmpkey;
8306 keyn = strsep(&stringp, ":");
8307 while(keyn) {
8308 key = ast_key_get(keyn, AST_KEY_PUBLIC);
8309 if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
8310 res = 0;
8311 p->eff_auth_method = IAX_AUTH_RSA;
8312 break;
8313 } else if (!key) {
8314 ast_log(LOG_WARNING, "Requested inkey '%s' for RSA authentication does not exist\n", keyn);
8315 }
8316 keyn = strsep(&stringp, ":");
8317 }
8318 ast_free(tmpkey);
8319 if (res && authdebug) {
8320 ast_log(LOG_WARNING, "No RSA public keys on file matched incoming call\n");
8321 }
8322 } else if (p->authmethods & IAX_AUTH_MD5) {
8323 struct MD5Context md5;
8324 unsigned char digest[16];
8325 char *tmppw, *stringp;
8326 tmppw = ast_strdupa(p->secret);
8327 stringp = tmppw;
8328 while((tmppw = strsep(&stringp, ";"))) {
8329 MD5Init(&md5);
8330 MD5Update(&md5, (unsigned char *)p->challenge, strlen(p->challenge));
8331 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
8332 MD5Final(digest, &md5);
8333 /* If they support md5, authenticate with it. */
8334 for (x=0;x<16;x++)
8335 sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
8336 if (!strcasecmp(requeststr, md5secret)) {
8337 res = 0;
8338 p->eff_auth_method = IAX_AUTH_MD5;
8339 break;
8340 } else if (authdebug) {
8341 ast_log(LOG_WARNING, "MD5 secret mismatch\n");
8342 }
8343 }
8344 } else if (p->authmethods & IAX_AUTH_PLAINTEXT) {
8345 if (!strcmp(secret, p->secret)) {
8346 res = 0;
8347 p->eff_auth_method = IAX_AUTH_PLAINTEXT;
8348 } else if (authdebug) {
8349 ast_log(LOG_WARNING, "Plaintext secret mismatch\n");
8350 }
8351 }
8352 return res;
8353}

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_unref(), and chan_iax2_pvt::username.

Referenced by socket_process_helper().

◆ auto_congest()

static int auto_congest ( const void *  data)
static

Definition at line 4848 of file chan_iax2.c.

4849{
4850#ifdef SCHED_MULTITHREADED
4851 if (schedule_action(__auto_congest, data))
4852#endif
4853 __auto_congest(data);
4854 return 0;
4855}

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 9541 of file chan_iax2.c.

9542{
9543 int callno = (int)(long)(data);
9544 ast_mutex_lock(&iaxsl[callno]);
9545 if (iaxs[callno]) {
9546 iaxs[callno]->autoid = -1;
9547 }
9548 ast_mutex_unlock(&iaxsl[callno]);
9549#ifdef SCHED_MULTITHREADED
9550 if (schedule_action(__auto_hangup, data))
9551#endif
9552 __auto_hangup(data);
9553 return 0;
9554}

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 2826 of file chan_iax2.c.

2827{
2828 struct addr_range *addr_range = NULL;
2829 struct addr_range tmp;
2830 struct ast_ha *ha;
2831 int limit;
2832 int error;
2833 int found;
2834
2835 for (; v; v = v->next) {
2836 limit = -1;
2837 error = 0;
2838 found = 0;
2839 ha = ast_append_ha("permit", v->name, NULL, &error);
2840
2841 /* check for valid config information */
2842 if (error) {
2843 ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2844 continue;
2845 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2846 ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2847 ast_free_ha(ha);
2848 continue;
2849 }
2850
2851 ast_copy_ha(ha, &tmp.ha);
2852 /* find or create the addr_range */
2853 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2854 ao2_lock(addr_range);
2855 found = 1;
2856 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2857 ast_free_ha(ha);
2858 return; /* out of memory */
2859 }
2860
2861 /* copy over config data into addr_range object */
2862 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2863 ast_free_ha(ha); /* cleanup the tmp ha */
2864 addr_range->limit = limit;
2865 addr_range->delme = 0;
2866
2867 /* cleanup */
2868 if (found) {
2869 ao2_unlock(addr_range);
2870 } else {
2871 ao2_link(callno_limits, addr_range);
2872 }
2873 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2874 }
2875}

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 12892 of file chan_iax2.c.

12893{
12894 struct iax2_context *con;
12895
12896 if ((con = ast_calloc(1, sizeof(*con))))
12897 ast_copy_string(con->context, context, sizeof(con->context));
12898
12899 return con;
12900}

References ast_calloc, ast_copy_string(), and iax2_context::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 6518 of file chan_iax2.c.

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

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 6512 of file chan_iax2.c.

6513{
6514 build_ecx_key(digest, pvt);
6515 ast_aes_set_decrypt_key(digest, &pvt->dcx);
6516}

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 13041 of file chan_iax2.c.

13042{
13043 struct iax2_peer *peer = NULL;
13044 struct ast_acl_list *oldacl = NULL;
13045 int maskfound = 0;
13046 int found = 0;
13047 int firstpass = 1;
13048 int subscribe_acl_change = 0;
13049
13050 if (!temponly) {
13051 peer = ao2_find(peers, name, OBJ_KEY);
13052 if (peer && !ast_test_flag64(peer, IAX_DELME))
13053 firstpass = 0;
13054 }
13055
13056 if (peer) {
13057 found++;
13058 if (firstpass) {
13059 oldacl = peer->acl;
13060 peer->acl = NULL;
13061 }
13062 unlink_peer(peer);
13063 } else if ((peer = ao2_alloc(sizeof(*peer), peer_destructor))) {
13064 peer->expire = -1;
13065 peer->pokeexpire = -1;
13066 peer->sockfd = defaultsockfd;
13067 if (ast_string_field_init(peer, 32))
13068 peer = peer_unref(peer);
13069 if (!(peer->endpoint = ast_endpoint_create("IAX2", name))) {
13070 peer = peer_unref(peer);
13071 }
13072 }
13073
13074 if (peer) {
13075 if (firstpass) {
13076 ast_copy_flags64(peer, &globalflags, IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
13077 peer->encmethods = iax2_encryption;
13078 peer->authmethods = iax2_authmethods;
13079 peer->adsi = adsi;
13080 ast_string_field_set(peer, secret, "");
13081 if (!found) {
13082 ast_string_field_set(peer, name, name);
13083 ast_sockaddr_parse(&peer->addr, "0.0.0.0", 0);
13084 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
13085 peer->expiry = min_reg_expire;
13086 }
13087 peer->prefs = prefs_global;
13088 peer->capability = iax2_capability;
13089 peer->smoothing = 0;
13090 peer->pokefreqok = DEFAULT_FREQ_OK;
13091 peer->pokefreqnotok = DEFAULT_FREQ_NOTOK;
13092 peer->maxcallno = 0;
13093 peercnt_modify((unsigned char) 0, 0, &peer->addr);
13094 peer->calltoken_required = CALLTOKEN_DEFAULT;
13095 ast_string_field_set(peer,context,"");
13096 ast_string_field_set(peer,peercontext,"");
13097 ast_clear_flag64(peer, IAX_HASCALLERID);
13098 ast_string_field_set(peer, cid_name, "");
13099 ast_string_field_set(peer, cid_num, "");
13100 ast_string_field_set(peer, mohinterpret, mohinterpret);
13101 ast_string_field_set(peer, mohsuggest, mohsuggest);
13102 }
13103
13104 if (!v) {
13105 v = alt;
13106 alt = NULL;
13107 }
13108 while(v) {
13109 if (!strcasecmp(v->name, "secret")) {
13110 ast_string_field_set(peer, secret, v->value);
13111 } else if (!strcasecmp(v->name, "mailbox")) {
13112 ast_string_field_set(peer, mailbox, v->value);
13113 } else if (!strcasecmp(v->name, "mohinterpret")) {
13114 ast_string_field_set(peer, mohinterpret, v->value);
13115 } else if (!strcasecmp(v->name, "mohsuggest")) {
13116 ast_string_field_set(peer, mohsuggest, v->value);
13117 } else if (!strcasecmp(v->name, "dbsecret")) {
13118 ast_string_field_set(peer, dbsecret, v->value);
13119 } else if (!strcasecmp(v->name, "description")) {
13120 ast_string_field_set(peer, description, v->value);
13121 } else if (!strcasecmp(v->name, "trunk")) {
13122 ast_set2_flag64(peer, ast_true(v->value), IAX_TRUNK);
13123 if (ast_test_flag64(peer, IAX_TRUNK) && !timer) {
13124 ast_log(LOG_WARNING, "Unable to support trunking on peer '%s' without a timing interface\n", peer->name);
13125 ast_clear_flag64(peer, IAX_TRUNK);
13126 }
13127 } else if (!strcasecmp(v->name, "auth")) {
13128 peer->authmethods = get_auth_methods(v->value);
13129 if (peer->authmethods & IAX_AUTH_PLAINTEXT) {
13130 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);
13131 }
13132 } else if (!strcasecmp(v->name, "encryption")) {
13133 peer->encmethods |= get_encrypt_methods(v->value);
13134 if (!peer->encmethods) {
13135 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
13136 }
13137 } else if (!strcasecmp(v->name, "forceencryption")) {
13138 if (ast_false(v->value)) {
13139 ast_clear_flag64(peer, IAX_FORCE_ENCRYPT);
13140 } else {
13141 peer->encmethods |= get_encrypt_methods(v->value);
13142 if (peer->encmethods) {
13143 ast_set_flag64(peer, IAX_FORCE_ENCRYPT);
13144 }
13145 }
13146 } else if (!strcasecmp(v->name, "transfer")) {
13147 if (!strcasecmp(v->value, "mediaonly")) {
13148 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13149 } else if (ast_true(v->value)) {
13150 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13151 } else
13152 ast_set_flags_to64(peer, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13153 } else if (!strcasecmp(v->name, "jitterbuffer")) {
13154 ast_set2_flag64(peer, ast_true(v->value), IAX_USEJITTERBUF);
13155 } else if (!strcasecmp(v->name, "host")) {
13156 if (!strcasecmp(v->value, "dynamic")) {
13157 /* They'll register with us */
13158 ast_set_flag64(peer, IAX_DYNAMIC);
13159 if (!found) {
13160 int peer_port = ast_sockaddr_port(&peer->addr);
13161 if (peer_port) {
13162 ast_sockaddr_set_port(&peer->defaddr, peer_port);
13163 }
13164 ast_sockaddr_setnull(&peer->addr);
13165 }
13166 } else {
13167 /* Non-dynamic. Make sure we become that way if we're not */
13168 AST_SCHED_DEL(sched, peer->expire);
13169 ast_clear_flag64(peer, IAX_DYNAMIC);
13170 if (peer->dnsmgr) {
13171 // Make sure we refresh dnsmgr if we're using it
13172 ast_dnsmgr_refresh(peer->dnsmgr);
13173 } else {
13174 // Or just invalidate the address
13175 peer->addr.ss.ss_family = AST_AF_UNSPEC;
13176 }
13177 if (ast_dnsmgr_lookup(v->value, &peer->addr, &peer->dnsmgr, srvlookup ? "_iax._udp" : NULL)) {
13178 return peer_unref(peer);
13179 }
13180 if (!ast_sockaddr_port(&peer->addr)) {
13181 ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
13182 }
13183 }
13184 } else if (!strcasecmp(v->name, "defaultip")) {
13185 struct ast_sockaddr peer_defaddr_tmp;
13186 peer_defaddr_tmp.ss.ss_family = AF_UNSPEC;
13187 if (ast_get_ip(&peer_defaddr_tmp, v->value)) {
13188 return peer_unref(peer);
13189 }
13190 ast_sockaddr_set_port(&peer_defaddr_tmp, ast_sockaddr_port(&peer->defaddr));
13191 ast_sockaddr_copy(&peer->defaddr, &peer_defaddr_tmp);
13192 } else if (!strcasecmp(v->name, "sourceaddress")) {
13193 peer_set_srcaddr(peer, v->value);
13194 } else if (!strcasecmp(v->name, "permit") ||
13195 !strcasecmp(v->name, "deny") ||
13196 !strcasecmp(v->name, "acl")) {
13197 ast_append_acl(v->name, v->value, &peer->acl, NULL, &subscribe_acl_change);
13198 } else if (!strcasecmp(v->name, "mask")) {
13199 maskfound++;
13200 ast_sockaddr_parse(&peer->mask, v->value, 0);
13201 } else if (!strcasecmp(v->name, "context")) {
13202 ast_string_field_set(peer, context, v->value);
13203 } else if (!strcasecmp(v->name, "regexten")) {
13204 ast_string_field_set(peer, regexten, v->value);
13205 } else if (!strcasecmp(v->name, "peercontext")) {
13206 ast_string_field_set(peer, peercontext, v->value);
13207 } else if (!strcasecmp(v->name, "port")) {
13208 int bindport;
13209 if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
13210 bindport = IAX_DEFAULT_PORTNO;
13211 }
13212 if (ast_test_flag64(peer, IAX_DYNAMIC)) {
13213 ast_sockaddr_set_port(&peer->defaddr, bindport);
13214 } else {
13215 ast_sockaddr_set_port(&peer->addr, bindport);
13216 }
13217 } else if (!strcasecmp(v->name, "username")) {
13218 ast_string_field_set(peer, username, v->value);
13219 } else if (!strcasecmp(v->name, "allow")) {
13220 iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
13221 } else if (!strcasecmp(v->name, "disallow")) {
13222 iax2_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
13223 } else if (!strcasecmp(v->name, "callerid")) {
13224 if (!ast_strlen_zero(v->value)) {
13225 char name2[80];
13226 char num2[80];
13227 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
13228 ast_string_field_set(peer, cid_name, name2);
13229 ast_string_field_set(peer, cid_num, num2);
13230 } else {
13231 ast_string_field_set(peer, cid_name, "");
13232 ast_string_field_set(peer, cid_num, "");
13233 }
13234 ast_set_flag64(peer, IAX_HASCALLERID);
13235 } else if (!strcasecmp(v->name, "fullname")) {
13236 ast_string_field_set(peer, cid_name, S_OR(v->value, ""));
13237 ast_set_flag64(peer, IAX_HASCALLERID);
13238 } else if (!strcasecmp(v->name, "cid_number")) {
13239 ast_string_field_set(peer, cid_num, S_OR(v->value, ""));
13240 ast_set_flag64(peer, IAX_HASCALLERID);
13241 } else if (!strcasecmp(v->name, "sendani")) {
13242 ast_set2_flag64(peer, ast_true(v->value), IAX_SENDANI);
13243 } else if (!strcasecmp(v->name, "inkeys")) {
13244 ast_string_field_set(peer, inkeys, v->value);
13245 } else if (!strcasecmp(v->name, "outkey")) {
13246 ast_string_field_set(peer, outkey, v->value);
13247 } else if (!strcasecmp(v->name, "qualify")) {
13248 if (!strcasecmp(v->value, "no")) {
13249 peer->maxms = 0;
13250 } else if (!strcasecmp(v->value, "yes")) {
13251 peer->maxms = DEFAULT_MAXMS;
13252 } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
13253 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);
13254 peer->maxms = 0;
13255 }
13256 } else if (!strcasecmp(v->name, "qualifysmoothing")) {
13257 peer->smoothing = ast_true(v->value);
13258 } else if (!strcasecmp(v->name, "qualifyfreqok")) {
13259 if (sscanf(v->value, "%30d", &peer->pokefreqok) != 1) {
13260 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);
13261 }
13262 } else if (!strcasecmp(v->name, "qualifyfreqnotok")) {
13263 if (sscanf(v->value, "%30d", &peer->pokefreqnotok) != 1) {
13264 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);
13265 }
13266 } else if (!strcasecmp(v->name, "timezone")) {
13267 ast_string_field_set(peer, zonetag, v->value);
13268 } else if (!strcasecmp(v->name, "adsi")) {
13269 peer->adsi = ast_true(v->value);
13270 } else if (!strcasecmp(v->name, "connectedline")) {
13271 if (ast_true(v->value)) {
13272 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13273 } else if (!strcasecmp(v->value, "send")) {
13274 ast_clear_flag64(peer, IAX_RECVCONNECTEDLINE);
13275 ast_set_flag64(peer, IAX_SENDCONNECTEDLINE);
13276 } else if (!strcasecmp(v->value, "receive")) {
13277 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE);
13278 ast_set_flag64(peer, IAX_RECVCONNECTEDLINE);
13279 } else {
13280 ast_clear_flag64(peer, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13281 }
13282 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
13283 if (sscanf(v->value, "%10hu", &peer->maxcallno) != 1) {
13284 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d.\n", v->value, v->lineno);
13285 } else {
13286 peercnt_modify((unsigned char) 1, peer->maxcallno, &peer->addr);
13287 }
13288 } else if (!strcasecmp(v->name, "requirecalltoken")) {
13289 /* default is required unless in optional ip list */
13290 if (ast_false(v->value)) {
13291 peer->calltoken_required = CALLTOKEN_NO;
13292 } else if (!strcasecmp(v->value, "auto")) {
13293 peer->calltoken_required = CALLTOKEN_AUTO;
13294 } else if (ast_true(v->value)) {
13295 peer->calltoken_required = CALLTOKEN_YES;
13296 } else {
13297 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
13298 }
13299 } /* else if (strcasecmp(v->name,"type")) */
13300 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
13301 v = v->next;
13302 if (!v) {
13303 v = alt;
13304 alt = NULL;
13305 }
13306 }
13307 if (!peer->authmethods)
13308 peer->authmethods = IAX_AUTH_MD5;
13309 ast_clear_flag64(peer, IAX_DELME);
13310 }
13311
13312 if (!maskfound && !ast_sockaddr_isnull(&peer->addr)) {
13313 if (ast_sockaddr_is_ipv4_mapped(&peer->addr)) {
13314 ast_sockaddr_parse(&peer->mask, "::ffff:ffff:ffff", 0);
13315 } else if (ast_sockaddr_is_ipv6(&peer->addr)) {
13316 ast_sockaddr_parse(&peer->mask, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
13317 } else {
13318 ast_sockaddr_parse(&peer->mask, "255.255.255.255", 0);
13319 }
13320 }
13321
13322 if (oldacl) {
13323 ast_free_acl_list(oldacl);
13324 }
13325
13326 if (!ast_strlen_zero(peer->mailbox) && !peer->mwi_event_sub) {
13327 /* The MWI subscriptions exist just so the core knows we care about those
13328 * mailboxes. However, we just grab the events out of the cache when it
13329 * is time to send MWI, since it is only sent with a REGACK. */
13330 peer->mwi_event_sub = ast_mwi_subscribe_pool(peer->mailbox, stasis_subscription_cb_noop, NULL);
13331 }
13332
13333 if (subscribe_acl_change) {
13334 acl_change_stasis_subscribe();
13335 }
13336
13337 return peer;
13338}

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_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, 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, 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 6486 of file chan_iax2.c.

6487{
6488 long tmp;
6489 for (tmp = ast_random(); len > 0; tmp = ast_random()) {
6490 memcpy(buf, (unsigned char *) &tmp, (len > sizeof(tmp)) ? sizeof(tmp) : len);
6491 buf += sizeof(tmp);
6492 len -= sizeof(tmp);
6493 }
6494}

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 13354 of file chan_iax2.c.

13355{
13356 struct iax2_user *user = NULL;
13357 struct iax2_context *con, *conl = NULL;
13358 struct ast_acl_list *oldacl = NULL;
13359 struct iax2_context *oldcon = NULL;
13360 int format;
13361 int firstpass=1;
13362 int oldcurauthreq = 0;
13363 int subscribe_acl_change = 0;
13364 char *varname = NULL, *varval = NULL;
13365 struct ast_variable *tmpvar = NULL;
13366
13367 if (!temponly) {
13368 user = ao2_find(users, name, OBJ_KEY);
13369 if (user && !ast_test_flag64(user, IAX_DELME))
13370 firstpass = 0;
13371 }
13372
13373 if (user) {
13374 if (firstpass) {
13375 oldcurauthreq = user->curauthreq;
13376 oldacl = user->acl;
13377 oldcon = user->contexts;
13378 user->acl = NULL;
13379 user->contexts = NULL;
13380 }
13381 /* Already in the list, remove it and it will be added back (or FREE'd) */
13382 ao2_unlink(users, user);
13383 } else {
13384 user = ao2_alloc(sizeof(*user), user_destructor);
13385 }
13386
13387 if (user) {
13388 if (firstpass) {
13389 ast_string_field_free_memory(user);
13390 memset(user, 0, sizeof(struct iax2_user));
13391 if (ast_string_field_init(user, 32)) {
13392 user = user_unref(user);
13393 goto cleanup;
13394 }
13395 user->maxauthreq = maxauthreq;
13396 user->curauthreq = oldcurauthreq;
13397 user->prefs = prefs_global;
13398 user->capability = iax2_capability;
13399 user->encmethods = iax2_encryption;
13400 user->authmethods = iax2_authmethods;
13401 user->adsi = adsi;
13402 user->calltoken_required = CALLTOKEN_DEFAULT;
13403 ast_string_field_set(user, name, name);
13404 ast_string_field_set(user, language, language);
13405 ast_copy_flags64(user, &globalflags, IAX_USEJITTERBUF | IAX_CODEC_USER_FIRST | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
13406 ast_clear_flag64(user, IAX_HASCALLERID);
13407 ast_string_field_set(user, cid_name, "");
13408 ast_string_field_set(user, cid_num, "");
13409 ast_string_field_set(user, accountcode, accountcode);
13410 ast_string_field_set(user, mohinterpret, mohinterpret);
13411 ast_string_field_set(user, mohsuggest, mohsuggest);
13412 }
13413 if (!v) {
13414 v = alt;
13415 alt = NULL;
13416 }
13417 while(v) {
13418 if (!strcasecmp(v->name, "context")) {
13419 con = build_context(v->value);
13420 if (con) {
13421 if (conl)
13422 conl->next = con;
13423 else
13424 user->contexts = con;
13425 conl = con;
13426 }
13427 } else if (!strcasecmp(v->name, "permit") ||
13428 !strcasecmp(v->name, "deny") ||
13429 !strcasecmp(v->name, "acl")) {
13430 ast_append_acl(v->name, v->value, &user->acl, NULL, &subscribe_acl_change);
13431 } else if (!strcasecmp(v->name, "setvar")) {
13432 varname = ast_strdupa(v->value);
13433 if ((varval = strchr(varname, '='))) {
13434 *varval = '\0';
13435 varval++;
13436 if ((tmpvar = ast_variable_new(varname, varval, ""))) {
13437 if (ast_variable_list_replace(&user->vars, tmpvar)) {
13438 tmpvar->next = user->vars;
13439 user->vars = tmpvar;
13440 }
13441 }
13442 }
13443 } else if (!strcasecmp(v->name, "allow")) {
13444 iax2_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
13445 } else if (!strcasecmp(v->name, "disallow")) {
13446 iax2_parse_allow_disallow(&user->prefs, &user->capability,v->value, 0);
13447 } else if (!strcasecmp(v->name, "trunk")) {
13448 ast_set2_flag64(user, ast_true(v->value), IAX_TRUNK);
13449 if (ast_test_flag64(user, IAX_TRUNK) && !timer) {
13450 ast_log(LOG_WARNING, "Unable to support trunking on user '%s' without a timing interface\n", user->name);
13451 ast_clear_flag64(user, IAX_TRUNK);
13452 }
13453 } else if (!strcasecmp(v->name, "auth")) {
13454 user->authmethods = get_auth_methods(v->value);
13455 if (user->authmethods & IAX_AUTH_PLAINTEXT) {
13456 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);
13457 }
13458 } else if (!strcasecmp(v->name, "encryption")) {
13459 user->encmethods |= get_encrypt_methods(v->value);
13460 if (!user->encmethods) {
13461 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
13462 }
13463 } else if (!strcasecmp(v->name, "forceencryption")) {
13464 if (ast_false(v->value)) {
13465 ast_clear_flag64(user, IAX_FORCE_ENCRYPT);
13466 } else {
13467 user->encmethods |= get_encrypt_methods(v->value);
13468 if (user->encmethods) {
13469 ast_set_flag64(user, IAX_FORCE_ENCRYPT);
13470 }
13471 }
13472 } else if (!strcasecmp(v->name, "transfer")) {
13473 if (!strcasecmp(v->value, "mediaonly")) {
13474 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13475 } else if (ast_true(v->value)) {
13476 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13477 } else
13478 ast_set_flags_to64(user, IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13479 } else if (!strcasecmp(v->name, "codecpriority")) {
13480 if(!strcasecmp(v->value, "caller"))
13481 ast_set_flag64(user, IAX_CODEC_USER_FIRST);
13482 else if(!strcasecmp(v->value, "disabled"))
13483 ast_set_flag64(user, IAX_CODEC_NOPREFS);
13484 else if(!strcasecmp(v->value, "reqonly")) {
13485 ast_set_flag64(user, IAX_CODEC_NOCAP);
13486 ast_set_flag64(user, IAX_CODEC_NOPREFS);
13487 }
13488 } else if (!strcasecmp(v->name, "immediate")) {
13489 ast_set2_flag64(user, ast_true(v->value), IAX_IMMEDIATE);
13490 } else if (!strcasecmp(v->name, "jitterbuffer")) {
13491 ast_set2_flag64(user, ast_true(v->value), IAX_USEJITTERBUF);
13492 } else if (!strcasecmp(v->name, "dbsecret")) {
13493 ast_string_field_set(user, dbsecret, v->value);
13494 } else if (!strcasecmp(v->name, "secret")) {
13495 if (!ast_strlen_zero(user->secret)) {
13496 char *old = ast_strdupa(user->secret);
13497
13498 ast_string_field_build(user, secret, "%s;%s", old, v->value);
13499 } else
13500 ast_string_field_set(user, secret, v->value);
13501 } else if (!strcasecmp(v->name, "callerid")) {
13502 if (!ast_strlen_zero(v->value) && strcasecmp(v->value, "asreceived")) {
13503 char name2[80];
13504 char num2[80];
13505 ast_callerid_split(v->value, name2, sizeof(name2), num2, sizeof(num2));
13506 ast_string_field_set(user, cid_name, name2);
13507 ast_string_field_set(user, cid_num, num2);
13508 ast_set_flag64(user, IAX_HASCALLERID);
13509 } else {
13510 ast_clear_flag64(user, IAX_HASCALLERID);
13511 ast_string_field_set(user, cid_name, "");
13512 ast_string_field_set(user, cid_num, "");
13513 }
13514 } else if (!strcasecmp(v->name, "fullname")) {
13515 if (!ast_strlen_zero(v->value)) {
13516 ast_string_field_set(user, cid_name, v->value);
13517 ast_set_flag64(user, IAX_HASCALLERID);
13518 } else {
13519 ast_string_field_set(user, cid_name, "");
13520 if (ast_strlen_zero(user->cid_num))
13521 ast_clear_flag64(user, IAX_HASCALLERID);
13522 }
13523 } else if (!strcasecmp(v->name, "cid_number")) {
13524 if (!ast_strlen_zero(v->value)) {
13525 ast_string_field_set(user, cid_num, v->value);
13526 ast_set_flag64(user, IAX_HASCALLERID);
13527 } else {
13528 ast_string_field_set(user, cid_num, "");
13529 if (ast_strlen_zero(user->cid_name))
13530 ast_clear_flag64(user, IAX_HASCALLERID);
13531 }
13532 } else if (!strcasecmp(v->name, "accountcode")) {
13533 ast_string_field_set(user, accountcode, v->value);
13534 } else if (!strcasecmp(v->name, "mohinterpret")) {
13535 ast_string_field_set(user, mohinterpret, v->value);
13536 } else if (!strcasecmp(v->name, "mohsuggest")) {
13537 ast_string_field_set(user, mohsuggest, v->value);
13538 } else if (!strcasecmp(v->name, "parkinglot")) {
13539 ast_string_field_set(user, parkinglot, v->value);
13540 } else if (!strcasecmp(v->name, "language")) {
13541 ast_string_field_set(user, language, v->value);
13542 } else if (!strcasecmp(v->name, "amaflags")) {
13543 format = ast_channel_string2amaflag(v->value);
13544 if (format < 0) {
13545 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
13546 } else {
13547 user->amaflags = format;
13548 }
13549 } else if (!strcasecmp(v->name, "inkeys")) {
13550 ast_string_field_set(user, inkeys, v->value);
13551 } else if (!strcasecmp(v->name, "maxauthreq")) {
13552 user->maxauthreq = atoi(v->value);
13553 if (user->maxauthreq < 0)
13554 user->maxauthreq = 0;
13555 } else if (!strcasecmp(v->name, "adsi")) {
13556 user->adsi = ast_true(v->value);
13557 } else if (!strcasecmp(v->name, "connectedline")) {
13558 if (ast_true(v->value)) {
13559 ast_set_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13560 } else if (!strcasecmp(v->value, "send")) {
13561 ast_clear_flag64(user, IAX_RECVCONNECTEDLINE);
13562 ast_set_flag64(user, IAX_SENDCONNECTEDLINE);
13563 } else if (!strcasecmp(v->value, "receive")) {
13564 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE);
13565 ast_set_flag64(user, IAX_RECVCONNECTEDLINE);
13566 } else {
13567 ast_clear_flag64(user, IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13568 }
13569 } else if (!strcasecmp(v->name, "requirecalltoken")) {
13570 /* default is required unless in optional ip list */
13571 if (ast_false(v->value)) {
13572 user->calltoken_required = CALLTOKEN_NO;
13573 } else if (!strcasecmp(v->value, "auto")) {
13574 user->calltoken_required = CALLTOKEN_AUTO;
13575 } else if (ast_true(v->value)) {
13576 user->calltoken_required = CALLTOKEN_YES;
13577 } else {
13578 ast_log(LOG_WARNING, "requirecalltoken must be set to a valid value. at line %d\n", v->lineno);
13579 }
13580 } /* else if (strcasecmp(v->name,"type")) */
13581 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
13582 v = v->next;
13583 if (!v) {
13584 v = alt;
13585 alt = NULL;
13586 }
13587 }
13588 if (!user->authmethods) {
13589 if (!ast_strlen_zero(user->secret)) {
13590 user->authmethods = IAX_AUTH_MD5;
13591 if (!ast_strlen_zero(user->inkeys))
13592 user->authmethods |= IAX_AUTH_RSA;
13593 } else if (!ast_strlen_zero(user->inkeys)) {
13594 user->authmethods = IAX_AUTH_RSA;
13595 } else {
13596 user->authmethods = IAX_AUTH_MD5;
13597 }
13598 }
13599 ast_clear_flag64(user, IAX_DELME);
13600 }
13601cleanup:
13602 if (oldacl) {
13603 ast_free_acl_list(oldacl);
13604 }
13605 if (oldcon) {
13606 free_context(oldcon);
13607 }
13608
13609 if (subscribe_acl_change) {
13610 acl_change_stasis_subscribe();
13611 }
13612
13613 return user;
13614}

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_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 14234 of file chan_iax2.c.

14235{
14236 struct ast_sockaddr addr;
14237 int x;
14238 int callno;
14239 struct iax_ie_data ied;
14240 struct create_addr_info cai;
14241 struct parsed_dial_string pds;
14242 char *tmpstr;
14243
14244 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
14245 /* Look for an *exact match* call. Once a call is negotiated, it can only
14246 look up entries for a single context */
14247 if (!ast_mutex_trylock(&iaxsl[x])) {
14248 if (iaxs[x] && !strcasecmp(data, iaxs[x]->dproot))
14249 return x;
14250 ast_mutex_unlock(&iaxsl[x]);
14251 }
14252 }
14253
14254 /* No match found, we need to create a new one */
14255
14256 memset(&cai, 0, sizeof(cai));
14257 memset(&ied, 0, sizeof(ied));
14258 memset(&pds, 0, sizeof(pds));
14259
14260 tmpstr = ast_strdupa(data);
14261 parse_dial_string(tmpstr, &pds);
14262
14263 if (ast_strlen_zero(pds.peer)) {
14264 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
14265 return -1;
14266 }
14267
14268 /* Populate our address from the given */
14269 if (create_addr(pds.peer, NULL, &addr, &cai))
14270 return -1;
14271
14272 ast_debug(1, "peer: %s, username: %s, password: %s, context: %s\n",
14273 pds.peer, pds.username, pds.password, pds.context);
14274
14275 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
14276 if (callno < 1) {
14277 ast_log(LOG_WARNING, "Unable to create call\n");
14278 return -1;
14279 }
14280
14281 ast_string_field_set(iaxs[callno], dproot, data);
14282 iaxs[callno]->capability = IAX_CAPABILITY_FULLBANDWIDTH;
14283
14284 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
14285 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, "TBD");
14286 /* the string format is slightly different from a standard dial string,
14287 because the context appears in the 'exten' position
14288 */
14289 if (pds.exten)
14290 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.exten);
14291 if (pds.username)
14292 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
14293 iax_ie_append_int(&ied, IAX_IE_FORMAT, IAX_CAPABILITY_FULLBANDWIDTH);
14294 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, IAX_CAPABILITY_FULLBANDWIDTH);
14295 /* Keep password handy */
14296 if (pds.password)
14297 ast_string_field_set(iaxs[callno], secret, pds.password);
14298 if (pds.key)
14299 ast_string_field_set(iaxs[callno], outkey, pds.key);
14300 /* Start the call going */
14301 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
14302 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
14303
14304 return callno;
14305}

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 6337 of file chan_iax2.c.

6338{
6339 /* Returns where in "receive time" we are. That is, how many ms
6340 since we received (or would have received) the frame with timestamp 0 */
6341 int ms;
6342#ifdef IAXTESTS
6343 int jit;
6344#endif /* IAXTESTS */
6345 /* Setup rxcore if necessary */
6346 if (ast_tvzero(p->rxcore)) {
6347 p->rxcore = ast_tvnow();
6348 if (iaxdebug)
6349 ast_debug(1, "calc_rxstamp: call=%d: rxcore set to %d.%6.6d - %ums\n",
6350 p->callno, (int)(p->rxcore.tv_sec), (int)(p->rxcore.tv_usec), offset);
6351 p->rxcore = ast_tvsub(p->rxcore, ast_samp2tv(offset, 1000));
6352#if 1
6353 if (iaxdebug)
6354 ast_debug(1, "calc_rxstamp: call=%d: works out as %d.%6.6d\n",
6355 p->callno, (int)(p->rxcore.tv_sec),(int)( p->rxcore.tv_usec));
6356#endif
6357 }
6358
6359 ms = ast_tvdiff_ms(ast_tvnow(), p->rxcore);
6360#ifdef IAXTESTS
6361 if (test_jit) {
6362 if (!test_jitpct || ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_jitpct)) {
6363 jit = (int)((float)test_jit * ast_random() / (RAND_MAX + 1.0));
6364 if ((int)(2.0 * ast_random() / (RAND_MAX + 1.0)))
6365 jit = -jit;
6366 ms += jit;
6367 }
6368 }
6369 if (test_late) {
6370 ms += test_late;
6371 test_late = 0;
6372 }
6373#endif /* IAXTESTS */
6374 return ms;
6375}

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 6202 of file chan_iax2.c.

6203{
6204 int ms;
6205 int voice = 0;
6206 int genuine = 0;
6207 int adjust;
6208 int rate = 0;
6209 struct timeval *delivery = NULL;
6210
6211
6212 /* What sort of frame do we have?: voice is self-explanatory
6213 "genuine" means an IAX frame - things like LAGRQ/RP, PING/PONG, ACK
6214 non-genuine frames are CONTROL frames [ringing etc], DTMF
6215 The "genuine" distinction is needed because genuine frames must get a clock-based timestamp,
6216 the others need a timestamp slaved to the voice frames so that they go in sequence
6217 */
6218 if (f->frametype == AST_FRAME_VOICE) {
6219 voice = 1;
6220 rate = ast_format_get_sample_rate(f->subclass.format) / 1000;
6221 delivery = &f->delivery;
6222 } else if (f->frametype == AST_FRAME_IAX) {
6223 genuine = 1;
6224 } else if (f->frametype == AST_FRAME_CNG) {
6225 p->notsilenttx = 0;
6226 }
6227
6228 if (ast_tvzero(p->offset)) {
6229 p->offset = ast_tvnow();
6230 /* Round to nearest 20ms for nice looking traces */
6231 p->offset.tv_usec -= p->offset.tv_usec % 20000;
6232 }
6233 /* If the timestamp is specified, just send it as is */
6234 if (ts)
6235 return ts;
6236 /* If we have a time that the frame arrived, always use it to make our timestamp */
6237 if (delivery && !ast_tvzero(*delivery)) {
6238 ms = ast_tvdiff_ms(*delivery, p->offset);
6239 if (ms < 0) {
6240 ms = 0;
6241 }
6242 if (iaxdebug)
6243 ast_debug(3, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
6244 } else {
6245 ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
6246 if (ms < 0)
6247 ms = 0;
6248 if (voice) {
6249 /* On a voice frame, use predicted values if appropriate */
6250 adjust = (ms - p->nextpred);
6251 if (p->notsilenttx && abs(adjust) <= MAX_TIMESTAMP_SKEW) {
6252 /* Adjust our txcore, keeping voice and non-voice synchronized */
6253 /* AN EXPLANATION:
6254 When we send voice, we usually send "calculated" timestamps worked out
6255 on the basis of the number of samples sent. When we send other frames,
6256 we usually send timestamps worked out from the real clock.
6257 The problem is that they can tend to drift out of step because the
6258 source channel's clock and our clock may not be exactly at the same rate.
6259 We fix this by continuously "tweaking" p->offset. p->offset is "time zero"
6260 for this call. Moving it adjusts timestamps for non-voice frames.
6261 We make the adjustment in the style of a moving average. Each time we
6262 adjust p->offset by 10% of the difference between our clock-derived
6263 timestamp and the predicted timestamp. That's why you see "10000"
6264 below even though IAX2 timestamps are in milliseconds.
6265 The use of a moving average avoids offset moving too radically.
6266 Generally, "adjust" roams back and forth around 0, with offset hardly
6267 changing at all. But if a consistent different starts to develop it
6268 will be eliminated over the course of 10 frames (200-300msecs)
6269 */
6270 if (adjust < 0)
6271 p->offset = ast_tvsub(p->offset, ast_samp2tv(abs(adjust), 10000));
6272 else if (adjust > 0)
6273 p->offset = ast_tvadd(p->offset, ast_samp2tv(adjust, 10000));
6274
6275 if (!p->nextpred) {
6276 p->nextpred = ms; /*f->samples / rate;*/
6277 if (p->nextpred <= p->lastsent)
6278 p->nextpred = p->lastsent + 3;
6279 }
6280 ms = p->nextpred;
6281 } else {
6282 /* in this case, just use the actual
6283 * time, since we're either way off
6284 * (shouldn't happen), or we're ending a
6285 * silent period -- and seed the next
6286 * predicted time. Also, round ms to the
6287 * next multiple of frame size (so our
6288 * silent periods are multiples of
6289 * frame size too) */
6290
6291 if (iaxdebug && abs(adjust) > MAX_TIMESTAMP_SKEW )
6292 ast_debug(1, "predicted timestamp skew (%d) > max (%d), using real ts instead.\n",
6293 abs(adjust), MAX_TIMESTAMP_SKEW);
6294
6295 if (f->samples >= rate) /* check to make sure we don't core dump */
6296 {
6297 int diff = ms % (f->samples / rate);
6298 if (diff)
6299 ms += f->samples/rate - diff;
6300 }
6301
6302 p->nextpred = ms;
6303 p->notsilenttx = 1;
6304 }
6305 } else if ( f->frametype == AST_FRAME_VIDEO ) {
6306 /*
6307 * IAX2 draft 03 says that timestamps MUST be in order.
6308 * It does not say anything about several frames having the same timestamp
6309 * When transporting video, we can have a frame that spans multiple iax packets
6310 * (so called slices), so it would make sense to use the same timestamp for all of
6311 * them
6312 * We do want to make sure that frames don't go backwards though
6313 */
6314 if ( (unsigned int)ms < p->lastsent )
6315 ms = p->lastsent;
6316 } else {
6317 /* On a dataframe, use last value + 3 (to accommodate jitter buffer shrinking) if appropriate unless
6318 it's a genuine frame */
6319 adjust = (ms - p->lastsent);
6320 if (genuine) {
6321 /* genuine (IAX LAGRQ etc) must keep their clock-based stamps */
6322 if (ms <= p->lastsent)
6323 ms = p->lastsent + 3;
6324 } else if (abs(adjust) <= MAX_TIMESTAMP_SKEW) {
6325 /* non-genuine frames (!?) (DTMF, CONTROL) should be pulled into the predicted stream stamps */
6326 ms = p->lastsent + 3;
6327 }
6328 }
6329 }
6330 p->lastsent = ms;
6331 if (voice) {
6332 p->nextpred = p->nextpred + f->samples / rate;
6333 }
6334 return ms;
6335}

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 6158 of file chan_iax2.c.

6159{
6160 unsigned long int mssincetx; /* unsigned to handle overflows */
6161 long int ms, pred;
6162
6163 tpeer->trunkact = *now;
6164 mssincetx = ast_tvdiff_ms(*now, tpeer->lasttxtime);
6165 if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
6166 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
6167 tpeer->txtrunktime = *now;
6168 tpeer->lastsent = 999999;
6169 }
6170 /* Update last transmit time now */
6171 tpeer->lasttxtime = *now;
6172
6173 /* Calculate ms offset */
6174 ms = ast_tvdiff_ms(*now, tpeer->txtrunktime);
6175 /* Predict from last value */
6176 pred = tpeer->lastsent + sampms;
6177 if (labs(ms - pred) < MAX_TIMESTAMP_SKEW)
6178 ms = pred;
6179
6180 /* We never send the same timestamp twice, so fudge a little if we must */
6181 if (ms == tpeer->lastsent)
6182 ms = tpeer->lastsent + 1;
6183 tpeer->lastsent = ms;
6184 return ms;
6185}

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 2580 of file chan_iax2.c.

2581{
2582 struct addr_range *addr_range;
2583 struct iax2_peer *peer = NULL;
2584 struct iax2_user *user = NULL;
2585 /* if no username is given, check for guest accounts */
2586 const char *find = S_OR(name, "guest");
2587 int res = 1; /* required by default */
2588 int optional = 0;
2589 enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2590 /* There are only two cases in which calltoken validation is not required.
2591 * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2592 * the peer definition has not set the requirecalltoken option.
2593 * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2594 */
2595
2596 /* ----- Case 1 ----- */
2597 if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, addr))) {
2598 ao2_ref(addr_range, -1);
2599 optional = 1;
2600 }
2601
2602 /* ----- Case 2 ----- */
2603 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2604 calltoken_required = user->calltoken_required;
2605 } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, addr))) {
2606 calltoken_required = user->calltoken_required;
2607 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2608 calltoken_required = peer->calltoken_required;
2609 } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, addr))) {
2610 calltoken_required = peer->calltoken_required;
2611 }
2612
2613 if (peer) {
2614 peer_unref(peer);
2615 }
2616 if (user) {
2617 user_unref(user);
2618 }
2619
2620 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);
2621 if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2622 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2623 res = 0;
2624 }
2625
2626 return res;
2627}

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 7940 of file chan_iax2.c.

7941{
7942 /* Start pessimistic */
7943 int res = -1;
7944 int version = 2;
7945 struct iax2_user *user = NULL, *best = NULL;
7946 int bestscore = 0;
7947 int gotcapability = 0;
7948 struct ast_variable *v = NULL, *tmpvar = NULL;
7949 struct ao2_iterator i;
7950
7951 if (!iaxs[callno])
7952 return res;
7953 if (ies->called_number)
7954 ast_string_field_set(iaxs[callno], exten, ies->called_number);
7955 if (ies->calling_number) {
7956 if (ast_test_flag64(&globalflags, IAX_SHRINKCALLERID)) {
7957 ast_shrink_phone_number(ies->calling_number);
7958 }
7959 ast_string_field_set(iaxs[callno], cid_num, ies->calling_number);
7960 }
7961 if (ies->calling_name)
7962 ast_string_field_set(iaxs[callno], cid_name, ies->calling_name);
7963 if (ies->calling_ani)
7964 ast_string_field_set(iaxs[callno], ani, ies->calling_ani);
7965 if (ies->dnid)
7966 ast_string_field_set(iaxs[callno], dnid, ies->dnid);
7967 if (ies->rdnis)
7968 ast_string_field_set(iaxs[callno], rdnis, ies->rdnis);
7969 if (ies->called_context)
7970 ast_string_field_set(iaxs[callno], context, ies->called_context);
7971 if (ies->language)
7972 ast_string_field_set(iaxs[callno], language, ies->language);
7973 if (ies->username)
7974 ast_string_field_set(iaxs[callno], username, ies->username);
7975 if (ies->calling_ton > -1)
7976 iaxs[callno]->calling_ton = ies->calling_ton;
7977 if (ies->calling_tns > -1)
7978 iaxs[callno]->calling_tns = ies->calling_tns;
7979 if (ies->calling_pres > -1)
7980 iaxs[callno]->calling_pres = ies->calling_pres;
7981 if (ies->calling_ani2 > -1)
7982 iaxs[callno]->calling_ani2 = ies->calling_ani2;
7983 if (ies->format)
7984 iaxs[callno]->peerformat = ies->format;
7985 if (ies->adsicpe)
7986 iaxs[callno]->peeradsicpe = ies->adsicpe;
7987 if (ies->capability) {
7988 gotcapability = 1;
7989 iaxs[callno]->peercapability = ies->capability;
7990 }
7991 if (ies->version)
7992 version = ies->version;
7993
7994 /* Use provided preferences until told otherwise for actual preferences */
7995 if (ies->codec_prefs) {
7996 iax2_codec_pref_convert(&iaxs[callno]->rprefs, ies->codec_prefs, 32, 0);
7997 } else {
7998 memset(&iaxs[callno]->rprefs, 0, sizeof(iaxs[callno]->rprefs));
7999 }
8000 iaxs[callno]->prefs = iaxs[callno]->rprefs;
8001
8002 if (!gotcapability) {
8003 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
8004 }
8005 if (version > IAX_PROTO_VERSION) {
8006 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
8007 ast_sockaddr_stringify_addr(addr), version);
8008 return res;
8009 }
8010 /* Search the userlist for a compatible entry, and fill in the rest */
8011 i = ao2_iterator_init(users, 0);
8012 while ((user = ao2_iterator_next(&i))) {
8013 if ((ast_strlen_zero(iaxs[callno]->username) || /* No username specified */
8014 !strcmp(iaxs[callno]->username, user->name)) /* Or this username specified */
8015 && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_ALLOW) /* Access is permitted from this IP */
8016 && (ast_strlen_zero(iaxs[callno]->context) || /* No context specified */
8017 apply_context(user->contexts, iaxs[callno]->context))) { /* Context is permitted */
8018 if (!ast_strlen_zero(iaxs[callno]->username)) {
8019 /* Exact match, stop right now. */
8020 if (best)
8021 user_unref(best);
8022 best = user;
8023 break;
8024 } else if (ast_strlen_zero(user->secret) && ast_strlen_zero(user->dbsecret) && ast_strlen_zero(user->inkeys)) {
8025 /* No required authentication */
8026 if (user->acl) {
8027 /* There was host authentication and we passed, bonus! */
8028 if (bestscore < 4) {
8029 bestscore = 4;
8030 if (best)
8031 user_unref(best);
8032 best = user;
8033 continue;
8034 }
8035 } else {
8036 /* No host access, but no secret, either, not bad */
8037 if (bestscore < 3) {
8038 bestscore = 3;
8039 if (best)
8040 user_unref(best);
8041 best = user;
8042 continue;
8043 }
8044 }
8045 } else {
8046 if (user->acl) {
8047 /* Authentication, but host access too, eh, it's something.. */
8048 if (bestscore < 2) {
8049 bestscore = 2;
8050 if (best)
8051 user_unref(best);
8052 best = user;
8053 continue;
8054 }
8055 } else {
8056 /* Authentication and no host access... This is our baseline */
8057 if (bestscore < 1) {
8058 bestscore = 1;
8059 if (best)
8060 user_unref(best);
8061 best = user;
8062 continue;
8063 }
8064 }
8065 }
8066 }
8067 user_unref(user);
8068 }
8069 ao2_iterator_destroy(&i);
8070 user = best;
8071 if (!user && !ast_strlen_zero(iaxs[callno]->username)) {
8072 user = realtime_user(iaxs[callno]->username, addr);
8073 if (user && (ast_apply_acl(user->acl, addr, "IAX2 user ACL: ") == AST_SENSE_DENY /* Access is denied from this IP */
8074 || (!ast_strlen_zero(iaxs[callno]->context) && /* No context specified */
8075 !apply_context(user->contexts, iaxs[callno]->context)))) { /* Context is permitted */
8076 user = user_unref(user);
8077 }
8078 }
8079 if (user) {
8080 /* We found our match (use the first) */
8081 /* copy vars */
8082 for (v = user->vars ; v ; v = v->next) {
8083 if ((tmpvar = ast_variable_new(v->name, v->value, v->file))) {
8084 if (ast_variable_list_replace(&iaxs[callno]->vars, tmpvar)) {
8085 tmpvar->next = iaxs[callno]->vars;
8086 iaxs[callno]->vars = tmpvar;
8087 }
8088 }
8089 }
8090 /* If a max AUTHREQ restriction is in place, activate it */
8091 if (user->maxauthreq > 0)
8092 ast_set_flag64(iaxs[callno], IAX_MAXAUTHREQ);
8093 iaxs[callno]->prefs = user->prefs;
8094 ast_copy_flags64(iaxs[callno], user, IAX_CODEC_USER_FIRST | IAX_IMMEDIATE | IAX_CODEC_NOPREFS | IAX_CODEC_NOCAP | IAX_FORCE_ENCRYPT);
8095 iaxs[callno]->encmethods = user->encmethods;
8096 /* Store the requested username if not specified */
8097 if (ast_strlen_zero(iaxs[callno]->username))
8098 ast_string_field_set(iaxs[callno], username, user->name);
8099 /* Store whether this is a trunked call, too, of course, and move if appropriate */
8100 ast_copy_flags64(iaxs[callno], user, IAX_TRUNK);
8101 iaxs[callno]->capability = user->capability;
8102 /* And use the default context */
8103 if (ast_strlen_zero(iaxs[callno]->context)) {
8104 if (user->contexts)
8105 ast_string_field_set(iaxs[callno], context, user->contexts->context);
8106 else
8107 ast_string_field_set(iaxs[callno], context, DEFAULT_CONTEXT);
8108 }
8109 /* And any input keys */
8110 ast_string_field_set(iaxs[callno], inkeys, user->inkeys);
8111 /* And the permitted authentication methods */
8112 iaxs[callno]->authmethods = user->authmethods;
8113 iaxs[callno]->adsi = user->adsi;
8114 /* If the user has callerid, override the remote caller id. */
8115 if (ast_test_flag64(user, IAX_HASCALLERID)) {
8116 iaxs[callno]->calling_tns = 0;
8117 iaxs[callno]->calling_ton = 0;
8118 ast_string_field_set(iaxs[callno], cid_num, user->cid_num);
8119 ast_string_field_set(iaxs[callno], cid_name, user->cid_name);
8120 ast_string_field_set(iaxs[callno], ani, user->cid_num);
8121 iaxs[callno]->calling_pres = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
8122 } else if (ast_strlen_zero(iaxs[callno]->cid_num) && ast_strlen_zero(iaxs[callno]->cid_name)) {
8123 iaxs[callno]->calling_pres = AST_PRES_NUMBER_NOT_AVAILABLE;
8124 } /* else user is allowed to set their own CID settings */
8125 if (!ast_strlen_zero(user->accountcode))
8126 ast_string_field_set(iaxs[callno], accountcode, user->accountcode);
8127 if (!ast_strlen_zero(user->mohinterpret))
8128 ast_string_field_set(iaxs[callno], mohinterpret, user->mohinterpret);
8129 if (!ast_strlen_zero(user->mohsuggest))
8130 ast_string_field_set(iaxs[callno], mohsuggest, user->mohsuggest);
8131 if (!ast_strlen_zero(user->parkinglot))
8132 ast_string_field_set(iaxs[callno], parkinglot, user->parkinglot);
8133 if (user->amaflags)
8134 iaxs[callno]->amaflags = user->amaflags;
8135 if (!ast_strlen_zero(user->language))
8136 ast_string_field_set(iaxs[callno], language, user->language);
8137 ast_copy_flags64(iaxs[callno], user, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
8138 /* Keep this check last */
8139 if (!ast_strlen_zero(user->dbsecret)) {
8140 char *family, *key=NULL;
8141 char buf[80];
8142 family = ast_strdupa(user->dbsecret);
8143 key = strchr(family, '/');
8144 if (key) {
8145 *key = '\0';
8146 key++;
8147 }
8148 if (!key || ast_db_get(family, key, buf, sizeof(buf)))
8149 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", user->dbsecret);
8150 else
8151 ast_string_field_set(iaxs[callno], secret, buf);
8152 } else
8153 ast_string_field_set(iaxs[callno], secret, user->secret);
8154 res = 0;
8155 user = user_unref(user);
8156 } else {
8157 /* user was not found, but we should still fake an AUTHREQ.
8158 * Set authmethods to the last known authmethod used by the system
8159 * Set a fake secret, it's not looked at, just required to attempt authentication.
8160 * Set authrej so the AUTHREP is rejected without even looking at its contents */
8161 iaxs[callno]->authmethods = last_authmethod ? last_authmethod : IAX_AUTH_MD5;
8162 ast_string_field_set(iaxs[callno], secret, "badsecret");
8163 iaxs[callno]->authrej = 1;
8164 if (!ast_strlen_zero(iaxs[callno]->username)) {
8165 /* only send the AUTHREQ if a username was specified. */
8166 res = 0;
8167 }
8168 }
8169 ast_set2_flag64(iaxs[callno], iax2_getpeertrunk(*addr), IAX_TRUNK);
8170 return res;
8171}

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, 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_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 9794 of file chan_iax2.c.

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

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
0address available
1address unavailable
-1error

Definition at line 12920 of file chan_iax2.c.

12921{
12922 int sd;
12923
12924 sd = socket(addr->ss.ss_family, SOCK_DGRAM, 0);
12925 if (sd < 0) {
12926 ast_log(LOG_ERROR, "Socket: %s\n", strerror(errno));
12927 return -1;
12928 }
12929
12930 if (ast_bind(sd, addr) < 0) {
12931 ast_debug(1, "Can't bind: %s\n", strerror(errno));
12932 close(sd);
12933 return 1;
12934 }
12935
12936 close(sd);
12937 return 0;
12938}

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 14745 of file chan_iax2.c.

14746{
14747 AST_LIST_HEAD(iax2_thread_list, iax2_thread);
14748 struct iax2_thread_list *list_head = head;
14749 struct iax2_thread *thread;
14750
14751 AST_LIST_LOCK(list_head);
14752 while ((thread = AST_LIST_REMOVE_HEAD(list_head, list))) {
14753 pthread_t thread_id = thread->threadid;
14754
14755 thread->stop = 1;
14756 signal_condition(&thread->lock, &thread->cond);
14757
14758 AST_LIST_UNLOCK(list_head);
14759 pthread_join(thread_id, NULL);
14760 AST_LIST_LOCK(list_head);
14761 }
14762 AST_LIST_UNLOCK(list_head);
14763}

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 1933 of file chan_iax2.c.

1934{
1935 int x;
1936 struct ast_format *found_format = NULL;
1937
1938 for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
1939 struct ast_format *pref_format;
1940 uint64_t pref_bitfield;
1941
1942 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
1943 if (!pref_bitfield) {
1944 break;
1945 }
1946
1947 pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
1948 if (!pref_format) {
1949 /* The bitfield is not associated with any format. */
1950 continue;
1951 }
1952 found_format = ast_format_cap_get_compatible_format(cap, pref_format);
1953 if (found_format) {
1954 break;
1955 }
1956 }
1957
1958 if (found_format && (ast_format_get_type(found_format) == AST_MEDIA_TYPE_AUDIO)) {
1959 return found_format;
1960 }
1961
1962 ast_debug(4, "Could not find preferred codec - Returning zero codec.\n");
1963 ao2_cleanup(found_format);
1964 return NULL;
1965}

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 8797 of file chan_iax2.c.

8798{
8799 char exten[256] = "";
8800 int status = CACHE_FLAG_UNKNOWN, expiry = iaxdefaultdpcache, x, matchmore = 0;
8801 struct iax2_dpcache *dp = NULL;
8802
8803 if (ies->called_number)
8804 ast_copy_string(exten, ies->called_number, sizeof(exten));
8805
8806 if (ies->dpstatus & IAX_DPSTATUS_EXISTS)
8807 status = CACHE_FLAG_EXISTS;
8808 else if (ies->dpstatus & IAX_DPSTATUS_CANEXIST)
8809 status = CACHE_FLAG_CANEXIST;
8810 else if (ies->dpstatus & IAX_DPSTATUS_NONEXISTENT)
8811 status = CACHE_FLAG_NONEXISTENT;
8812
8813 if (ies->refresh)
8814 expiry = ies->refresh;
8815 if (ies->dpstatus & IAX_DPSTATUS_MATCHMORE)
8816 matchmore = CACHE_FLAG_MATCHMORE;
8817
8818 AST_LIST_LOCK(&dpcache);
8819 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, peer_list) {
8820 if (strcmp(dp->exten, exten))
8821 continue;
8822 AST_LIST_REMOVE_CURRENT(peer_list);
8823 dp->callno = 0;
8824 dp->expiry.tv_sec = dp->orig.tv_sec + expiry;
8825 if (dp->flags & CACHE_FLAG_PENDING) {
8826 dp->flags &= ~CACHE_FLAG_PENDING;
8827 dp->flags |= status;
8828 dp->flags |= matchmore;
8829 }
8830 /* Wake up waiters */
8831 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
8832 if (dp->waiters[x] > -1) {
8833 if (write(dp->waiters[x], "asdf", 4) < 0) {
8834 }
8835 }
8836 }
8837 }
8838 AST_LIST_TRAVERSE_SAFE_END;
8839 AST_LIST_UNLOCK(&dpcache);
8840
8841 return 0;
8842}

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 3977 of file chan_iax2.c.

3978{
3979 int which = 0;
3980 struct iax2_peer *peer;
3981 char *res = NULL;
3982 int wordlen = strlen(word);
3983 struct ao2_iterator i;
3984
3985 i = ao2_iterator_init(peers, 0);
3986 while ((peer = ao2_iterator_next(&i))) {
3987 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
3988 && (!flags || ast_test_flag64(peer, flags))) {
3989 res = ast_strdup(peer->name);
3990 peer_unref(peer);
3991 break;
3992 }
3993 peer_unref(peer);
3994 }
3995 ao2_iterator_destroy(&i);
3996
3997 return res;
3998}

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 7301 of file chan_iax2.c.

7302{
7303 int which = 0;
7304 struct iax2_peer *p = NULL;
7305 char *res = NULL;
7306 int wordlen = strlen(word);
7307
7308 /* 0 - iax2; 1 - unregister; 2 - <peername> */
7309 if (pos == 2) {
7310 struct ao2_iterator i = ao2_iterator_init(peers, 0);
7311 while ((p = ao2_iterator_next(&i))) {
7312 if (!strncasecmp(p->name, word, wordlen) &&
7313 ++which > state && p->expire > -1) {
7314 res = ast_strdup(p->name);
7315 peer_unref(p);
7316 break;
7317 }
7318 peer_unref(p);
7319 }
7320 ao2_iterator_destroy(&i);
7321 }
7322
7323 return res;
7324}

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 8844 of file chan_iax2.c.

8845{
8846 int peercallno = 0;
8847 struct chan_iax2_pvt *pvt = iaxs[callno];
8848 struct iax_frame *cur;
8849 jb_frame frame;
8850
8851 if (ies->callno)
8852 peercallno = ies->callno;
8853
8854 if (peercallno < 1) {
8855 ast_log(LOG_WARNING, "Invalid transfer request\n");
8856 return -1;
8857 }
8858 remove_by_transfercallno(pvt);
8859 /* since a transfer has taken place, the address will change.
8860 * This must be accounted for in the peercnts table. Remove
8861 * the old address and add the new one */
8862 peercnt_remove_by_addr(&pvt->addr);
8863 peercnt_add(&pvt->transfer);
8864 /* now copy over the new address */
8865 memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
8866 memset(&pvt->transfer, 0, sizeof(pvt->transfer));
8867 /* Reset sequence numbers */
8868 pvt->oseqno = 0;
8869 pvt->rseqno = 0;
8870 pvt->iseqno = 0;
8871 pvt->aseqno = 0;
8872
8873 if (pvt->peercallno) {
8874 remove_by_peercallno(pvt);
8875 }
8876 pvt->peercallno = peercallno;
8877 /*this is where the transferring call switches hash tables */
8878 store_by_peercallno(pvt);
8879 pvt->transferring = TRANSFER_NONE;
8880 pvt->svoiceformat = -1;
8881 pvt->voiceformat = 0;
8882 pvt->svideoformat = -1;
8883 pvt->videoformat = 0;
8884 pvt->transfercallno = 0;
8885 memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
8886 memset(&pvt->offset, 0, sizeof(pvt->offset));
8887 /* reset jitterbuffer */
8888 while(jb_getall(pvt->jb,&frame) == JB_OK)
8889 iax2_frame_free(frame.data);
8890 jb_reset(pvt->jb);
8891 pvt->lag = 0;
8892 pvt->last = 0;
8893 pvt->lastsent = 0;
8894 pvt->nextpred = 0;
8895 pvt->pingtime = DEFAULT_RETRY_TIME;
8896 AST_LIST_TRAVERSE(&frame_queue[callno], cur, list) {
8897 /* We must cancel any packets that would have been transmitted
8898 because now we're talking to someone new. It's okay, they
8899 were transmitted to someone that didn't care anyway. */
8900 cur->retries = -1;
8901 }
8902 return 0;
8903}

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 1899 of file chan_iax2.c.

1900{
1901 int x;
1902 int power=-1;
1903 /* If it's 64 or smaller, just return it */
1904 if (subclass < IAX_FLAG_SC_LOG)
1905 return subclass;
1906 /* Otherwise find its power */
1907 for (x = 0; x < IAX_MAX_SHIFT; x++) {
1908 if (subclass & (1LL << x)) {
1909 if (power > -1) {
1910 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
1911 return 0;
1912 } else
1913 power = x;
1914 }
1915 }
1916 return power | IAX_FLAG_SC_LOG;
1917}

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 9807 of file chan_iax2.c.

9808{
9809 jb_info stats;
9810 jb_getinfo(pvt->jb, &stats);
9811
9812 memset(iep, 0, sizeof(*iep));
9813
9814 iax_ie_append_int(iep,IAX_IE_RR_JITTER, stats.jitter);
9815 if(stats.frames_in == 0) stats.frames_in = 1;
9816 iax_ie_append_int(iep,IAX_IE_RR_LOSS, ((0xff & (stats.losspct/1000)) << 24 | (stats.frames_lost & 0x00ffffff)));
9817 iax_ie_append_int(iep,IAX_IE_RR_PKTS, stats.frames_in);
9818 iax_ie_append_short(iep,IAX_IE_RR_DELAY, stats.current - stats.min);
9819 iax_ie_append_int(iep,IAX_IE_RR_DROPPED, stats.frames_dropped);
9820 iax_ie_append_int(iep,IAX_IE_RR_OOO, stats.frames_ooo);
9821}

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 4719 of file chan_iax2.c.

4720{
4721 struct iax2_peer *peer;
4722 int res = -1;
4723
4724 ast_clear_flag64(cai, IAX_SENDANI | IAX_TRUNK);
4725 cai->sockfd = defaultsockfd;
4726 cai->maxtime = 0;
4727
4728 if (!(peer = find_peer(peername, 1))) {
4729 struct ast_sockaddr peer_addr;
4730
4731 peer_addr.ss.ss_family = AST_AF_UNSPEC;
4732 cai->found = 0;
4733 if (ast_get_ip_or_srv(&peer_addr, peername, srvlookup ? "_iax._udp" : NULL)) {
4734 ast_log(LOG_WARNING, "No such host: %s\n", peername);
4735 return -1;
4736 }
4737
4738 if (!ast_sockaddr_port(&peer_addr)) {
4739 ast_sockaddr_set_port(&peer_addr, IAX_DEFAULT_PORTNO);
4740 }
4741
4742 ast_sockaddr_copy(addr, &peer_addr);
4743 /*
4744 * Use The global iax prefs for unknown peer/user.
4745 * However, move the calling channel's native codec to
4746 * the top of the preference list.
4747 */
4748 cai->prefs = prefs_global;
4749 if (c) {
4750 int i;
4751
4752 for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
4753 struct ast_format *format = ast_format_cap_get_format(
4754 ast_channel_nativeformats(c), i);
4755 iax2_codec_pref_prepend(&cai->prefs, format,
4756 ast_format_cap_get_format_framing(ast_channel_nativeformats(c), format),
4757 1);
4758 ao2_ref(format, -1);
4759 }
4760 }
4761 return 0;
4762 }
4763
4764 cai->found = 1;
4765
4766 /* if the peer has no address (current or default), return failure */
4767 if (ast_sockaddr_isnull(&peer->addr) && ast_sockaddr_isnull(&peer->defaddr)) {
4768 goto return_unref;
4769 }
4770
4771 /* if the peer is being monitored and is currently unreachable, return failure */
4772 if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
4773 goto return_unref;
4774
4775 ast_copy_flags64(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
4776 cai->maxtime = peer->maxms;
4777 cai->capability = peer->capability;
4778 cai->encmethods = peer->encmethods;
4779 cai->authmethods = peer->authmethods;
4780 cai->sockfd = peer->sockfd;
4781 cai->adsi = peer->adsi;
4782 cai->prefs = peer->prefs;
4783 /* Move the calling channel's native codec to the top of the preference list */
4784 if (c) {
4785 int i;
4786
4787 for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
4788 struct ast_format *tmpfmt = ast_format_cap_get_format(
4789 ast_channel_nativeformats(c), i);
4790 iax2_codec_pref_prepend(&cai->prefs, tmpfmt,
4791 ast_format_cap_get_format_framing(ast_channel_nativeformats(c), tmpfmt),
4792 1);
4793 ao2_ref(tmpfmt, -1);
4794 }
4795 }
4796 ast_copy_string(cai->context, peer->context, sizeof(cai->context));
4797 ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
4798 ast_copy_string(cai->username, peer->username, sizeof(cai->username));
4799 ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
4800 ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
4801 ast_copy_string(cai->cid_num, peer->cid_num, sizeof(cai->cid_num));
4802 ast_copy_string(cai->cid_name, peer->cid_name, sizeof(cai->cid_name));
4803 ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
4804 ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
4805 if (ast_strlen_zero(peer->dbsecret)) {
4806 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
4807 } else {
4808 char *family;
4809 char *key = NULL;
4810
4811 family = ast_strdupa(peer->dbsecret);
4812 key = strchr(family, '/');
4813 if (key)
4814 *key++ = '\0';
4815 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
4816 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
4817 goto return_unref;
4818 }
4819 }
4820
4821 if (!ast_sockaddr_isnull(&peer->addr)) {
4822 ast_sockaddr_copy(addr, &peer->addr);
4823 } else {
4824 ast_sockaddr_copy(addr, &peer->defaddr);
4825 }
4826
4827 res = 0;
4828
4829return_unref:
4830 peer_unref(peer);
4831
4832 return res;
4833}

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 3107 of file chan_iax2.c.

3108{
3109 uint16_t i;
3110
3111 callno_pool.available = callno_pool_trunk.available = 0;
3112
3113 /* We start at 2. 0 and 1 are reserved. */
3114 for (i = 2; i < TRUNK_CALL_START; i++) {
3115 callno_pool.numbers[callno_pool.available] = i;
3116 callno_pool.available++;
3117 }
3118
3119 for (i = TRUNK_CALL_START; i < IAX_MAX_CALLS; i++) {
3120 callno_pool_trunk.numbers[callno_pool_trunk.available] = i;
3121 callno_pool_trunk.available++;
3122 }
3123
3124 callno_pool.capacity = callno_pool.available;
3125 callno_pool_trunk.capacity = callno_pool_trunk.available;
3126
3127 ast_assert(callno_pool.capacity && callno_pool_trunk.capacity);
3128
3129 return 0;
3130}

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 6576 of file chan_iax2.c.

6577{
6578 int padding;
6579 unsigned char *workspace;
6580
6581 workspace = ast_alloca(*datalen);
6582 memset(f, 0, sizeof(*f));
6583 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
6584 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
6585 if (*datalen < 16 + sizeof(struct ast_iax2_full_hdr))
6586 return -1;
6587 /* Decrypt */
6588 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr), dcx);
6589
6590 padding = 16 + (workspace[15] & 0x0f);
6591 if (iaxdebug)
6592 ast_debug(1, "Decoding full frame with length %d (padding = %d) (15=%02hhx)\n", *datalen, padding, workspace[15]);
6593 if (*datalen < padding + sizeof(struct ast_iax2_full_hdr))
6594 return -1;
6595
6596 *datalen -= padding;
6597 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
6598 f->frametype = fh->type;
6599 if (f->frametype == AST_FRAME_VIDEO) {
6600 f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1));
6601 if (!f->subclass.format) {
6602 f->subclass.format = ast_format_none;
6603 }
6604 } else if (f->frametype == AST_FRAME_VOICE) {
6605 f->subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
6606 if (!f->subclass.format) {
6607 f->subclass.format = ast_format_none;
6608 }
6609 } else {
6610 f->subclass.integer = uncompress_subclass(fh->csub);
6611 }
6612 } else {
6613 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
6614 if (iaxdebug)
6615 ast_debug(5, "Decoding mini with length %d\n", *datalen);
6616 if (*datalen < 16 + sizeof(struct ast_iax2_mini_hdr))
6617 return -1;
6618 /* Decrypt */
6619 memcpy_decrypt(workspace, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), dcx);
6620 padding = 16 + (workspace[15] & 0x0f);
6621 if (*datalen < padding + sizeof(struct ast_iax2_mini_hdr))
6622 return -1;
6623 *datalen -= padding;
6624 memcpy(efh->encdata, workspace + padding, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
6625 }
6626 return 0;
6627}

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 6668 of file chan_iax2.c.

6669{
6670 int res=-1;
6671 if (!ast_test_flag64(iaxs[callno], IAX_KEYPOPULATED)) {
6672 /* Search for possible keys, given secrets */
6673 struct MD5Context md5;
6674 unsigned char digest[16];
6675 char *tmppw, *stringp;
6676
6677 tmppw = ast_strdupa(iaxs[callno]->secret);
6678 stringp = tmppw;
6679 while ((tmppw = strsep(&stringp, ";"))) {
6680 MD5Init(&md5);
6681 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
6682 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
6683 MD5Final(digest, &md5);
6684 build_encryption_keys(digest, iaxs[callno]);
6685 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
6686 if (!res) {
6687 ast_set_flag64(iaxs[callno], IAX_KEYPOPULATED);
6688 break;
6689 }
6690 }
6691 } else
6692 res = decode_frame(&iaxs[callno]->dcx, fh, f, datalen);
6693 return res;
6694}

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 9937 of file chan_iax2.c.

9938{
9939 struct iax2_pkt_buf *pkt_buf, *cur_pkt_buf;
9940 struct ast_iax2_full_hdr *fh, *cur_fh;
9941
9942 if (!(pkt_buf = ast_calloc(1, sizeof(*pkt_buf) + from_here->buf_len)))
9943 return;
9944
9945 pkt_buf->len = from_here->buf_len;
9946 memcpy(pkt_buf->buf, from_here->buf, pkt_buf->len);
9947
9948 fh = (struct ast_iax2_full_hdr *) pkt_buf->buf;
9949 ast_mutex_lock(&to_here->lock);
9950 AST_LIST_TRAVERSE_SAFE_BEGIN(&to_here->full_frames, cur_pkt_buf, entry) {
9951 cur_fh = (struct ast_iax2_full_hdr *) cur_pkt_buf->buf;
9952 if (fh->oseqno < cur_fh->oseqno) {
9953 AST_LIST_INSERT_BEFORE_CURRENT(pkt_buf, entry);
9954 break;
9955 }
9956 }
9957 AST_LIST_TRAVERSE_SAFE_END
9958
9959 if (!cur_pkt_buf)
9960 AST_LIST_INSERT_TAIL(&to_here->full_frames, pkt_buf, entry);
9961
9962 to_here->iostate = IAX_IOSTATE_READY;
9963 ast_cond_signal(&to_here->cond);
9964
9965 ast_mutex_unlock(&to_here->lock);
9966}

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, 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 13634 of file chan_iax2.c.

13635{
13636 struct iax2_registry *reg;
13637
13638 ao2_callback(users, OBJ_NODATA, user_delme_cb, NULL);
13639
13640 AST_LIST_LOCK(&registrations);
13641 while ((reg = AST_LIST_REMOVE_HEAD(&registrations, entry))) {
13642 if (sched) {
13643 AST_SCHED_DEL(sched, reg->expire);
13644 }
13645 if (reg->callno) {
13646 int callno = reg->callno;
13647 ast_mutex_lock(&iaxsl[callno]);
13648 if (iaxs[callno]) {
13649 iaxs[callno]->reg = NULL;
13650 iax2_destroy(callno);
13651 }
13652 ast_mutex_unlock(&iaxsl[callno]);
13653 }
13654 if (reg->dnsmgr)
13655 ast_dnsmgr_release(reg->dnsmgr);
13656 ast_free(reg);
13657 }
13658 AST_LIST_UNLOCK(&registrations);
13659
13660 ao2_callback(peers, OBJ_NODATA, peer_delme_cb, NULL);
13661}

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 9733 of file chan_iax2.c.

9734{
9735 unsigned short dpstatus = 0;
9736 struct iax_ie_data ied1;
9737 int mm;
9738
9739 memset(&ied1, 0, sizeof(ied1));
9740 mm = ast_matchmore_extension(NULL, context, callednum, 1, callerid);
9741 /* Must be started */
9742 if (ast_exists_extension(NULL, context, callednum, 1, callerid)) {
9743 dpstatus = IAX_DPSTATUS_EXISTS;
9744 } else if (ast_canmatch_extension(NULL, context, callednum, 1, callerid)) {
9745 dpstatus = IAX_DPSTATUS_CANEXIST;
9746 } else {
9747 dpstatus = IAX_DPSTATUS_NONEXISTENT;
9748 }
9749 if (ast_ignore_pattern(context, callednum))
9750 dpstatus |= IAX_DPSTATUS_IGNOREPAT;
9751 if (mm)
9752 dpstatus |= IAX_DPSTATUS_MATCHMORE;
9753 if (!skiplock)
9754 ast_mutex_lock(&iaxsl[callno]);
9755 if (iaxs[callno]) {
9756 iax_ie_append_str(&ied1, IAX_IE_CALLED_NUMBER, callednum);
9757 iax_ie_append_short(&ied1, IAX_IE_DPSTATUS, dpstatus);
9758 iax_ie_append_short(&ied1, IAX_IE_REFRESH, iaxdefaultdpcache);
9759 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_DPREP, 0, ied1.buf, ied1.pos, -1);
9760 }
9761 if (!skiplock)
9762 ast_mutex_unlock(&iaxsl[callno]);
9763}

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, 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 9765 of file chan_iax2.c.

9766{
9767 /* Look up for dpreq */
9768 struct dpreq_data *dpr = data;
9769 dp_lookup(dpr->callno, dpr->context, dpr->callednum, dpr->callerid, 0);
9770 if (dpr->callerid)
9771 ast_free(dpr->callerid);
9772 ast_free(dpr);
9773 return NULL;
9774}

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

1837{
1838 ast_str_set(buf, 0, "(");
1839 if (e & IAX_ENCRYPT_AES128) {
1840 ast_str_append(buf, 0, "aes128");
1841 }
1842 if (e & IAX_ENCRYPT_KEYROTATE) {
1843 ast_str_append(buf, 0, ",keyrotate");
1844 }
1845 if (ast_str_strlen(*buf) > 1) {
1846 ast_str_append(buf, 0, ")");
1847 } else {
1848 ast_str_set(buf, 0, "No");
1849 }
1850}

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 6629 of file chan_iax2.c.

6630{
6631 int padding;
6632 unsigned char *workspace;
6633 workspace = ast_alloca(*datalen + 32);
6634 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
6635 struct ast_iax2_full_enc_hdr *efh = (struct ast_iax2_full_enc_hdr *)fh;
6636 if (iaxdebug)
6637 ast_debug(1, "Encoding full frame %d/%d with length %d\n", fh->type, fh->csub, *datalen);
6638 padding = 16 - ((*datalen - sizeof(struct ast_iax2_full_enc_hdr)) % 16);
6639 padding = 16 + (padding & 0xf);
6640 memcpy(workspace, poo, padding);
6641 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_full_enc_hdr));
6642 workspace[15] &= 0xf0;
6643 workspace[15] |= (padding & 0xf);
6644 if (iaxdebug)
6645 ast_debug(1, "Encoding full frame %d/%d with length %d + %d padding (15=%02hhx)\n", fh->type, fh->csub, *datalen, padding, workspace[15]);
6646 *datalen += padding;
6647 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_full_enc_hdr), ecx);
6648 if (*datalen >= 32 + sizeof(struct ast_iax2_full_enc_hdr))
6649 memcpy(poo, workspace + *datalen - 32, 32);
6650 } else {
6651 struct ast_iax2_mini_enc_hdr *efh = (struct ast_iax2_mini_enc_hdr *)fh;
6652 if (iaxdebug)
6653 ast_debug(5, "Encoding mini frame with length %d\n", *datalen);
6654 padding = 16 - ((*datalen - sizeof(struct ast_iax2_mini_enc_hdr)) % 16);
6655 padding = 16 + (padding & 0xf);
6656 memcpy(workspace, poo, padding);
6657 memcpy(workspace + padding, efh->encdata, *datalen - sizeof(struct ast_iax2_mini_enc_hdr));
6658 workspace[15] &= 0xf0;
6659 workspace[15] |= (padding & 0x0f);
6660 *datalen += padding;
6661 memcpy_encrypt(efh->encdata, workspace, *datalen - sizeof(struct ast_iax2_mini_enc_hdr), ecx);
6662 if (*datalen >= 32 + sizeof(struct ast_iax2_mini_enc_hdr))
6663 memcpy(poo, workspace + *datalen - 32, 32);
6664 }
6665 return 0;
6666}

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 9134 of file chan_iax2.c.

9135{
9136#ifdef SCHED_MULTITHREADED
9137 if (schedule_action(__expire_registry, data))
9138#endif
9139 __expire_registry(data);
9140 return 0;
9141}

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 14307 of file chan_iax2.c.

14308{
14309 struct iax2_dpcache *dp = NULL;
14310 struct timeval now = ast_tvnow();
14311 int x, com[2], timeout, doabort, callno;
14312
14313 AST_LIST_TRAVERSE_SAFE_BEGIN(&dpcache, dp, cache_list) {
14314 if (ast_tvcmp(now, dp->expiry) > 0) {
14315 AST_LIST_REMOVE_CURRENT(cache_list);
14316 if ((dp->flags & CACHE_FLAG_PENDING) || dp->callno)
14317 ast_log(LOG_WARNING, "DP still has peer field or pending or callno (flags = %d, peer = blah, callno = %d)\n", dp->flags, dp->callno);
14318 else
14319 ast_free(dp);
14320 continue;
14321 }
14322 if (!strcmp(dp->peercontext, data) && !strcmp(dp->exten, exten))
14323 break;
14324 }
14325 AST_LIST_TRAVERSE_SAFE_END;
14326
14327 if (!dp) {
14328 /* No matching entry. Create a new one. */
14329 /* First, can we make a callno? */
14330 if ((callno = cache_get_callno_locked(data)) < 0) {
14331 ast_log(LOG_WARNING, "Unable to generate call for '%s'\n", data);
14332 return NULL;
14333 }
14334 if (!(dp = ast_calloc(1, sizeof(*dp)))) {
14335 ast_mutex_unlock(&iaxsl[callno]);
14336 return NULL;
14337 }
14338 ast_copy_string(dp->peercontext, data, sizeof(dp->peercontext));
14339 ast_copy_string(dp->exten, exten, sizeof(dp->exten));
14340 dp->expiry = ast_tvnow();
14341 dp->orig = dp->expiry;
14342 /* Expires in 30 mins by default */
14343 dp->expiry.tv_sec += iaxdefaultdpcache;
14344 dp->flags = CACHE_FLAG_PENDING;
14345 for (x = 0; x < ARRAY_LEN(dp->waiters); x++)
14346 dp->waiters[x] = -1;
14347 /* Insert into the lists */
14348 AST_LIST_INSERT_TAIL(&dpcache, dp, cache_list);
14349 AST_LIST_INSERT_TAIL(&iaxs[callno]->dpentries, dp, peer_list);
14350 /* Send the request if we're already up */
14351 if (ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
14352 iax2_dprequest(dp, callno);
14353 ast_mutex_unlock(&iaxsl[callno]);
14354 }
14355
14356 /* By here we must have a dp */
14357 if (dp->flags & CACHE_FLAG_PENDING) {
14358 int res;
14359 struct pollfd pfd;
14360 /* Okay, here it starts to get nasty. We need a pipe now to wait
14361 for a reply to come back so long as it's pending */
14362 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
14363 /* Find an empty slot */
14364 if (dp->waiters[x] < 0)
14365 break;
14366 }
14367 if (x >= ARRAY_LEN(dp->waiters)) {
14368 ast_log(LOG_WARNING, "No more waiter positions available\n");
14369 return NULL;
14370 }
14371 if (pipe(com)) {
14372 ast_log(LOG_WARNING, "Unable to create pipe for comm\n");
14373 return NULL;
14374 }
14375 dp->waiters[x] = com[1];
14376 /* Okay, now we wait */
14377 timeout = iaxdefaulttimeout * 1000;
14378 /* Temporarily unlock */
14379 AST_LIST_UNLOCK(&dpcache);
14380 doabort = 0;
14381
14382 /* chan is in autoservice here, so do NOT service it here! */
14383 pfd.fd = com[0];
14384 pfd.events = POLLIN;
14385 pfd.revents = 0;
14386 /* Wait for pipe activity... if the channel hangs up, we'll catch it on the way out. */
14387 res = ast_poll(&pfd, 1, timeout);
14388 if (res < 0) {
14389 ast_log(LOG_WARNING, "poll returned < 0: %s\n", strerror(errno));
14390 return NULL;
14391 } else if (!pfd.revents) {
14392 ast_log(LOG_WARNING, "Timeout waiting for %s exten %s\n", data, exten);
14393 }
14394
14395 if (chan && ast_check_hangup(chan)) {
14396 doabort = 1;
14397 }
14398
14399 AST_LIST_LOCK(&dpcache);
14400 dp->waiters[x] = -1;
14401 close(com[1]);
14402 close(com[0]);
14403 if (doabort) {
14404 /* Don't interpret anything, just abort. */
14405 return NULL;
14406 }
14407 if (!(dp->flags & CACHE_FLAG_TIMEOUT)) {
14408 /* Now to do non-independent analysis the results of our wait */
14409 if (dp->flags & CACHE_FLAG_PENDING) {
14410 /* Still pending... It's a timeout. Wake everybody up. Consider it no longer
14411 pending. Don't let it take as long to timeout. */
14412 dp->flags &= ~CACHE_FLAG_PENDING;
14413 dp->flags |= CACHE_FLAG_TIMEOUT;
14414 /* Expire after only 60 seconds now. This is designed to help reduce backlog in heavily loaded
14415 systems without leaving it unavailable once the server comes back online */
14416 dp->expiry.tv_sec = dp->orig.tv_sec + 60;
14417 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
14418 if (dp->waiters[x] > -1) {
14419 if (write(dp->waiters[x], "asdf", 4) < 0) {
14420 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
14421 }
14422 }
14423 }
14424 }
14425 }
14426 /* Our caller will obtain the rest */
14427 }
14428 return dp;
14429}

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 3320 of file chan_iax2.c.

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

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 3324 of file chan_iax2.c.

3324 {
3325
3326 return __find_callno(callno, dcallno, addr, new, sockfd, 1, full_frame);
3327}

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 1671 of file chan_iax2.c.

1672{
1673 struct iax2_thread *thread = NULL;
1674
1675 /* Pop the head of the idle list off */
1676 AST_LIST_LOCK(&idle_list);
1677 thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1678 AST_LIST_UNLOCK(&idle_list);
1679
1680 /* If we popped a thread off the idle list, just return it */
1681 if (thread) {
1682 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1683 return thread;
1684 }
1685
1686 /* Pop the head of the dynamic list off */
1687 AST_LIST_LOCK(&dynamic_list);
1688 thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1689 AST_LIST_UNLOCK(&dynamic_list);
1690
1691 /* If we popped a thread off the dynamic list, just return it */
1692 if (thread) {
1693 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1694 return thread;
1695 }
1696
1697 /* If we can't create a new dynamic thread for any reason, return no thread at all */
1698 if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1699 return NULL;
1700
1701 /* Set default values */
1702 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1703 thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1704 thread->type = IAX_THREAD_TYPE_DYNAMIC;
1705
1706 /* Initialize lock and condition */
1707 ast_mutex_init(&thread->lock);
1708 ast_cond_init(&thread->cond, NULL);
1709 ast_mutex_init(&thread->init_lock);
1710 ast_cond_init(&thread->init_cond, NULL);
1711 ast_mutex_lock(&thread->init_lock);
1712
1713 /* Create thread and send it on it's way */
1714 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1715 ast_cond_destroy(&thread->cond);
1716 ast_mutex_destroy(&thread->lock);
1717 ast_mutex_unlock(&thread->init_lock);
1718 ast_cond_destroy(&thread->init_cond);
1719 ast_mutex_destroy(&thread->init_lock);
1720 ast_free(thread);
1721 return NULL;
1722 }
1723
1724 /* this thread is not processing a full frame (since it is idle),
1725 so ensure that the field for the full frame call number is empty */
1726 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1727
1728 /* Wait for the thread to be ready before returning it to the caller */
1729 ast_cond_wait(&thread->init_cond, &thread->init_lock);
1730
1731 /* Done with init_lock */
1732 ast_mutex_unlock(&thread->init_lock);
1733
1734 return thread;
1735}

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 2095 of file chan_iax2.c.

2096{
2097 struct iax2_peer *peer = NULL;
2098
2099 peer = ao2_find(peers, name, OBJ_KEY);
2100
2101 /* Now go for realtime if applicable */
2102 if (!peer && realtime) {
2103 peer = realtime_peer(name, NULL);
2104 }
2105 return peer;
2106}

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 6377 of file chan_iax2.c.

6378{
6379 struct iax2_trunk_peer *tpeer = NULL;
6380
6381 /* Finds and locks trunk peer */
6382 AST_LIST_LOCK(&tpeers);
6383
6384 AST_LIST_TRAVERSE(&tpeers, tpeer, list) {
6385 if (!ast_sockaddr_cmp(&tpeer->addr, addr)) {
6386 ast_mutex_lock(&tpeer->lock);
6387 break;
6388 }
6389 }
6390
6391 if (!tpeer) {
6392 if ((tpeer = ast_calloc(1, sizeof(*tpeer)))) {
6393 ast_mutex_init(&tpeer->lock);
6394 tpeer->lastsent = 9999;
6395 ast_sockaddr_copy(&tpeer->addr, addr);
6396 tpeer->trunkact = ast_tvnow();
6397 ast_mutex_lock(&tpeer->lock);
6398 tpeer->sockfd = fd;
6399
6400#ifdef SO_NO_CHECK
6401 setsockopt(tpeer->sockfd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
6402#endif
6403 ast_debug(1, "Created trunk peer for '%s'\n", ast_sockaddr_stringify(&tpeer->addr));
6404 AST_LIST_INSERT_TAIL(&tpeers, tpeer, list);
6405 }
6406 }
6407
6408 AST_LIST_UNLOCK(&tpeers);
6409
6410 return tpeer;
6411}

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 2120 of file chan_iax2.c.

2121{
2122 return ao2_find(users, name, OBJ_KEY);
2123}

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 7358 of file chan_iax2.c.

7360{
7361 int *fd = user_data;
7362
7363 ast_cli(*fd, "%-15.15s %-15d %-15d\n",
7364 header->devname,
7365 ntohs(header->version),
7366 (int) ntohl(header->datalen));
7367
7368 return 0;
7369}

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 6187 of file chan_iax2.c.

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

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 12693 of file chan_iax2.c.

12694{
12695 struct iax2_context *conl;
12696 while(con) {
12697 conl = con;
12698 con = con->next;
12699 ast_free(conl);
12700 }
12701}

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 2234 of file chan_iax2.c.

2235{
2236 if (s->f.datalen) {
2237 ast_free(s->f.data.ptr);
2238 }
2239 ast_free(s);
2240}

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 14552 of file chan_iax2.c.

14553{
14554 struct iax2_peer *peer;
14555 char *peername, *colname;
14556
14557 peername = ast_strdupa(data);
14558
14559 /* if our channel, return the IP address of the endpoint of current channel */
14560 if (!strcmp(peername,"CURRENTCHANNEL")) {
14561 unsigned short callno;
14562 if (!chan || ast_channel_tech(chan) != &iax2_tech) {
14563 return -1;
14564 }
14565 callno = PTR_TO_CALLNO(ast_channel_tech_pvt(chan));
14566 ast_copy_string(buf, !ast_sockaddr_isnull(&iaxs[callno]->addr) ? ast_sockaddr_stringify_addr(&iaxs[callno]->addr) : "", len);
14567 return 0;
14568 }
14569
14570 if ((colname = strchr(peername, ',')))
14571 *colname++ = '\0';
14572 else
14573 colname = "ip";
14574
14575 if (!(peer = find_peer(peername, 1)))
14576 return -1;
14577
14578 if (!strcasecmp(colname, "ip")) {
14579 ast_copy_string(buf, ast_sockaddr_stringify_addr(&peer->addr), len);
14580 } else if (!strcasecmp(colname, "status")) {
14581 peer_status(peer, buf, len);
14582 } else if (!strcasecmp(colname, "mailbox")) {
14583 ast_copy_string(buf, peer->mailbox, len);
14584 } else if (!strcasecmp(colname, "context")) {
14585 ast_copy_string(buf, peer->context, len);
14586 } else if (!strcasecmp(colname, "expire")) {
14587 snprintf(buf, len, "%d", peer->expire);
14588 } else if (!strcasecmp(colname, "dynamic")) {
14589 ast_copy_string(buf, (ast_test_flag64(peer, IAX_DYNAMIC) ? "yes" : "no"), len);
14590 } else if (!strcasecmp(colname, "callerid_name")) {
14591 ast_copy_string(buf, peer->cid_name, len);
14592 } else if (!strcasecmp(colname, "callerid_num")) {
14593 ast_copy_string(buf, peer->cid_num, len);
14594 } else if (!strcasecmp(colname, "codecs")) {
14595 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
14596
14597 iax2_getformatname_multiple(peer->capability, &codec_buf);
14598 ast_copy_string(buf, ast_str_buffer(codec_buf), len);
14599 } else if (!strncasecmp(colname, "codec[", 6)) {
14600 char *codecnum, *ptr;
14601 struct ast_format *tmpfmt;
14602
14603 /* skip over "codec" to the '[' */
14604 codecnum = colname + 5;
14605 *codecnum = '\0';
14606 codecnum++;
14607 if ((ptr = strchr(codecnum, ']'))) {
14608 *ptr = '\0';
14609 }
14610 if((iax2_codec_pref_index(&peer->prefs, atoi(codecnum), &tmpfmt))) {
14611 ast_copy_string(buf, ast_format_get_name(tmpfmt), len);
14612 } else {
14613 buf[0] = '\0';
14614 }
14615 } else {
14616 buf[0] = '\0';
14617 }
14618
14619 peer_unref(peer);
14620
14621 return 0;
14622}

References iax2_peer::addr, 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 12902 of file chan_iax2.c.

12903{
12904 int methods = 0;
12905 if (strstr(value, "rsa"))
12906 methods |= IAX_AUTH_RSA;
12907 if (strstr(value, "md5"))
12908 methods |= IAX_AUTH_MD5;
12909 if (strstr(value, "plaintext"))
12910 methods |= IAX_AUTH_PLAINTEXT;
12911 return methods;
12912}

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 1852 of file chan_iax2.c.

1853{
1854 int e;
1855 if (!strcasecmp(s, "aes128"))
1856 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1857 else if (ast_true(s))
1858 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1859 else
1860 e = 0;
1861 return e;
1862}

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 4314 of file chan_iax2.c.

4315{
4316#ifdef SCHED_MULTITHREADED
4317 if (schedule_action(__get_from_jb, data))
4318#endif
4319 __get_from_jb(data);
4320 return 0;
4321}

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 2991 of file chan_iax2.c.

2992{
2993 struct call_number_pool *pool = NULL;
2994 callno_entry swap;
2995 size_t choice;
2996
2997 switch (type) {
2998 case CALLNO_TYPE_NORMAL:
2999 pool = &callno_pool;
3000 break;
3001 case CALLNO_TYPE_TRUNK:
3002 pool = &callno_pool_trunk;
3003 break;
3004 default:
3005 ast_assert(0);
3006 break;
3007 }
3008
3009 /* If we fail, make sure this has a defined value */
3010 *entry = 0;
3011
3012 /* We lock here primarily to ensure thread safety of the
3013 * total_nonval_callno_used check and increment */
3014 ast_mutex_lock(&callno_pool_lock);
3015
3016 /* Bail out if we don't have any available call numbers */
3017 if (!pool->available) {
3018 ast_log(LOG_WARNING, "Out of call numbers\n");
3019 ast_mutex_unlock(&callno_pool_lock);
3020 return 1;
3021 }
3022
3023 /* Only a certain number of non-validated call numbers should be allocated.
3024 * If there ever is an attack, this separates the calltoken validating users
3025 * from the non-calltoken validating users. */
3026 if (!validated && total_nonval_callno_used >= global_maxcallno_nonval) {
3027 ast_log(LOG_WARNING,
3028 "NON-CallToken callnumber limit is reached. Current: %d Max: %d\n",
3029 total_nonval_callno_used,
3030 global_maxcallno_nonval);
3031 ast_mutex_unlock(&callno_pool_lock);
3032 return 1;
3033 }
3034
3035 /* We use a modified Fisher-Yates-Durstenfeld Shuffle to maintain a list of
3036 * available call numbers. The array of call numbers begins as an ordered
3037 * list from 1 -> n, and we keep a running tally of how many remain unclaimed
3038 * - let's call that x. When a call number is needed we pick a random index
3039 * into the array between 0 and x and use that as our call number. In a
3040 * typical FYD shuffle, we would swap the value that we are extracting with
3041 * the number at x, but in our case we swap and don't touch the value at x
3042 * because it is effectively invisible. We rely on the rest of the IAX2 core
3043 * to return the number to us at some point. Finally, we decrement x by 1
3044 * which establishes our new unused range.
3045 *
3046 * When numbers are returned to the pool, we put them just past x and bump x
3047 * by 1 so that this number is now available for re-use. */
3048
3049 choice = ast_random() % pool->available;
3050
3051 *entry = pool->numbers[choice];
3052 swap = pool->numbers[pool->available - 1];
3053
3054 pool->numbers[choice] = swap;
3055 pool->available--;
3056
3057 if (validated) {
3058 CALLNO_ENTRY_SET_VALIDATED(*entry);
3059 } else {
3060 total_nonval_callno_used++;
3061 }
3062
3063 ast_mutex_unlock(&callno_pool_lock);
3064
3065 return 0;
3066}

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 5043 of file chan_iax2.c.

5045{
5046#define CALLTOKEN_HASH_FORMAT "%s%u%d" /* address + port + ts + randomcalldata */
5047#define CALLTOKEN_IE_FORMAT "%u?%s" /* time + ? + (40 char hash) */
5048 struct ast_str *buf = ast_str_alloca(256);
5049 time_t t = time(NULL);
5050 char hash[41]; /* 40 char sha1 hash */
5051 int subclass = uncompress_subclass(fh->csub);
5052
5053 /* ----- Case 1 ----- */
5054 if (ies->calltoken && !ies->calltokendata) { /* empty calltoken is provided, client supports calltokens */
5055 struct iax_ie_data ied = {
5056 .buf = { 0 },
5057 .pos = 0,
5058 };
5059
5060 /* create the hash with their address data and our timestamp */
5061 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) t, randomcalltokendata);
5062 ast_sha1_hash(hash, ast_str_buffer(buf));
5063
5064 ast_str_set(&buf, 0, CALLTOKEN_IE_FORMAT, (unsigned int) t, hash);
5065 iax_ie_append_str(&ied, IAX_IE_CALLTOKEN, ast_str_buffer(buf));
5066 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_CALLTOKEN, ntohl(fh->ts), fh->iseqno + 1, fd, &ied);
5067
5068 return 1;
5069
5070 /* ----- Case 2 ----- */
5071 } else if (ies->calltoken && ies->calltokendata) { /* calltoken received, check to see if it is valid */
5072 char *rec_hash = NULL; /* the received hash, make sure it matches with ours. */
5073 char *rec_ts = NULL; /* received timestamp */
5074 unsigned int rec_time; /* received time_t */
5075
5076 /* split the timestamp from the hash data */
5077 rec_hash = strchr((char *) ies->calltokendata, '?');
5078 if (rec_hash) {
5079 *rec_hash++ = '\0';
5080 rec_ts = (char *) ies->calltokendata;
5081 }
5082
5083 /* check that we have valid data before we do any comparisons */
5084 if (!rec_hash || !rec_ts) {
5085 goto reject;
5086 } else if (sscanf(rec_ts, "%u", &rec_time) != 1) {
5087 goto reject;
5088 }
5089
5090 /* create a hash with their address and the _TOKEN'S_ timestamp */
5091 ast_str_set(&buf, 0, CALLTOKEN_HASH_FORMAT, ast_sockaddr_stringify(addr), (unsigned int) rec_time, randomcalltokendata);
5092 ast_sha1_hash(hash, ast_str_buffer(buf));
5093
5094 /* compare hashes and then check timestamp delay */
5095 if (strcmp(hash, rec_hash)) {
5096 ast_log(LOG_WARNING, "Address %s failed CallToken hash inspection\n", ast_sockaddr_stringify(addr));
5097 goto reject; /* received hash does not match ours, reject */
5098 } else if ((t < rec_time) || ((t - rec_time) >= max_calltoken_delay)) {
5099 ast_log(LOG_WARNING, "Too much delay in IAX2 calltoken timestamp from address %s\n", ast_sockaddr_stringify(addr));
5100 goto reject; /* too much delay, reject */
5101 }
5102
5103 /* at this point the call token is valid, returning 0
5104 * will allow socket_process to continue as usual */
5105 requirecalltoken_mark_auto(ies->username, subclass);
5106 return 0;
5107
5108 /* ----- Case 3 ----- */
5109 } else { /* calltokens are not supported for this client, how do we respond? */
5110 if (calltoken_required(addr, ies->username, subclass)) {
5111 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"));
5112 goto reject;
5113 }
5114 return 0; /* calltoken is not required for this addr, so permit it. */
5115 }
5116
5117reject:
5118 /* received frame has failed calltoken inspection, send apathetic reject messages */
5119 if (subclass == IAX_COMMAND_REGREQ || subclass == IAX_COMMAND_REGREL) {
5120 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
5121 } else {
5122 send_apathetic_reply(1, ntohs(fh->scallno), addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
5123 }
5124
5125 return 1;
5126}

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 12523 of file chan_iax2.c.

12524{
12525 int force = 0;
12526 int res;
12527
12528 switch (cmd) {
12529 case CLI_INIT:
12530 e->command = "iax2 provision";
12531 e->usage =
12532 "Usage: iax2 provision <host> <template> [forced]\n"
12533 " Provisions the given peer or IP address using a template\n"
12534 " matching either 'template' or '*' if the template is not\n"
12535 " found. If 'forced' is specified, even empty provisioning\n"
12536 " fields will be provisioned as empty fields.\n";
12537 return NULL;
12538 case CLI_GENERATE:
12539 if (a->pos == 3)
12540 return iax_prov_complete_template(a->line, a->word, a->pos, a->n);
12541 return NULL;
12542 }
12543
12544 if (a->argc < 4)
12545 return CLI_SHOWUSAGE;
12546 if (a->argc > 4) {
12547 if (!strcasecmp(a->argv[4], "forced"))
12548 force = 1;
12549 else
12550 return CLI_SHOWUSAGE;
12551 }
12552 res = iax2_provision(NULL, -1, a->argv[2], a->argv[3], force);
12553 if (res < 0)
12554 ast_cli(a->fd, "Unable to find peer/address '%s'\n", a->argv[2]);
12555 else if (res < 1)
12556 ast_cli(a->fd, "No template (including wildcard) matching '%s'\n", a->argv[3]);
12557 else
12558 ast_cli(a->fd, "Provisioning '%s' with template '%s'%s\n", a->argv[2], a->argv[3], force ? ", forced" : "");
12559 return CLI_SUCCESS;
12560}

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 3726 of file chan_iax2.c.

3727{
3728 struct iax2_peer *peer = NULL;
3729 struct iax2_user *user = NULL;
3730 static const char * const choices[] = { "all", NULL };
3731 char *cmplt;
3732
3733 switch (cmd) {
3734 case CLI_INIT:
3735 e->command = "iax2 prune realtime";
3736 e->usage =
3737 "Usage: iax2 prune realtime [<peername>|all]\n"
3738 " Prunes object(s) from the cache\n";
3739 return NULL;
3740 case CLI_GENERATE:
3741 if (a->pos == 3) {
3742 cmplt = ast_cli_complete(a->word, choices, a->n);
3743 if (!cmplt)
3744 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
3745 return cmplt;
3746 }
3747 return NULL;
3748 }
3749 if (a->argc != 4)
3750 return CLI_SHOWUSAGE;
3751 if (!strcmp(a->argv[3], "all")) {
3752 prune_users();
3753 prune_peers();
3754 ast_cli(a->fd, "Cache flushed successfully.\n");
3755 return CLI_SUCCESS;
3756 }
3757 peer = find_peer(a->argv[3], 0);
3758 user = find_user(a->argv[3]);
3759 if (peer || user) {
3760 if (peer) {
3761 if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
3762 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
3763 expire_registry(peer_ref(peer));
3764 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
3765 } else {
3766 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
3767 }
3768 peer_unref(peer);
3769 }
3770 if (user) {
3771 if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
3772 ast_set_flag64(user, IAX_RTAUTOCLEAR);
3773 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
3774 } else {
3775 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
3776 }
3777 ao2_unlink(users,user);
3778 user_unref(user);
3779 }
3780 } else {
3781 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
3782 }
3783
3784 return CLI_SUCCESS;
3785}

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 14211 of file chan_iax2.c.

14212{
14213 switch (cmd) {
14214 case CLI_INIT:
14215 e->command = "iax2 reload";
14216 e->usage =
14217 "Usage: iax2 reload\n"
14218 " Reloads IAX configuration from iax.conf\n";
14219 return NULL;
14220 case CLI_GENERATE:
14221 return NULL;
14222 }
14223
14224 reload_config(0);
14225
14226 return CLI_SUCCESS;
14227}

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 7737 of file chan_iax2.c.

7738{
7739 switch (cmd) {
7740 case CLI_INIT:
7741 e->command = "iax2 set debug {on|off|peer}";
7742 e->usage =
7743 "Usage: iax2 set debug {on|off|peer peername}\n"
7744 " Enables/Disables dumping of IAX packets for debugging purposes.\n";
7745 return NULL;
7746 case CLI_GENERATE:
7747 if (a->pos == 4 && !strcasecmp(a->argv[3], "peer"))
7748 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
7749 return NULL;
7750 }
7751
7752 if (a->argc < e->args || a->argc > e->args + 1)
7753 return CLI_SHOWUSAGE;
7754
7755 if (!strcasecmp(a->argv[3], "peer")) {
7756 struct iax2_peer *peer;
7757
7758 if (a->argc != e->args + 1)
7759 return CLI_SHOWUSAGE;
7760
7761 peer = find_peer(a->argv[4], 1);
7762
7763 if (!peer) {
7764 ast_cli(a->fd, "IAX2 peer '%s' does not exist\n", a->argv[e->args-1]);
7765 return CLI_FAILURE;
7766 }
7767
7768 ast_sockaddr_copy(&debugaddr, &peer->addr);
7769
7770 ast_cli(a->fd, "IAX2 Debugging Enabled for IP: %s\n", ast_sockaddr_stringify_port(&debugaddr));
7771
7772 ao2_ref(peer, -1);
7773 } else if (!strncasecmp(a->argv[3], "on", 2)) {
7774 iaxdebug = 1;
7775 ast_cli(a->fd, "IAX2 Debugging Enabled\n");
7776 } else {
7777 iaxdebug = 0;
7778 memset(&debugaddr, 0, sizeof(debugaddr));
7779 ast_cli(a->fd, "IAX2 Debugging Disabled\n");
7780 }
7781 return CLI_SUCCESS;
7782}

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 7810 of file chan_iax2.c.

7811{
7812 switch (cmd) {
7813 case CLI_INIT:
7814 e->command = "iax2 set debug jb {on|off}";
7815 e->usage =
7816 "Usage: iax2 set debug jb {on|off}\n"
7817 " Enables/Disables jitterbuffer debugging information\n";
7818 return NULL;
7819 case CLI_GENERATE:
7820 return NULL;
7821 }
7822
7823 if (a->argc != e->args)
7824 return CLI_SHOWUSAGE;
7825
7826 if (!strncasecmp(a->argv[e->args -1], "on", 2)) {
7827 jb_setoutput(jb_error_output, jb_warning_output, jb_debug_output);
7828 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Enabled\n");
7829 } else {
7830 jb_setoutput(jb_error_output, jb_warning_output, NULL);
7831 ast_cli(a->fd, "IAX2 Jitterbuffer Debugging Disabled\n");
7832 }
7833 return CLI_SUCCESS;
7834}

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 7784 of file chan_iax2.c.

7785{
7786 switch (cmd) {
7787 case CLI_INIT:
7788 e->command = "iax2 set debug trunk {on|off}";
7789 e->usage =
7790 "Usage: iax2 set debug trunk {on|off}\n"
7791 " Enables/Disables debugging of IAX trunking\n";
7792 return NULL;
7793 case CLI_GENERATE:
7794 return NULL;
7795 }
7796
7797 if (a->argc != e->args)
7798 return CLI_SHOWUSAGE;
7799
7800 if (!strncasecmp(a->argv[e->args - 1], "on", 2)) {
7801 iaxtrunkdebug = 1;
7802 ast_cli(a->fd, "IAX2 Trunk Debugging Enabled\n");
7803 } else {
7804 iaxtrunkdebug = 0;
7805 ast_cli(a->fd, "IAX2 Trunk Debugging Disabled\n");
7806 }
7807 return CLI_SUCCESS;
7808}

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 4046 of file chan_iax2.c.

4047{
4048 int mtuv;
4049
4050 switch (cmd) {
4051 case CLI_INIT:
4052 e->command = "iax2 set mtu";
4053 e->usage =
4054 "Usage: iax2 set mtu <value>\n"
4055 " Set the system-wide IAX IP mtu to <value> bytes net or\n"
4056 " zero to disable. Disabling means that the operating system\n"
4057 " must handle fragmentation of UDP packets when the IAX2 trunk\n"
4058 " packet exceeds the UDP payload size. This is substantially\n"
4059 " below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
4060 " greater for G.711 samples.\n";
4061 return NULL;
4062 case CLI_GENERATE:
4063 return NULL;
4064 }
4065
4066 if (a->argc != 4)
4067 return CLI_SHOWUSAGE;
4068 if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
4069 mtuv = MAX_TRUNK_MTU;
4070 else
4071 mtuv = atoi(a->argv[3]);
4072
4073 if (mtuv == 0) {
4074 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
4075 global_max_trunk_mtu = 0;
4076 return CLI_SUCCESS;
4077 }
4078 if (mtuv < 172 || mtuv > 4000) {
4079 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n");
4080 return CLI_SHOWUSAGE;
4081 }
4082 ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
4083 global_max_trunk_mtu = mtuv;
4084 return CLI_SUCCESS;
4085}

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 4087 of file chan_iax2.c.

4088{
4089 struct iax2_dpcache *dp = NULL;
4090 char tmp[1024], *pc = NULL;
4091 int s, x, y;
4092 struct timeval now = ast_tvnow();
4093
4094 switch (cmd) {
4095 case CLI_INIT:
4096 e->command = "iax2 show cache";
4097 e->usage =
4098 "Usage: iax2 show cache\n"
4099 " Display currently cached IAX Dialplan results.\n";
4100 return NULL;
4101 case CLI_GENERATE:
4102 return NULL;
4103 }
4104
4105 AST_LIST_LOCK(&dpcache);
4106
4107 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
4108
4109 AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
4110 s = dp->expiry.tv_sec - now.tv_sec;
4111 tmp[0] = '\0';
4112 if (dp->flags & CACHE_FLAG_EXISTS)
4113 strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
4114 if (dp->flags & CACHE_FLAG_NONEXISTENT)
4115 strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
4116 if (dp->flags & CACHE_FLAG_CANEXIST)
4117 strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
4118 if (dp->flags & CACHE_FLAG_PENDING)
4119 strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
4120 if (dp->flags & CACHE_FLAG_TIMEOUT)
4121 strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
4122 if (dp->flags & CACHE_FLAG_TRANSMITTED)
4123 strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
4124 if (dp->flags & CACHE_FLAG_MATCHMORE)
4125 strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
4126 if (dp->flags & CACHE_FLAG_UNKNOWN)
4127 strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
4128 /* Trim trailing pipe */
4129 if (!ast_strlen_zero(tmp)) {
4130 tmp[strlen(tmp) - 1] = '\0';
4131 } else {
4132 ast_copy_string(tmp, "(none)", sizeof(tmp));
4133 }
4134 y = 0;
4135 pc = strchr(dp->peercontext, '@');
4136 if (!pc) {
4137 pc = dp->peercontext;
4138 } else {
4139 pc++;
4140 }
4141 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
4142 if (dp->waiters[x] > -1)
4143 y++;
4144 }
4145 if (s > 0) {
4146 ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
4147 } else {
4148 ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
4149 }
4150 }
4151
4152 AST_LIST_UNLOCK(&dpcache);
4153
4154 return CLI_SUCCESS;
4155}

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 2922 of file chan_iax2.c.

2923{
2924 struct ao2_iterator i;
2925 struct peercnt *peercnt;
2926 struct ast_sockaddr addr;
2927 int found = 0;
2928
2929 switch (cmd) {
2930 case CLI_INIT:
2931 e->command = "iax2 show callnumber usage";
2932 e->usage =
2933 "Usage: iax2 show callnumber usage [IP address]\n"
2934 " Shows current IP addresses which are consuming iax2 call numbers\n";
2935 return NULL;
2936 case CLI_GENERATE:
2937 return NULL;
2938 case CLI_HANDLER:
2939 if (a->argc < 4 || a->argc > 5)
2940 return CLI_SHOWUSAGE;
2941
2942 if (a->argc == 4) {
2943 ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2944 }
2945
2946 i = ao2_iterator_init(peercnts, 0);
2947 while ((peercnt = ao2_iterator_next(&i))) {
2948 ast_sockaddr_copy(&addr, &peercnt->addr);
2949
2950 if (a->argc == 5) {
2951 if (!strcasecmp(a->argv[4], ast_sockaddr_stringify(&addr))) {
2952 ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2953 ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2954 ao2_ref(peercnt, -1);
2955 found = 1;
2956 break;
2957 }
2958 } else {
2959 ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2960 }
2961 ao2_ref(peercnt, -1);
2962 }
2963 ao2_iterator_destroy(&i);
2964
2965 if (a->argc == 4) {
2966 size_t pool_avail = callno_pool.available;
2967 size_t trunk_pool_avail = callno_pool_trunk.available;
2968
2969 ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
2970 "Non-CallToken Validated Callno Used: %d\n",
2971 global_maxcallno_nonval,
2972 total_nonval_callno_used);
2973
2974 ast_cli(a->fd, "Total Available Callno: %zu\n"
2975 "Regular Callno Available: %zu\n"
2976 "Trunk Callno Available: %zu\n",
2977 pool_avail + trunk_pool_avail,
2978 pool_avail,
2979 trunk_pool_avail);
2980 } else if (a->argc == 5 && !found) {
2981 ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
2982 }
2983
2984
2985 return CLI_SUCCESS;
2986 default:
2987 return NULL;
2988 }
2989}

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 7564 of file chan_iax2.c.

7565{
7566#define FORMAT2 "%-20.20s %-40.40s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %-6.6s %s %s %9s\n"
7567#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"
7568#define FORMATB "%-20.20s %-40.40s %-10.10s %5.5d/%5.5d %5.5d/%5.5d [Native Bridged to ID=%5.5d]\n"
7569 int x;
7570 int numchans = 0;
7571 char first_message[10] = { 0, };
7572 char last_message[10] = { 0, };
7573
7574 switch (cmd) {
7575 case CLI_INIT:
7576 e->command = "iax2 show channels";
7577 e->usage =
7578 "Usage: iax2 show channels\n"
7579 " Lists all currently active IAX channels.\n";
7580 return NULL;
7581 case CLI_GENERATE:
7582 return NULL;
7583 }
7584
7585 if (a->argc != 3)
7586 return CLI_SHOWUSAGE;
7587 ast_cli(a->fd, FORMAT2, "Channel", "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "JitBuf", "Format", "FirstMsg", "LastMsg");
7588 for (x = 0; x < ARRAY_LEN(iaxs); x++) {
7589 ast_mutex_lock(&iaxsl[x]);
7590 if (iaxs[x]) {
7591 int lag, jitter, localdelay;
7592 jb_info jbinfo;
7593 if (ast_test_flag64(iaxs[x], IAX_USEJITTERBUF)) {
7594 jb_getinfo(iaxs[x]->jb, &jbinfo);
7595 jitter = jbinfo.jitter;
7596 localdelay = jbinfo.current - jbinfo.min;
7597 } else {
7598 jitter = -1;
7599 localdelay = 0;
7600 }
7601
7602 iax_frame_subclass2str(iaxs[x]->first_iax_message & ~MARK_IAX_SUBCLASS_TX, first_message, sizeof(first_message));
7603 iax_frame_subclass2str(iaxs[x]->last_iax_message & ~MARK_IAX_SUBCLASS_TX, last_message, sizeof(last_message));
7604 lag = iaxs[x]->remote_rr.delay;
7605 ast_cli(a->fd, FORMAT,
7606 iaxs[x]->owner ? ast_channel_name(iaxs[x]->owner) : "(None)",
7607 ast_sockaddr_stringify_addr(&iaxs[x]->addr),
7608 S_OR(iaxs[x]->username, "(None)"),
7609 iaxs[x]->callno, iaxs[x]->peercallno,
7610 iaxs[x]->oseqno, iaxs[x]->iseqno,
7611 lag,
7612 jitter,
7613 localdelay,
7614 iax2_getformatname(iaxs[x]->voiceformat),
7615 (iaxs[x]->first_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7616 first_message,
7617 (iaxs[x]->last_iax_message & MARK_IAX_SUBCLASS_TX) ? "Tx:" : "Rx:",
7618 last_message);
7619 numchans++;
7620 }
7621 ast_mutex_unlock(&iaxsl[x]);
7622 }
7623 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
7624 return CLI_SUCCESS;
7625#undef FORMAT
7626#undef FORMAT2
7627#undef FORMATB
7628}

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, chan_iax2_pvt::callno, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, jb_info::current, iax_rr::delay, chan_iax2_pvt::first_iax_message, FORMAT, FORMAT2, iax2_getformatname(), iax_frame_subclass2str(), IAX_USEJITTERBUF, iaxs, iaxsl, chan_iax2_pvt::iseqno, jb_getinfo(), jb_info::jitter, chan_iax2_pvt::last_iax_message, MARK_IAX_SUBCLASS_TX, jb_info::min, NULL, chan_iax2_pvt::oseqno, chan_iax2_pvt::owner, chan_iax2_pvt::peercallno, 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 7371 of file chan_iax2.c.

7372{
7373 switch (cmd) {
7374 case CLI_INIT:
7375 e->command = "iax2 show firmware";
7376 e->usage =
7377 "Usage: iax2 show firmware\n"
7378 " Lists all known IAX firmware images.\n";
7379 return NULL;
7380 case CLI_GENERATE:
7381 return NULL;
7382 }
7383
7384 if (a->argc != 3 && a->argc != 4)
7385 return CLI_SHOWUSAGE;
7386
7387 ast_cli(a->fd, "%-15.15s %-15.15s %-15.15s\n", "Device", "Version", "Size");
7388
7389 iax_firmware_traverse(
7390 a->argc == 3 ? NULL : a->argv[3],
7391 firmware_show_callback,
7392 (void *) &a->fd);
7393
7394 return CLI_SUCCESS;
7395}

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 7714 of file chan_iax2.c.

7715{
7716 int numchans = 0;
7717
7718 switch (cmd) {
7719 case CLI_INIT:
7720 e->command = "iax2 show netstats";
7721 e->usage =
7722 "Usage: iax2 show netstats\n"
7723 " Lists network status for all currently active IAX channels.\n";
7724 return NULL;
7725 case CLI_GENERATE:
7726 return NULL;
7727 }
7728 if (a->argc != 3)
7729 return CLI_SHOWUSAGE;
7730 ast_cli(a->fd, " -------- LOCAL --------------------- -------- REMOTE --------------------\n");
7731 ast_cli(a->fd, "Channel RTT Jit Del Lost %% Drop OOO Kpkts Jit Del Lost %% Drop OOO Kpkts FirstMsg LastMsg\n");
7732 numchans = ast_cli_netstats(NULL, a->fd, 1);
7733 ast_cli(a->fd, "%d active IAX channel%s\n", numchans, (numchans != 1) ? "s" : "");
7734 return CLI_SUCCESS;
7735}

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 3901 of file chan_iax2.c.

3902{
3903 char status[64];
3904 char cbuf[256];
3905 struct iax2_peer *peer;
3906 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
3907 struct ast_str *encmethods = ast_str_alloca(256);
3908 int load_realtime = 0;
3909
3910 switch (cmd) {
3911 case CLI_INIT:
3912 e->command = "iax2 show peer";
3913 e->usage =
3914 "Usage: iax2 show peer <name>\n"
3915 " Display details on specific IAX peer\n";
3916 return NULL;
3917 case CLI_GENERATE:
3918 if (a->pos == 3)
3919 return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
3920 return NULL;
3921 }
3922
3923 if (a->argc < 4)
3924 return CLI_SHOWUSAGE;
3925
3926 load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
3927
3928 peer = find_peer(a->argv[3], load_realtime);
3929 if (peer) {
3930 char *str_addr, *str_defaddr;
3931 char *str_port, *str_defport;
3932
3933 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->addr));
3934 str_port = ast_strdupa(ast_sockaddr_stringify_port(&peer->addr));
3935 str_defaddr = ast_strdupa(ast_sockaddr_stringify_addr(&peer->defaddr));
3936 str_defport = ast_strdupa(ast_sockaddr_stringify_port(&peer->defaddr));
3937
3938 encmethods_to_str(peer->encmethods, &encmethods);
3939 ast_cli(a->fd, "\n\n");
3940 ast_cli(a->fd, " * Name : %s\n", peer->name);
3941 ast_cli(a->fd, " Description : %s\n", peer->description);
3942 ast_cli(a->fd, " Secret : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
3943 ast_cli(a->fd, " Context : %s\n", peer->context);
3944 ast_cli(a->fd, " Parking lot : %s\n", peer->parkinglot);
3945 ast_cli(a->fd, " Mailbox : %s\n", peer->mailbox);
3946 ast_cli(a->fd, " Dynamic : %s\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
3947 ast_cli(a->fd, " Callnum limit: %d\n", peer->maxcallno);
3948 ast_cli(a->fd, " Calltoken req: %s\n", (peer->calltoken_required == CALLTOKEN_YES) ? "Yes" : ((peer->calltoken_required == CALLTOKEN_AUTO) ? "Auto" : "No"));
3949 ast_cli(a->fd, " Trunk : %s\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
3950 ast_cli(a->fd, " Encryption : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
3951 ast_cli(a->fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
3952 ast_cli(a->fd, " Expire : %d\n", peer->expire);
3953 ast_cli(a->fd, " ACL : %s\n", (ast_acl_list_is_empty(peer->acl) ? "No" : "Yes"));
3954 ast_cli(a->fd, " Addr->IP : %s Port %s\n", str_addr ? str_addr : "(Unspecified)", str_port);
3955 ast_cli(a->fd, " Defaddr->IP : %s Port %s\n", str_defaddr, str_defport);
3956 ast_cli(a->fd, " Username : %s\n", peer->username);
3957 ast_cli(a->fd, " Codecs : %s\n", iax2_getformatname_multiple(peer->capability, &codec_buf));
3958
3959 if (iax2_codec_pref_string(&peer->prefs, cbuf, sizeof(cbuf)) < 0) {
3960 strcpy(cbuf, "Error"); /* Safe */
3961 }
3962 ast_cli(a->fd, " Codec Order : %s\n", cbuf);
3963
3964 peer_status(peer, status, sizeof(status));
3965 ast_cli(a->fd, " Status : %s\n", status);
3966 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");
3967 ast_cli(a->fd, "\n");
3968 peer_unref(peer);
3969 } else {
3970 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
3971 ast_cli(a->fd, "\n");
3972 }
3973
3974 return CLI_SUCCESS;
3975}

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 7326 of file chan_iax2.c.

7327{
7328 switch (cmd) {
7329 case CLI_INIT:
7330 e->command = "iax2 show peers";
7331 e->usage =
7332 "Usage: iax2 show peers [registered] [like <pattern>]\n"
7333 " Lists all known IAX2 peers.\n"
7334 " Optional 'registered' argument lists only peers with known addresses.\n"
7335 " Optional regular expression pattern is used to filter the peer list.\n";
7336 return NULL;
7337 case CLI_GENERATE:
7338 return NULL;
7339 }
7340
7341 switch (__iax2_show_peers(a->fd, NULL, NULL, a->argc, a->argv)) {
7342 case RESULT_SHOWUSAGE:
7343 return CLI_SHOWUSAGE;
7344 case RESULT_FAILURE:
7345 return CLI_FAILURE;
7346 default:
7347 return CLI_SUCCESS;
7348 }
7349}

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 7481 of file chan_iax2.c.

7482{
7483#define FORMAT2 "%-45.45s %-6.6s %-10.10s %-45.45s %8.8s %s\n"
7484#define FORMAT "%-45.45s %-6.6s %-10.10s %-45.45s %8d %s\n"
7485
7486 struct iax2_registry *reg = NULL;
7487 char host[80];
7488 char perceived[80];
7489 int counter = 0;
7490
7491 switch (cmd) {
7492 case CLI_INIT:
7493 e->command = "iax2 show registry";
7494 e->usage =
7495 "Usage: iax2 show registry\n"
7496 " Lists all registration requests and status.\n";
7497 return NULL;
7498 case CLI_GENERATE:
7499 return NULL;
7500 }
7501 if (a->argc != 3)
7502 return CLI_SHOWUSAGE;
7503 ast_cli(a->fd, FORMAT2, "Host", "dnsmgr", "Username", "Perceived", "Refresh", "State");
7504 AST_LIST_LOCK(&registrations);
7505 AST_LIST_TRAVERSE(&registrations, reg, entry) {
7506 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
7507
7508 snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
7509
7510 ast_cli(a->fd, FORMAT, host,
7511 (reg->dnsmgr) ? "Y" : "N",
7512 reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
7513 counter++;
7514 }
7515 AST_LIST_UNLOCK(&registrations);
7516 ast_cli(a->fd, "%d IAX2 registrations.\n", counter);
7517 return CLI_SUCCESS;
7518#undef FORMAT
7519#undef FORMAT2
7520}

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

4001{
4002 struct iax_frame *cur;
4003 int cnt = 0, dead = 0, final = 0, i = 0;
4004
4005 switch (cmd) {
4006 case CLI_INIT:
4007 e->command = "iax2 show stats";
4008 e->usage =
4009 "Usage: iax2 show stats\n"
4010 " Display statistics on IAX channel driver.\n";
4011 return NULL;
4012 case CLI_GENERATE:
4013 return NULL;
4014 }
4015
4016 if (a->argc != 3)
4017 return CLI_SHOWUSAGE;
4018
4019 for (i = 0; i < ARRAY_LEN(frame_queue); i++) {
4020 ast_mutex_lock(&iaxsl[i]);
4021 AST_LIST_TRAVERSE(&frame_queue[i], cur, list) {
4022 if (cur->retries < 0)
4023 dead++;
4024 if (cur->final)
4025 final++;
4026 cnt++;
4027 }
4028 ast_mutex_unlock(&iaxsl[i]);
4029 }
4030
4031 ast_cli(a->fd, " IAX Statistics\n");
4032 ast_cli(a->fd, "---------------------\n");
4033 ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
4034 ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
4035 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
4036 ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
4037
4038 trunk_timed = trunk_untimed = 0;
4039 if (trunk_maxmtu > trunk_nmaxmtu)
4040 trunk_nmaxmtu = trunk_maxmtu;
4041
4042 return CLI_SUCCESS;
4043}

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 7191 of file chan_iax2.c.

7192{
7193 struct iax2_thread *thread = NULL;
7194 time_t t;
7195 int threadcount = 0, dynamiccount = 0;
7196 char type;
7197
7198 switch (cmd) {
7199 case CLI_INIT:
7200 e->command = "iax2 show threads";
7201 e->usage =
7202 "Usage: iax2 show threads\n"
7203 " Lists status of IAX helper threads\n";
7204 return NULL;
7205 case CLI_GENERATE:
7206 return NULL;
7207 }
7208 if (a->argc != 3)
7209 return CLI_SHOWUSAGE;
7210
7211 ast_cli(a->fd, "IAX2 Thread Information\n");
7212 time(&t);
7213 ast_cli(a->fd, "Idle Threads:\n");
7214 AST_LIST_LOCK(&idle_list);
7215 AST_LIST_TRAVERSE(&idle_list, thread, list) {
7216#ifdef DEBUG_SCHED_MULTITHREAD
7217 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
7218 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7219#else
7220 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
7221 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7222#endif
7223 threadcount++;
7224 }
7225 AST_LIST_UNLOCK(&idle_list);
7226 ast_cli(a->fd, "Active Threads:\n");
7227 AST_LIST_LOCK(&active_list);
7228 AST_LIST_TRAVERSE(&active_list, thread, list) {
7229 if (thread->type == IAX_THREAD_TYPE_DYNAMIC)
7230 type = 'D';
7231 else
7232 type = 'P';
7233#ifdef DEBUG_SCHED_MULTITHREAD
7234 ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d, func='%s'\n",
7235 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7236#else
7237 ast_cli(a->fd, "Thread %c%d: state=%u, update=%d, actions=%d\n",
7238 type, thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7239#endif
7240 threadcount++;
7241 }
7242 AST_LIST_UNLOCK(&active_list);
7243 ast_cli(a->fd, "Dynamic Threads:\n");
7244 AST_LIST_LOCK(&dynamic_list);
7245 AST_LIST_TRAVERSE(&dynamic_list, thread, list) {
7246#ifdef DEBUG_SCHED_MULTITHREAD
7247 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d, func='%s'\n",
7248 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions, thread->curfunc);
7249#else
7250 ast_cli(a->fd, "Thread %d: state=%u, update=%d, actions=%d\n",
7251 thread->threadnum, thread->iostate, (int)(t - thread->checktime), thread->actions);
7252#endif
7253 dynamiccount++;
7254 }
7255 AST_LIST_UNLOCK(&dynamic_list);
7256 ast_cli(a->fd, "%d of %d threads accounted for with %d dynamic threads\n", threadcount, iaxthreadcount, dynamiccount);
7257 return CLI_SUCCESS;
7258}

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 6910 of file chan_iax2.c.

6911{
6912 regex_t regexbuf;
6913 int havepattern = 0;
6914
6915#define FORMAT "%-15.15s %-20.20s %-15.15s %-15.15s %-5.5s %-5.10s\n"
6916#define FORMAT2 "%-15.15s %-20.20s %-15.15d %-15.15s %-5.5s %-5.10s\n"
6917
6918 struct iax2_user *user = NULL;
6919 char auth[90];
6920 char *pstr = "";
6921 struct ao2_iterator i;
6922
6923 switch (cmd) {
6924 case CLI_INIT:
6925 e->command = "iax2 show users [like]";
6926 e->usage =
6927 "Usage: iax2 show users [like <pattern>]\n"
6928 " Lists all known IAX2 users.\n"
6929 " Optional regular expression pattern is used to filter the user list.\n";
6930 return NULL;
6931 case CLI_GENERATE:
6932 return NULL;
6933 }
6934
6935 switch (a->argc) {
6936 case 5:
6937 if (!strcasecmp(a->argv[3], "like")) {
6938 if (regcomp(&regexbuf, a->argv[4], REG_EXTENDED | REG_NOSUB))
6939 return CLI_SHOWUSAGE;
6940 havepattern = 1;
6941 } else
6942 return CLI_SHOWUSAGE;
6943 case 3:
6944 break;
6945 default:
6946 return CLI_SHOWUSAGE;
6947 }
6948
6949 ast_cli(a->fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C","Codec Pref");
6950 i = ao2_iterator_init(users, 0);
6951 for (; (user = ao2_iterator_next(&i)); user_unref(user)) {
6952 if (havepattern && regexec(&regexbuf, user->name, 0, NULL, 0))
6953 continue;
6954
6955 if (!ast_strlen_zero(user->secret)) {
6956 ast_copy_string(auth,user->secret, sizeof(auth));
6957 } else if (!ast_strlen_zero(user->inkeys)) {
6958 snprintf(auth, sizeof(auth), "Key: %-15.15s ", user->inkeys);
6959 } else
6960 ast_copy_string(auth, "-no secret-", sizeof(auth));
6961
6962 if(ast_test_flag64(user, IAX_CODEC_NOCAP))
6963 pstr = "REQ Only";
6964 else if(ast_test_flag64(user, IAX_CODEC_NOPREFS))
6965 pstr = "Disabled";
6966 else
6967 pstr = ast_test_flag64(user, IAX_CODEC_USER_FIRST) ? "Caller" : "Host";
6968
6969 ast_cli(a->fd, FORMAT2, user->name, auth, user->authmethods,
6970 user->contexts ? user->contexts->context : DEFAULT_CONTEXT,
6971 ast_acl_list_is_empty(user->acl) ? "No" : "Yes", pstr);
6972 }
6973 ao2_iterator_destroy(&i);
6974
6975 if (havepattern)
6976 regfree(&regexbuf);
6977
6978 return CLI_SUCCESS;
6979#undef FORMAT
6980#undef FORMAT2
6981}

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 3787 of file chan_iax2.c.

3788{
3789 switch (cmd) {
3790 case CLI_INIT:
3791 e->command = "iax2 test losspct";
3792 e->usage =
3793 "Usage: iax2 test losspct <percentage>\n"
3794 " For testing, throws away <percentage> percent of incoming packets\n";
3795 return NULL;
3796 case CLI_GENERATE:
3797 return NULL;
3798 }
3799 if (a->argc != 4)
3800 return CLI_SHOWUSAGE;
3801
3802 test_losspct = atoi(a->argv[3]);
3803
3804 return CLI_SUCCESS;
3805}

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 7260 of file chan_iax2.c.

7261{
7262 struct iax2_peer *p;
7263
7264 switch (cmd) {
7265 case CLI_INIT:
7266 e->command = "iax2 unregister";
7267 e->usage =
7268 "Usage: iax2 unregister <peername>\n"
7269 " Unregister (force expiration) an IAX2 peer from the registry.\n";
7270 return NULL;
7271 case CLI_GENERATE:
7272 return complete_iax2_unregister(a->line, a->word, a->pos, a->n);
7273 }
7274
7275 if (a->argc != 3)
7276 return CLI_SHOWUSAGE;
7277
7278 p = find_peer(a->argv[2], 1);
7279 if (p) {
7280 if (p->expire > -1) {
7281 struct iax2_peer *peer;
7282
7283 peer = ao2_find(peers, a->argv[2], OBJ_KEY);
7284 if (peer) {
7285 expire_registry(peer_ref(peer)); /* will release its own reference when done */
7286 peer_unref(peer); /* ref from ao2_find() */
7287 ast_cli(a->fd, "Peer %s unregistered\n", a->argv[2]);
7288 } else {
7289 ast_cli(a->fd, "Peer %s not found\n", a->argv[2]);
7290 }
7291 } else {
7292 ast_cli(a->fd, "Peer %s not registered\n", a->argv[2]);
7293 }
7294 peer_unref(p);
7295 } else {
7296 ast_cli(a->fd, "Peer unknown: %s. Not unregistered\n", a->argv[2]);
7297 }
7298 return CLI_SUCCESS;
7299}

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 9907 of file chan_iax2.c.

9908{
9909 struct iax2_pkt_buf *pkt_buf;
9910
9911 ast_mutex_lock(&thread->lock);
9912
9913 while ((pkt_buf = AST_LIST_REMOVE_HEAD(&thread->full_frames, entry))) {
9914 ast_mutex_unlock(&thread->lock);
9915
9916 thread->buf = pkt_buf->buf;
9917 thread->buf_len = pkt_buf->len;
9918 thread->buf_size = pkt_buf->len + 1;
9919
9920 socket_process(thread);
9921
9922 thread->buf = NULL;
9923 ast_free(pkt_buf);
9924
9925 ast_mutex_lock(&thread->lock);
9926 }
9927
9928 ast_mutex_unlock(&thread->lock);
9929}

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 3441 of file chan_iax2.c.

3442{
3443 /* XXX Ideally we should figure out why an error occurred and then abort those
3444 rather than continuing to try. Unfortunately, the published interface does
3445 not seem to work XXX */
3446#if 0
3447 struct sockaddr_in *sin;
3448 int res;
3449 struct msghdr m;
3450 struct sock_extended_err e;
3451 m.msg_name = NULL;
3452 m.msg_namelen = 0;
3453 m.msg_iov = NULL;
3454 m.msg_control = &e;
3455 m.msg_controllen = sizeof(e);
3456 m.msg_flags = 0;
3457 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
3458 if (res < 0)
3459 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
3460 else {
3461 if (m.msg_controllen) {
3462 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
3463 if (sin)
3464 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
3465 else
3466 ast_log(LOG_WARNING, "No address detected??\n");
3467 } else {
3468 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
3469 }
3470 }
3471#endif
3472 return 0;
3473}

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 8911 of file chan_iax2.c.

8912{
8913 struct iax2_registry *reg;
8914 /* Start pessimistic */
8915 char peer[256] = "";
8916 char msgstatus[60];
8917 int refresh = 60;
8918 char ourip[256] = "<Unspecified>";
8919 struct ast_sockaddr oldus;
8920 struct ast_sockaddr us;
8921 int oldmsgs;
8922
8923 if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
8924 ast_sockaddr_copy(&us, &ies->apparent_addr);
8925 }
8926 if (ies->username) {
8927 ast_copy_string(peer, ies->username, sizeof(peer));
8928 }
8929 if (ies->refresh) {
8930 refresh = ies->refresh;
8931 }
8932 if (ies->calling_number) {
8933 /* We don't do anything with it really, but maybe we should */
8934 }
8935 reg = iaxs[callno]->reg;
8936 if (!reg) {
8937 ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
8938 return -1;
8939 }
8940 ast_sockaddr_copy(&oldus, &reg->us);
8941 oldmsgs = reg->messages;
8942 if (ast_sockaddr_cmp(&reg->addr, addr)) {
8943 ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", ast_sockaddr_stringify(addr));
8944 return -1;
8945 }
8946 ast_sockaddr_copy(&reg->us, &us);
8947 if (ies->msgcount >= 0) {
8948 reg->messages = ies->msgcount & 0xffff; /* only low 16 bits are used in the transmission of the IE */
8949 }
8950 /* always refresh the registration at the interval requested by the server
8951 we are registering to
8952 */
8953 reg->refresh = refresh;
8954 reg->expire = iax2_sched_replace(reg->expire, sched,
8955 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
8956 if (ast_sockaddr_cmp(&oldus, &reg->us) || (reg->messages != oldmsgs)) {
8957
8958 if (reg->messages > 255) {
8959 snprintf(msgstatus, sizeof(msgstatus), " with %d new and %d old messages waiting", reg->messages & 0xff, reg->messages >> 8);
8960 } else if (reg->messages > 1) {
8961 snprintf(msgstatus, sizeof(msgstatus), " with %d new messages waiting", reg->messages);
8962 } else if (reg->messages > 0) {
8963 ast_copy_string(msgstatus, " with 1 new message waiting", sizeof(msgstatus));
8964 } else {
8965 ast_copy_string(msgstatus, " with no messages waiting", sizeof(msgstatus));
8966 }
8967
8968 snprintf(ourip, sizeof(ourip), "%s", ast_sockaddr_stringify(&reg->us));
8969
8970 ast_verb(3, "Registered IAX2 to '%s', who sees us as %s%s\n", ast_sockaddr_stringify(addr), ourip, msgstatus);
8971 iax2_publish_registry(reg->username, ast_sockaddr_stringify(addr), "Registered", NULL);
8972 }
8973 reg->regstate = REG_STATE_REGISTERED;
8974 return 0;
8975}

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 3171 of file chan_iax2.c.

3172{
3173 if (frametype != AST_FRAME_IAX) {
3174 return 0;
3175 }
3176 switch (subclass) {
3177 case IAX_COMMAND_NEW:
3178 case IAX_COMMAND_REGREQ:
3179 case IAX_COMMAND_FWDOWNL:
3180 case IAX_COMMAND_REGREL:
3181 return 1;
3182 case IAX_COMMAND_POKE:
3183 if (!inbound) {
3184 return 1;
3185 }
3186 break;
3187 }
3188 return 0;
3189}

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 5857 of file chan_iax2.c.

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

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 8977 of file chan_iax2.c.

8979{
8980 struct iax2_registry *reg;
8981
8982 if (!(reg = ast_calloc(1, sizeof(*reg) + strlen(hostname) + 1))) {
8983 return -1;
8984 }
8985
8986 reg->addr.ss.ss_family = AST_AF_UNSPEC;
8987 if (ast_dnsmgr_lookup(hostname, &reg->addr, &reg->dnsmgr, srvlookup ? "_iax._udp" : NULL) < 0) {
8988 ast_free(reg);
8989 return -1;
8990 }
8991
8992 ast_copy_string(reg->username, username, sizeof(reg->username));
8993 strcpy(reg->hostname, hostname); /* Note: This is safe */
8994
8995 if (secret) {
8996 ast_copy_string(reg->secret, secret, sizeof(reg->secret));
8997 }
8998
8999 reg->expire = -1;
9000 reg->refresh = IAX_DEFAULT_REG_EXPIRE;
9001
9002 reg->port = ast_sockaddr_port(&reg->addr);
9003
9004 if (!porta && !reg->port) {
9005 reg->port = IAX_DEFAULT_PORTNO;
9006 } else if (porta) {
9007 sscanf(porta, "%5d", &reg->port);
9008 }
9009
9010 ast_sockaddr_set_port(&reg->addr, reg->port);
9011
9012 AST_LIST_LOCK(&registrations);
9013 AST_LIST_INSERT_HEAD(&registrations, reg, entry);
9014 AST_LIST_UNLOCK(&registrations);
9015
9016 return 0;
9017}

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 5205 of file chan_iax2.c.

5206{
5207 struct ast_sockaddr addr;
5208 char *l=NULL, *n=NULL, *tmpstr;
5209 struct iax_ie_data ied;
5210 char *defaultrdest = "s";
5211 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5212 struct parsed_dial_string pds;
5213 struct create_addr_info cai;
5214 struct ast_var_t *var;
5215 struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
5216 const char* osp_token_ptr;
5217 unsigned int osp_token_length;
5218 unsigned char osp_block_index;
5219 unsigned int osp_block_length;
5220 unsigned char osp_buffer[256];
5221 char encoded_prefs[32];
5222 iax2_format iax2_tmpfmt;
5223
5224 if ((ast_channel_state(c) != AST_STATE_DOWN) && (ast_channel_state(c) != AST_STATE_RESERVED)) {
5225 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", ast_channel_name(c));
5226 return -1;
5227 }
5228
5229 memset(&cai, 0, sizeof(cai));
5230 cai.encmethods = iax2_encryption;
5231 cai.authmethods = iax2_authmethods;
5232
5233 memset(&pds, 0, sizeof(pds));
5234 tmpstr = ast_strdupa(dest);
5235 parse_dial_string(tmpstr, &pds);
5236
5237 if (ast_strlen_zero(pds.peer)) {
5238 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", dest);
5239 return -1;
5240 }
5241 if (!pds.exten) {
5242 pds.exten = defaultrdest;
5243 }
5244 if (create_addr(pds.peer, c, &addr, &cai)) {
5245 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
5246 return -1;
5247 }
5248
5249 if (ast_test_flag64(&cai, IAX_FORCE_ENCRYPT) ||
5250 ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT)) {
5251 if (!cai.encmethods) {
5252 ast_log(LOG_WARNING, "Encryption forced for call, but not enabled\n");
5253 ast_channel_hangupcause_set(c, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
5254 return -1;
5255 }
5256 if (((cai.authmethods & IAX_AUTH_RSA) || (cai.authmethods & IAX_AUTH_MD5) || (cai.authmethods & IAX_AUTH_PLAINTEXT)) &&
5257 ast_strlen_zero(cai.secret) && ast_strlen_zero(pds.password)) {
5258 ast_log(LOG_WARNING, "Call terminated. Encryption forced but no secret provided\n");
5259 return -1;
5260 }
5261 }
5262
5263 if (!pds.username && !ast_strlen_zero(cai.username))
5264 pds.username = cai.username;
5265 if (!pds.password && !ast_strlen_zero(cai.secret))
5266 pds.password = cai.secret;
5267 if (!pds.key && !ast_strlen_zero(cai.outkey))
5268 pds.key = cai.outkey;
5269 if (!pds.context && !ast_strlen_zero(cai.peercontext))
5270 pds.context = cai.peercontext;
5271
5272 /* Keep track of the context for outgoing calls too */
5273 ast_channel_context_set(c, cai.context);
5274
5275 if (pds.port) {
5276 int bindport;
5277 if (ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
5278 ast_sockaddr_set_port(&addr, bindport);
5279 }
5280 }
5281
5282 l = ast_channel_connected(c)->id.number.valid ? ast_channel_connected(c)->id.number.str : NULL;
5283 n = ast_channel_connected(c)->id.name.valid ? ast_channel_connected(c)->id.name.str : NULL;
5284
5285 /* Now build request */
5286 memset(&ied, 0, sizeof(ied));
5287
5288 /* On new call, first IE MUST be IAX version of caller */
5289 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
5290 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
5291 if (pds.options && strchr(pds.options, 'a')) {
5292 /* Request auto answer */
5293 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
5294 }
5295
5296 /* WARNING: this breaks down at 190 bits! */
5297 iax2_codec_pref_convert(&cai.prefs, encoded_prefs, sizeof(encoded_prefs), 1);
5298 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, encoded_prefs);
5299
5300 if (l) {
5301 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
5302 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
5303 ast_party_id_presentation(&ast_channel_connected(c)->id));
5304 } else if (n) {
5305 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES,
5306 ast_party_id_presentation(&ast_channel_connected(c)->id));
5307 } else {
5308 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
5309 }
5310
5311 iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, ast_channel_connected(c)->id.number.plan);
5312 iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, ast_channel_dialed(c)->transit_network_select);
5313 iax_ie_append_int(&ied, IAX_IE_CALLINGANI2, ast_channel_connected(c)->ani2);
5314
5315 if (n)
5316 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
5317 if (ast_test_flag64(iaxs[callno], IAX_SENDANI)
5318 && ast_channel_connected(c)->ani.number.valid
5319 && ast_channel_connected(c)->ani.number.str) {
5320 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, ast_channel_connected(c)->ani.number.str);
5321 }
5322
5323 if (!ast_strlen_zero(ast_channel_language(c)))
5324 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, ast_channel_language(c));
5325 if (!ast_strlen_zero(ast_channel_dialed(c)->number.str)) {
5326 iax_ie_append_str(&ied, IAX_IE_DNID, ast_channel_dialed(c)->number.str);
5327 }
5328 if (ast_channel_redirecting(c)->from.number.valid
5329 && !ast_strlen_zero(ast_channel_redirecting(c)->from.number.str)) {
5330 iax_ie_append_str(&ied, IAX_IE_RDNIS, ast_channel_redirecting(c)->from.number.str);
5331 }
5332
5333 if (pds.context)
5334 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
5335
5336 if (pds.username)
5337 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
5338
5339 if (cai.encmethods)
5340 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
5341
5342 ast_mutex_lock(&iaxsl[callno]);
5343
5344 if (!ast_strlen_zero(ast_channel_context(c)))
5345 ast_string_field_set(iaxs[callno], context, ast_channel_context(c));
5346
5347 if (pds.username)
5348 ast_string_field_set(iaxs[callno], username, pds.username);
5349
5350 iaxs[callno]->encmethods = cai.encmethods;
5351
5352 iaxs[callno]->adsi = cai.adsi;
5353
5354 ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
5355 ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
5356
5357 if (pds.key)
5358 ast_string_field_set(iaxs[callno], outkey, pds.key);
5359 if (pds.password)
5360 ast_string_field_set(iaxs[callno], secret, pds.password);
5361
5362 iax2_tmpfmt = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(c));
5363 iax_ie_append_int(&ied, IAX_IE_FORMAT, (int) iax2_tmpfmt);
5364 iax_ie_append_versioned_uint64(&ied, IAX_IE_FORMAT2, 0, iax2_tmpfmt);
5365
5366 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, (int) iaxs[callno]->capability);
5367 iax_ie_append_versioned_uint64(&ied, IAX_IE_CAPABILITY2, 0, iaxs[callno]->capability);
5368 iax_ie_append_short(&ied, IAX_IE_ADSICPE, ast_channel_adsicpe(c));
5369 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
5370
5371 if (iaxs[callno]->maxtime) {
5372 /* Initialize pingtime and auto-congest time */
5373 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
5374 iaxs[callno]->initid = iax2_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
5375 } else if (autokill) {
5376 iaxs[callno]->pingtime = autokill / 2;
5377 iaxs[callno]->initid = iax2_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
5378 }
5379
5380 /* Check if there is an OSP token */
5381 osp_token_ptr = pbx_builtin_getvar_helper(c, "IAX2OSPTOKEN");
5382 if (!ast_strlen_zero(osp_token_ptr)) {
5383 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
5384 osp_block_index = 0;
5385 while (osp_token_length > 0) {
5386 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
5387 osp_buffer[0] = osp_block_index;
5388 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
5389 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
5390 osp_block_index++;
5391 osp_token_ptr += osp_block_length;
5392 osp_token_length -= osp_block_length;
5393 }
5394 } else
5395 ast_log(LOG_WARNING, "OSP token is too long\n");
5396 } else if (iaxdebug)
5397 ast_debug(1, "OSP token is undefined\n");
5398
5399 /* send the command using the appropriate socket for this peer */
5400 iaxs[callno]->sockfd = cai.sockfd;
5401
5402 /* Add remote vars */
5403 if (variablestore) {
5404 AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
5405 ast_debug(1, "Found an IAX variable store on this channel\n");
5406 AST_LIST_LOCK(variablelist);
5407 AST_LIST_TRAVERSE(variablelist, var, entries) {
5408 char tmp[256];
5409 int i;
5410 ast_debug(1, "Found IAXVAR '%s' with value '%s' (to transmit)\n", ast_var_name(var), ast_var_value(var));
5411 /* Automatically divide the value up into sized chunks */
5412 for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) + 1)) {
5413 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var), ast_var_value(var) + i);
5414 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
5415 }
5416 }
5417 AST_LIST_UNLOCK(variablelist);
5418 }
5419
5420 /* Transmit the string in a "NEW" request */
5421 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
5422 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
5423
5424 ast_mutex_unlock(&iaxsl[callno]);
5425 ast_setstate(c, AST_STATE_RINGING);
5426
5427 return 0;
5428}

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, 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 14455 of file chan_iax2.c.

14456{
14457 int res = 0;
14458 struct iax2_dpcache *dp = NULL;
14459#if 0
14460 ast_log(LOG_NOTICE, "iax2_canmatch: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14461#endif
14462 if ((priority != 1) && (priority != 2))
14463 return 0;
14464
14465 AST_LIST_LOCK(&dpcache);
14466 if ((dp = find_cache(chan, data, context, exten, priority))) {
14467 if (dp->flags & CACHE_FLAG_CANEXIST)
14468 res = 1;
14469 } else {
14470 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14471 }
14472 AST_LIST_UNLOCK(&dpcache);
14473
14474 return res;
14475}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_CANEXIST, 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 1967 of file chan_iax2.c.

1968{
1969 struct ast_format_cap *cap;
1970 struct ast_format *tmpfmt;
1971 iax2_format format = 0;
1972
1973 if ((cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
1974 iax2_format_compatibility_bitfield2cap(formats, cap);
1975 tmpfmt = codec_choose_from_prefs(pref, cap);
1976 if (!tmpfmt) {
1977 ao2_ref(cap, -1);
1978 return 0;
1979 }
1980
1981 format = ast_format_compatibility_format2bitfield(tmpfmt);
1982 ao2_ref(tmpfmt, -1);
1983 ao2_ref(cap, -1);
1984 }
1985
1986 return format;
1987}

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 4857 of file chan_iax2.c.

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

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 2163 of file chan_iax2.c.

2164{
2165 int sched_id = (int)(long)data;
2166
2167 AST_SCHED_DEL(sched, sched_id);
2168
2169 return 0;
2170}

References AST_SCHED_DEL.

Referenced by iax2_destroy_helper().

◆ iax2_destroy()

static void iax2_destroy ( int  callno)
static

Definition at line 3545 of file chan_iax2.c.

3546{
3547 struct chan_iax2_pvt *pvt = NULL;
3548 struct ast_channel *owner = NULL;
3549
3550retry:
3551 if ((pvt = iaxs[callno])) {
3552#if 0
3553 /* iax2_destroy_helper gets called from this function later on. When
3554 * called twice, we get the (previously) familiar FRACK! errors in
3555 * devmode, from the scheduler. An alternative to this approach is to
3556 * reset the scheduler entries to -1 when they're deleted in
3557 * iax2_destroy_helper(). That approach was previously decided to be
3558 * "wrong" because "the memory is going to be deallocated anyway. Why
3559 * should we be resetting those values?" */
3560 iax2_destroy_helper(pvt);
3561#endif
3562 }
3563
3564 owner = pvt ? pvt->owner : NULL;
3565
3566 if (owner) {
3567 if (ast_channel_trylock(owner)) {
3568 ast_debug(3, "Avoiding IAX destroy deadlock\n");
3569 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
3570 goto retry;
3571 }
3572 }
3573
3574 if (!owner) {
3575 iaxs[callno] = NULL;
3576 }
3577
3578 if (pvt) {
3579 if (!owner) {
3580 pvt->owner = NULL;
3581 } else {
3582 /* If there's an owner, prod it to give up */
3583 /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
3584 * because we already hold the owner channel lock. */
3585 ast_queue_hangup(owner);
3586 }
3587
3588 if (pvt->peercallno) {
3589 remove_by_peercallno(pvt);
3590 }
3591
3592 if (pvt->transfercallno) {
3593 remove_by_transfercallno(pvt);
3594 }
3595
3596 if (!owner) {
3597 ao2_ref(pvt, -1);
3598 pvt = NULL;
3599 }
3600 }
3601
3602 if (owner) {
3603 ast_channel_unlock(owner);
3604 }
3605}

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 2174 of file chan_iax2.c.

2175{
2176 /* Decrement AUTHREQ count if needed */
2177 if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
2178 struct iax2_user *user;
2179
2180 user = ao2_find(users, pvt->username, OBJ_KEY);
2181 if (user) {
2182 ast_atomic_fetchadd_int(&user->curauthreq, -1);
2183 user_unref(user);
2184 }
2185
2186 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
2187 }
2188
2189
2190 /* Mark call destroy initiated flag. */
2191 pvt->destroy_initiated = 1;
2192
2193 /*
2194 * Schedule deleting the scheduled (but didn't run yet) PINGs or LAGRQs.
2195 * Already running tasks will be terminated because of destroy_initiated.
2196 *
2197 * Don't call AST_SCHED_DEL from this thread for pingid and lagid because
2198 * it leads to a deadlock between the scheduler thread callback locking
2199 * the callno mutex and this thread which holds the callno mutex one or
2200 * more times. It is better to have another thread delete the scheduled
2201 * callbacks which doesn't lock the callno mutex.
2202 */
2203 iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->pingid);
2204 iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->lagid);
2205
2206 pvt->pingid = -1;
2207 pvt->lagid = -1;
2208
2209 AST_SCHED_DEL(sched, pvt->autoid);
2210 AST_SCHED_DEL(sched, pvt->authid);
2211 AST_SCHED_DEL(sched, pvt->initid);
2212 AST_SCHED_DEL(sched, pvt->jbid);
2213 AST_SCHED_DEL(sched, pvt->keyrotateid);
2214}

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_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 14667 of file chan_iax2.c.

14668{
14669 struct parsed_dial_string pds;
14670 char *tmp = ast_strdupa(data);
14671 struct iax2_peer *p;
14672 int res = AST_DEVICE_INVALID;
14673
14674 memset(&pds, 0, sizeof(pds));
14675 parse_dial_string(tmp, &pds);
14676
14677 if (ast_strlen_zero(pds.peer)) {
14678 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
14679 return res;
14680 }
14681
14682 ast_debug(3, "Checking device state for device %s\n", pds.peer);
14683
14684 /* SLD: FIXME: second call to find_peer during registration */
14685 if (!(p = find_peer(pds.peer, 1)))
14686 return res;
14687
14688 res = AST_DEVICE_UNAVAILABLE;
14689
14690 ast_debug(3, "Found peer. What's device state of %s? addr=%s, defaddr=%s maxms=%d, lastms=%d\n",
14691 pds.peer, ast_sockaddr_stringify(&p->addr), ast_sockaddr_stringify(&p->defaddr), p->maxms, p->lastms);
14692
14693 if (((!ast_sockaddr_isnull(&p->addr)) || (!ast_sockaddr_isnull(&p->defaddr))) &&
14694 (!p->maxms || ((p->lastms > -1) && (p->historicms <= p->maxms)))) {
14695 /* Peer is registered, or have default IP address
14696 and a valid registration */
14697 if (p->historicms == 0 || p->historicms <= p->maxms)
14698 /* let the core figure out whether it is in use or not */
14699 res = AST_DEVICE_UNKNOWN;
14700 }
14701
14702 peer_unref(p);
14703
14704 return res;
14705}

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 4427 of file chan_iax2.c.

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

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 4432 of file chan_iax2.c.

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

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 12381 of file chan_iax2.c.

12382{
12383 struct iax_ie_data ied;
12384 if (iaxdebug)
12385 ast_debug(1, "Sending registration request for '%s'\n", reg->username);
12386
12387 if (reg->dnsmgr &&
12388 ((reg->regstate == REG_STATE_TIMEOUT) || ast_sockaddr_isnull(&reg->addr))) {
12389 /* Maybe the IP has changed, force DNS refresh */
12390 ast_dnsmgr_refresh(reg->dnsmgr);
12391 }
12392
12393 /*
12394 * if IP has Changed, free allocated call to create a new one with new IP
12395 * call has the pointer to IP and must be updated to the new one
12396 */
12397 if (reg->dnsmgr && ast_dnsmgr_changed(reg->dnsmgr) && (reg->callno > 0)) {
12398 int callno = reg->callno;
12399 ast_mutex_lock(&iaxsl[callno]);
12400 iax2_destroy(callno);
12401 ast_mutex_unlock(&iaxsl[callno]);
12402 reg->callno = 0;
12403 }
12404 if (ast_sockaddr_isnull(&reg->addr)) {
12405 if (iaxdebug)
12406 ast_debug(1, "Unable to send registration request for '%s' without IP address\n", reg->username);
12407 /* Setup the next registration attempt */
12408 reg->expire = iax2_sched_replace(reg->expire, sched,
12409 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
12410 return -1;
12411 }
12412 if (!ast_sockaddr_port(&reg->addr) && reg->port) {
12413 ast_sockaddr_set_port(&reg->addr, reg->port);
12414 }
12415
12416 if (!reg->callno) {
12417
12418 ast_debug(3, "Allocate call number\n");
12419
12420 reg->callno = find_callno_locked(0, 0, &reg->addr, NEW_FORCE, defaultsockfd, 0);
12421 if (reg->callno < 1) {
12422 ast_log(LOG_WARNING, "Unable to create call for registration\n");
12423 return -1;
12424 } else
12425 ast_debug(3, "Registration created on call %d\n", reg->callno);
12426 iaxs[reg->callno]->reg = reg;
12427 ast_mutex_unlock(&iaxsl[reg->callno]);
12428 }
12429 /* Setup the next registration a little early */
12430 reg->expire = iax2_sched_replace(reg->expire, sched,
12431 (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
12432 /* Send the request */
12433 memset(&ied, 0, sizeof(ied));
12434 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
12435 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
12436 add_empty_calltoken_ie(iaxs[reg->callno], &ied); /* this _MUST_ be the last ie added */
12437 send_command(iaxs[reg->callno],AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
12438 reg->regstate = REG_STATE_REGSENT;
12439 return 0;
12440}

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 8754 of file chan_iax2.c.

8755{
8756#ifdef SCHED_MULTITHREADED
8757 if (schedule_action(__iax2_do_register_s, data))
8758#endif
8759 __iax2_do_register_s(data);
8760 return 0;
8761}

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 9556 of file chan_iax2.c.

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

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 1614 of file chan_iax2.c.

1615{
1616 AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1617 struct ast_var_t *oldvar, *newvar;
1618
1619 newlist = ast_calloc(sizeof(*newlist), 1);
1620 if (!newlist) {
1621 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1622 return NULL;
1623 }
1624
1625 AST_LIST_HEAD_INIT(newlist);
1626 AST_LIST_LOCK(oldlist);
1627 AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1628 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1629 if (newvar)
1630 AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1631 else
1632 ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1633 }
1634 AST_LIST_UNLOCK(oldlist);
1635 return newlist;
1636}

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 14501 of file chan_iax2.c.

14502{
14503 char odata[256];
14504 char req[sizeof(odata) + AST_MAX_CONTEXT + AST_MAX_EXTENSION + sizeof("IAX2//@")];
14505 char *ncontext;
14506 struct iax2_dpcache *dp = NULL;
14507 struct ast_app *dial = NULL;
14508#if 0
14509 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);
14510#endif
14511 if (priority == 2) {
14512 /* Indicate status, can be overridden in dialplan */
14513 const char *dialstatus = pbx_builtin_getvar_helper(chan, "DIALSTATUS");
14514 if (dialstatus) {
14515 dial = pbx_findapp(dialstatus);
14516 if (dial)
14517 pbx_exec(chan, dial, "");
14518 }
14519 return -1;
14520 } else if (priority != 1)
14521 return -1;
14522
14523 AST_LIST_LOCK(&dpcache);
14524 if ((dp = find_cache(chan, data, context, exten, priority))) {
14525 if (dp->flags & CACHE_FLAG_EXISTS) {
14526 ast_copy_string(odata, data, sizeof(odata));
14527 ncontext = strchr(odata, '/');
14528 if (ncontext) {
14529 *ncontext = '\0';
14530 ncontext++;
14531 snprintf(req, sizeof(req), "IAX2/%s/%s@%s", odata, exten, ncontext);
14532 } else {
14533 snprintf(req, sizeof(req), "IAX2/%s/%s", odata, exten);
14534 }
14535 ast_verb(3, "Executing Dial('%s')\n", req);
14536 } else {
14537 AST_LIST_UNLOCK(&dpcache);
14538 ast_log(LOG_WARNING, "Can't execute nonexistent extension '%s[@%s]' in data '%s'\n", exten, context, data);
14539 return -1;
14540 }
14541 }
14542 AST_LIST_UNLOCK(&dpcache);
14543
14544 if ((dial = pbx_findapp("Dial")))
14545 return pbx_exec(chan, dial, req);
14546 else
14547 ast_log(LOG_WARNING, "No dial application registered\n");
14548
14549 return -1;
14550}

References ast_copy_string(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_verb, CACHE_FLAG_EXISTS, 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 14432 of file chan_iax2.c.

14433{
14434 int res = 0;
14435 struct iax2_dpcache *dp = NULL;
14436#if 0
14437 ast_log(LOG_NOTICE, "iax2_exists: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14438#endif
14439 if ((priority != 1) && (priority != 2))
14440 return 0;
14441
14442 AST_LIST_LOCK(&dpcache);
14443 if ((dp = find_cache(chan, data, context, exten, priority))) {
14444 if (dp->flags & CACHE_FLAG_EXISTS)
14445 res = 1;
14446 } else {
14447 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14448 }
14449 AST_LIST_UNLOCK(&dpcache);
14450
14451 return res;
14452}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_EXISTS, 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 4454 of file chan_iax2.c.

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

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 2216 of file chan_iax2.c.

2217{
2218 AST_SCHED_DEL(sched, fr->retrans);
2219 iax_frame_free(fr);
2220}

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 1638 of file chan_iax2.c.

1639{
1640 AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1641 struct ast_var_t *oldvar;
1642
1643 AST_LIST_LOCK(oldlist);
1644 while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1645 ast_free(oldvar);
1646 }
1647 AST_LIST_UNLOCK(oldlist);
1648 AST_LIST_HEAD_DESTROY(oldlist);
1649 ast_free(oldlist);
1650}

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 1989 of file chan_iax2.c.

1990{
1991 struct ast_format *tmpfmt;
1992
1993 tmpfmt = ast_format_compatibility_bitfield2format(format);
1994 if (!tmpfmt) {
1995 return "Unknown";
1996 }
1997
1998 return ast_format_get_name(tmpfmt);
1999}

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 2001 of file chan_iax2.c.

2002{
2003 struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
2004
2005 if (!cap) {
2006 return "(Nothing)";
2007 }
2008 iax2_format_compatibility_bitfield2cap(format, cap);
2009 ast_format_cap_get_names(cap, codec_buf);
2010 ao2_ref(cap, -1);
2011
2012 return ast_str_buffer(*codec_buf);
2013}

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 2131 of file chan_iax2.c.

2132{
2133 struct iax2_peer *peer = NULL;
2134 int res = 0;
2135 struct ao2_iterator i;
2136
2137 i = ao2_iterator_init(peers, 0);
2138 while ((peer = ao2_iterator_next(&i))) {
2139
2140 if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
2141 ast_copy_string(host, peer->name, len);
2142 peer_unref(peer);
2143 res = 1;
2144 break;
2145 }
2146 peer_unref(peer);
2147 }
2148 ao2_iterator_destroy(&i);
2149
2150 if (!peer) {
2151 peer = realtime_peer(NULL, &addr);
2152 if (peer) {
2153 ast_copy_string(host, peer->name, len);
2154 peer_unref(peer);
2155 res = 1;
2156 }
2157 }
2158
2159 return res;
2160}

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 5937 of file chan_iax2.c.

5938{
5939 struct iax2_peer *peer;
5940 int res = 0;
5941 struct ao2_iterator i;
5942
5943 i = ao2_iterator_init(peers, 0);
5944 while ((peer = ao2_iterator_next(&i))) {
5945
5946 if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
5947 res = ast_test_flag64(peer, IAX_TRUNK);
5948 peer_unref(peer);
5949 break;
5950 }
5951 peer_unref(peer);
5952 }
5953 ao2_iterator_destroy(&i);
5954
5955 return res;
5956}

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 5430 of file chan_iax2.c.

5431{
5432 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5433 struct iax_ie_data ied;
5434 int alreadygone;
5435 memset(&ied, 0, sizeof(ied));
5436 ast_mutex_lock(&iaxsl[callno]);
5437 if (callno && iaxs[callno]) {
5438 ast_debug(1, "We're hanging up %s now...\n", ast_channel_name(c));
5439 alreadygone = ast_test_flag64(iaxs[callno], IAX_ALREADYGONE);
5440 /* Send the hangup unless we have had a transmission error or are already gone */
5441 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)ast_channel_hangupcause(c));
5442 if (!iaxs[callno]->error && !alreadygone) {
5443 if (send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1)) {
5444 ast_log(LOG_WARNING, "No final packet could be sent for callno %d\n", callno);
5445 }
5446 if (!iaxs[callno]) {
5447 ast_mutex_unlock(&iaxsl[callno]);
5448 return 0;
5449 }
5450 }
5451 /* Explicitly predestroy it */
5452 iax2_predestroy(callno);
5453 /* If we were already gone to begin with, destroy us now */
5454 if (iaxs[callno] && alreadygone) {
5455 ast_debug(1, "Really destroying %s now...\n", ast_channel_name(c));
5456 iax2_destroy(callno);
5457 } else if (iaxs[callno]) {
5458 if (ast_sched_add(sched, 10000, scheduled_destroy, CALLNO_TO_PTR(callno)) < 0) {
5459 ast_log(LOG_ERROR, "Unable to schedule iax2 callno %d destruction?!! Destroying immediately.\n", callno);
5460 iax2_destroy(callno);
5461 }
5462 }
5463 } else if (ast_channel_tech_pvt(c)) {
5464 /* If this call no longer exists, but the channel still
5465 * references it we need to set the channel's tech_pvt to null
5466 * to avoid ast_channel_free() trying to free it.
5467 */
5468 ast_channel_tech_pvt_set(c, NULL);
5469 }
5470 ast_mutex_unlock(&iaxsl[callno]);
5471 ast_verb(3, "Hungup '%s'\n", ast_channel_name(c));
5472 return 0;
5473}

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 5864 of file chan_iax2.c.

5865{
5866 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5867 struct chan_iax2_pvt *pvt;
5868 int res = 0;
5869
5870 if (iaxdebug)
5871 ast_debug(1, "Indicating condition %d\n", condition);
5872
5873 ast_mutex_lock(&iaxsl[callno]);
5874 pvt = iaxs[callno];
5875
5876 if (wait_for_peercallno(pvt)) {
5877 res = -1;
5878 goto done;
5879 }
5880
5881 switch (condition) {
5882 case AST_CONTROL_HOLD:
5883 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
5884 ast_moh_start(c, data, pvt->mohinterpret);
5885 goto done;
5886 }
5887 break;
5888 case AST_CONTROL_UNHOLD:
5889 if (strcasecmp(pvt->mohinterpret, "passthrough")) {
5890 ast_moh_stop(c);
5891 goto done;
5892 }
5893 break;
5894 case AST_CONTROL_CONNECTED_LINE:
5895 case AST_CONTROL_REDIRECTING:
5896 if (!ast_test_flag64(pvt, IAX_SENDCONNECTEDLINE)) {
5897 /* We are not configured to allow sending these updates. */
5898 ast_debug(2, "Callno %d: Config blocked sending control frame %d.\n",
5899 callno, condition);
5900 goto done;
5901 }
5902 break;
5903 case AST_CONTROL_PVT_CAUSE_CODE:
5904 case AST_CONTROL_MASQUERADE_NOTIFY:
5905 res = -1;
5906 goto done;
5907 }
5908
5909 res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
5910
5911done:
5912 ast_mutex_unlock(&iaxsl[callno]);
5913
5914 return res;
5915}

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 1443 of file chan_iax2.c.

1444{
1445 enum ast_control_frame_type control = subtype;
1446 int is_allowed;
1447
1448 /*
1449 * Note: If we compare the enumeration type, which does not have any
1450 * negative constants, the compiler may optimize this code away.
1451 * Therefore, we must perform an integer comparison here.
1452 */
1453 if (subtype == -1) {
1454 return -1;
1455 }
1456
1457 /* Default to not allowing control frames to pass. */
1458 is_allowed = 0;
1459
1460 /*
1461 * The switch default is not present in order to take advantage
1462 * of the compiler complaining of a missing enum case.
1463 */
1464 switch (control) {
1465 /*
1466 * These control frames make sense to send/receive across the link.
1467 */
1468 case AST_CONTROL_HANGUP:
1469 case AST_CONTROL_RING:
1470 case AST_CONTROL_RINGING:
1471 case AST_CONTROL_ANSWER:
1472 case AST_CONTROL_BUSY:
1473 case AST_CONTROL_TAKEOFFHOOK:
1474 case AST_CONTROL_OFFHOOK:
1475 case AST_CONTROL_CONGESTION:
1476 case AST_CONTROL_FLASH:
1477 case AST_CONTROL_WINK:
1478 case AST_CONTROL_OPTION:
1479 case AST_CONTROL_RADIO_KEY:
1480 case AST_CONTROL_RADIO_UNKEY:
1481 case AST_CONTROL_PROGRESS:
1482 case AST_CONTROL_PROCEEDING:
1483 case AST_CONTROL_HOLD:
1484 case AST_CONTROL_UNHOLD:
1485 case AST_CONTROL_VIDUPDATE:
1486 case AST_CONTROL_CONNECTED_LINE:
1487 case AST_CONTROL_REDIRECTING:
1488 case AST_CONTROL_T38_PARAMETERS:
1489 case AST_CONTROL_AOC:
1490 case AST_CONTROL_INCOMPLETE:
1491 case AST_CONTROL_MCID:
1492 is_allowed = -1;
1493 break;
1494
1495 /*
1496 * These control frames do not make sense to send/receive across the link.
1497 */
1498 case _XXX_AST_CONTROL_T38:
1499 /* The control value is deprecated in favor of AST_CONTROL_T38_PARAMETERS. */
1500 case AST_CONTROL_SRCUPDATE:
1501 /* Across an IAX link the source is still the same. */
1502 case AST_CONTROL_TRANSFER:
1503 /* A success/fail status report from calling ast_transfer() on this machine. */
1504 case AST_CONTROL_CC:
1505 /* The payload contains pointers that are valid for the sending machine only. */
1506 case AST_CONTROL_SRCCHANGE:
1507 /* Across an IAX link the source is still the same. */
1508 case AST_CONTROL_READ_ACTION:
1509 /* The action can only be done by the sending machine. */
1510 case AST_CONTROL_END_OF_Q:
1511 /* This frame would cause the call to unexpectedly hangup. */
1512 case AST_CONTROL_UPDATE_RTP_PEER:
1513 /* Only meaningful across a bridge on this machine for direct-media exchange. */
1514 case AST_CONTROL_PVT_CAUSE_CODE:
1515 /* Intended only for the sending machine's local channel structure. */
1516 case AST_CONTROL_MASQUERADE_NOTIFY:
1517 /* Intended only for masquerades when calling ast_indicate_data(). */
1518 case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
1519 /* Intended only for internal stream topology manipulation. */
1520 case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
1521 /* Intended only for internal stream topology change notification. */
1522 case AST_CONTROL_STREAM_TOPOLOGY_SOURCE_CHANGED:
1523 case AST_CONTROL_STREAM_STOP:
1524 case AST_CONTROL_STREAM_SUSPEND:
1525 case AST_CONTROL_STREAM_RESTART:
1526 case AST_CONTROL_STREAM_REVERSE:
1527 case AST_CONTROL_STREAM_FORWARD:
1528 case AST_CONTROL_PLAYBACK_BEGIN: /* Only supported by app_dial currently */
1529 /* None of these playback stream control frames should go across the link. */
1530 case AST_CONTROL_RECORD_CANCEL:
1531 case AST_CONTROL_RECORD_STOP:
1532 case AST_CONTROL_RECORD_SUSPEND:
1533 case AST_CONTROL_RECORD_MUTE:
1534 /* None of these media recording control frames should go across the link. */
1535 break;
1536 }
1537 return is_allowed;
1538}

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 5592 of file chan_iax2.c.

5593{
5594 int res = 0;
5595 struct chan_iax2_pvt *pvt = (void *) vpvt;
5596 struct MD5Context md5;
5597 char key[17] = "";
5598 struct iax_ie_data ied = {
5599 .pos = 0,
5600 };
5601
5602 ast_mutex_lock(&iaxsl[pvt->callno]);
5603 pvt->keyrotateid = ast_sched_add(sched, 120000 + (ast_random() % 180001), iax2_key_rotate, vpvt);
5604
5605 snprintf(key, sizeof(key), "%lX", (unsigned long)ast_random());
5606
5607 MD5Init(&md5);
5608 MD5Update(&md5, (unsigned char *) key, strlen(key));
5609 MD5Final((unsigned char *) key, &md5);
5610
5611 IAX_DEBUGDIGEST("Sending", key);
5612
5613 iax_ie_append_raw(&ied, IAX_IE_CHALLENGE, key, 16);
5614
5615 res = send_command(pvt, AST_FRAME_IAX, IAX_COMMAND_RTKEY, 0, ied.buf, ied.pos, -1);
5616
5617 build_ecx_key((unsigned char *) key, pvt);
5618
5619 ast_mutex_unlock(&iaxsl[pvt->callno]);
5620
5621 return res;
5622}

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
callnoCall number to lock.
Return values
0If call disappeared or has ongoing hangup procedure.
1If call found and mutex is locked.

Definition at line 1784 of file chan_iax2.c.

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

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 1419 of file chan_iax2.c.

1420{
1421 for (;;) {
1422 if (!iaxs[callno] || !iaxs[callno]->owner) {
1423 /* There is no owner lock to get. */
1424 break;
1425 }
1426 if (!ast_channel_trylock(iaxs[callno]->owner)) {
1427 /* We got the lock */
1428 break;
1429 }
1430 /* Avoid deadlock by pausing and trying again */
1431 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1432 }
1433}

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 14478 of file chan_iax2.c.

14479{
14480 int res = 0;
14481 struct iax2_dpcache *dp = NULL;
14482#if 0
14483 ast_log(LOG_NOTICE, "iax2_matchmore: con: %s, exten: %s, pri: %d, cid: %s, data: %s\n", context, exten, priority, callerid ? callerid : "<unknown>", data);
14484#endif
14485 if ((priority != 1) && (priority != 2))
14486 return 0;
14487
14488 AST_LIST_LOCK(&dpcache);
14489 if ((dp = find_cache(chan, data, context, exten, priority))) {
14490 if (dp->flags & CACHE_FLAG_MATCHMORE)
14491 res = 1;
14492 } else {
14493 ast_log(LOG_WARNING, "Unable to make DP cache\n");
14494 }
14495 AST_LIST_UNLOCK(&dpcache);
14496
14497 return res;
14498}

References AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, CACHE_FLAG_MATCHMORE, 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 2015 of file chan_iax2.c.

2016{
2017 int res, i;
2018 struct ast_format_cap *cap;
2019
2020 /* We want to add the formats to the cap in the preferred order */
2021 cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
2022 if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
2023 ao2_cleanup(cap);
2024 return 1;
2025 }
2026
2027 res = ast_format_cap_update_by_allow_disallow(cap, list, allowing);
2028
2029 /* Adjust formats bitfield and pref list to match. */
2030 *formats = iax2_format_compatibility_cap2bitfield(cap);
2031 iax2_codec_pref_remove_missing(pref, *formats);
2032
2033 for (i = 0; i < ast_format_cap_count(cap); i++) {
2034 struct ast_format *fmt = ast_format_cap_get_format(cap, i);
2035
2036 iax2_codec_pref_append(pref, fmt, ast_format_cap_get_format_framing(cap, fmt));
2037 ao2_ref(fmt, -1);
2038 }
2039
2040 ao2_ref(cap, -1);
2041
2042 return res;
2043}

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 12591 of file chan_iax2.c.

12592{
12593 struct iax2_peer *peer = (struct iax2_peer *)data;
12594 peer->pokeexpire = -1;
12595#ifdef SCHED_MULTITHREADED
12596 if (schedule_action(__iax2_poke_noanswer, data))
12597#endif
12598 __iax2_poke_noanswer(data);
12599 peer_unref(peer);
12600 return 0;
12601}

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 12612 of file chan_iax2.c.

12613{
12614 int callno;
12615 int poke_timeout;
12616
12617 if (!peer->maxms || (ast_sockaddr_isnull(&peer->addr) && !peer->dnsmgr)) {
12618 /* IF we have no IP without dnsmgr, or this isn't to be monitored, return
12619 immediately after clearing things out */
12620 peer->lastms = 0;
12621 peer->historicms = 0;
12622 peer->pokeexpire = -1;
12623 peer->callno = 0;
12624 return 0;
12625 }
12626
12627 /* The peer could change the callno inside iax2_destroy, since we do deadlock avoidance */
12628 if ((callno = peer->callno) > 0) {
12629 ast_log(LOG_NOTICE, "Still have a callno...\n");
12630 ast_mutex_lock(&iaxsl[callno]);
12631 iax2_destroy(callno);
12632 ast_mutex_unlock(&iaxsl[callno]);
12633 }
12634 if (heldcall)
12635 ast_mutex_unlock(&iaxsl[heldcall]);
12636 callno = peer->callno = find_callno(0, 0, &peer->addr, NEW_FORCE, peer->sockfd, 0);
12637 if (heldcall)
12638 ast_mutex_lock(&iaxsl[heldcall]);
12639 if (callno < 1) {
12640 ast_log(LOG_WARNING, "Unable to allocate call for poking peer '%s'\n", peer->name);
12641 return -1;
12642 }
12643
12644 if (peer->pokeexpire > -1) {
12645 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
12646 peer->pokeexpire = -1;
12647 peer_unref(peer);
12648 }
12649 }
12650
12651 if (peer->lastms < 0){
12652 /* If the host is already unreachable then use time less than the unreachable
12653 * interval. 5/6 is arbitrary multiplier to get value less than
12654 * peer->pokefreqnotok. Value less than peer->pokefreqnotok is used to expire
12655 * current POKE before starting new POKE (which is scheduled after
12656 * peer->pokefreqnotok). */
12657 poke_timeout = peer->pokefreqnotok * 5 / 6;
12658 } else {
12659 /* If the host is reachable, use timeout large enough to allow for multiple
12660 * POKE retries. Limit this value to less than peer->pokefreqok. 5/6 is arbitrary
12661 * multiplier to get value less than peer->pokefreqok. Value less than
12662 * peer->pokefreqok is used to expire current POKE before starting new POKE
12663 * (which is scheduled after peer->pokefreqok). */
12664 poke_timeout = MIN(MAX_RETRY_TIME * 2 + peer->maxms, peer->pokefreqok * 5 / 6);
12665 }
12666
12667 /* Queue up a new task to handle no reply */
12668 peer->pokeexpire = iax2_sched_add(sched, poke_timeout, iax2_poke_noanswer, peer_ref(peer));
12669
12670 if (peer->pokeexpire == -1)
12671 peer_unref(peer);
12672
12673 /* And send the poke */
12674 ast_mutex_lock(&iaxsl[callno]);
12675 if (iaxs[callno]) {
12676 struct iax_ie_data ied = {
12677 .buf = { 0 },
12678 .pos = 0,
12679 };
12680
12681 /* Speed up retransmission times for this qualify call */
12682 iaxs[callno]->pingtime = peer->maxms / 8;
12683 iaxs[callno]->peerpoke = peer;
12684
12685 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
12686 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_POKE, 0, ied.buf, ied.pos, -1);
12687 }
12688 ast_mutex_unlock(&iaxsl[callno]);
12689
12690 return 0;
12691}

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 12603 of file chan_iax2.c.

12604{
12605 struct iax2_peer *peer = obj;
12606
12607 iax2_poke_peer(peer, 0);
12608
12609 return 0;
12610}

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 9593 of file chan_iax2.c.

9594{
9595 struct iax2_peer *peer = (struct iax2_peer *)data;
9596 peer->pokeexpire = -1;
9597#ifdef SCHED_MULTITHREADED
9598 if (schedule_action(__iax2_poke_peer_s, data))
9599#endif
9600 __iax2_poke_peer_s(data);
9601 return 0;
9602}

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 3522 of file chan_iax2.c.

3523{
3524 struct ast_channel *c = NULL;
3525 struct chan_iax2_pvt *pvt = iaxs[callno];
3526
3527 if (!pvt)
3528 return -1;
3529
3530 if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
3531 iax2_destroy_helper(pvt);
3532 ast_set_flag64(pvt, IAX_ALREADYGONE);
3533 }
3534
3535 if ((c = pvt->owner)) {
3536 ast_channel_tech_pvt_set(c, NULL);
3537 iax2_queue_hangup(callno);
3538 pvt->owner = NULL;
3539 ast_module_unref(ast_module_info->self);
3540 }
3541
3542 return 0;
3543}

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 12235 of file chan_iax2.c.

12236{
12237 struct iax2_thread *thread = data;
12238 struct timeval wait;
12239 struct timespec ts;
12240 int put_into_idle = 0;
12241 int first_time = 1;
12242 int old_state;
12243
12244 ast_atomic_fetchadd_int(&iaxactivethreadcount, 1);
12245
12246 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
12247 pthread_cleanup_push(iax2_process_thread_cleanup, data);
12248
12249 for (;;) {
12250 /* Wait for something to signal us to be awake */
12251 ast_mutex_lock(&thread->lock);
12252
12253 if (thread->stop) {
12254 ast_mutex_unlock(&thread->lock);
12255 break;
12256 }
12257
12258 /* Flag that we're ready to accept signals */
12259 if (first_time) {
12260 signal_condition(&thread->init_lock, &thread->init_cond);
12261 first_time = 0;
12262 }
12263
12264 /* Put into idle list if applicable */
12265 if (put_into_idle) {
12266 insert_idle_thread(thread);
12267 }
12268
12269 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
12270 struct iax2_thread *t = NULL;
12271 /* Wait to be signalled or time out */
12272 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
12273 ts.tv_sec = wait.tv_sec;
12274 ts.tv_nsec = wait.tv_usec * 1000;
12275 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
12276 /* This thread was never put back into the available dynamic
12277 * thread list, so just go away. */
12278 if (!put_into_idle || thread->stop) {
12279 ast_mutex_unlock(&thread->lock);
12280 break;
12281 }
12282 AST_LIST_LOCK(&dynamic_list);
12283 /* Account for the case where this thread is acquired *right* after a timeout */
12284 if ((t = AST_LIST_REMOVE(&dynamic_list, thread, list)))
12285 ast_atomic_fetchadd_int(&iaxdynamicthreadcount, -1);
12286 AST_LIST_UNLOCK(&dynamic_list);
12287 if (t) {
12288 /* This dynamic thread timed out waiting for a task and was
12289 * not acquired immediately after the timeout,
12290 * so it's time to go away. */
12291 ast_mutex_unlock(&thread->lock);
12292 break;
12293 }
12294 /* Someone grabbed our thread *right* after we timed out.
12295 * Wait for them to set us up with something to do and signal
12296 * us to continue. */
12297 wait = ast_tvadd(ast_tvnow(), ast_samp2tv(30000, 1000));
12298 ts.tv_sec = wait.tv_sec;
12299 ts.tv_nsec = wait.tv_usec * 1000;
12300 if (ast_cond_timedwait(&thread->cond, &thread->lock, &ts) == ETIMEDOUT) {
12301 ast_mutex_unlock(&thread->lock);
12302 break;
12303 }
12304 }
12305 } else {
12306 ast_cond_wait(&thread->cond, &thread->lock);
12307 }
12308
12309 /* Go back into our respective list */
12310 put_into_idle = 1;
12311
12312 ast_mutex_unlock(&thread->lock);
12313
12314 if (thread->stop) {
12315 break;
12316 }
12317
12318 /* See what we need to do */
12319 switch (thread->iostate) {
12320 case IAX_IOSTATE_IDLE:
12321 continue;
12322 case IAX_IOSTATE_READY:
12323 thread->actions++;
12324 thread->iostate = IAX_IOSTATE_PROCESSING;
12325 socket_process(thread);
12326 handle_deferred_full_frames(thread);
12327 break;
12328 case IAX_IOSTATE_SCHEDREADY:
12329 thread->actions++;
12330 thread->iostate = IAX_IOSTATE_PROCESSING;
12331#ifdef SCHED_MULTITHREADED
12332 thread->schedfunc(thread->scheddata);
12333#endif
12334 break;
12335 default:
12336 break;
12337 }
12338
12339 /* The network thread added us to the active_thread list when we were given
12340 * frames to process, Now that we are done, we must remove ourselves from
12341 * the active list, and return to the idle list */
12342 AST_LIST_LOCK(&active_list);
12343 AST_LIST_REMOVE(&active_list, thread, list);
12344 AST_LIST_UNLOCK(&active_list);
12345
12346 /* Make sure another frame didn't sneak in there after we thought we were done. */
12347 handle_deferred_full_frames(thread);
12348
12349 time(&thread->checktime);
12350 thread->iostate = IAX_IOSTATE_IDLE;
12351#ifdef DEBUG_SCHED_MULTITHREAD
12352 thread->curfunc[0]='\0';
12353#endif
12354 }
12355
12356 /*!
12357 * \note For some reason, idle threads are exiting without being
12358 * removed from an idle list, which is causing memory
12359 * corruption. Forcibly remove it from the list, if it's there.
12360 */
12361 AST_LIST_LOCK(&idle_list);
12362 AST_LIST_REMOVE(&idle_list, thread, list);
12363 AST_LIST_UNLOCK(&idle_list);
12364
12365 AST_LIST_LOCK(&dynamic_list);
12366 AST_LIST_REMOVE(&dynamic_list, thread, list);
12367 AST_LIST_UNLOCK(&dynamic_list);
12368
12369 if (!thread->stop) {
12370 /* Nobody asked me to stop so nobody is waiting to join me. */
12371 pthread_detach(pthread_self());
12372 }
12373
12374 /* I am exiting here on my own volition, I need to clean up my own data structures
12375 * Assume that I am no longer in any of the lists (idle, active, or dynamic)
12376 */
12377 pthread_cleanup_pop(1);
12378 return NULL;
12379}

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 12223 of file chan_iax2.c.

12224{
12225 struct iax2_thread *thread = data;
12226 ast_mutex_destroy(&thread->lock);
12227 ast_cond_destroy(&thread->cond);
12228 ast_mutex_destroy(&thread->init_lock);
12229 ast_cond_destroy(&thread->init_cond);
12230 ast_free(thread);
12231 /* Ignore check_return warning from Coverity for ast_atomic_dec_and_test below */
12232 ast_atomic_dec_and_test(&iaxactivethreadcount);
12233}

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 12442 of file chan_iax2.c.

12443{
12444 /* Returns 1 if provisioned, -1 if not able to find destination, or 0 if no provisioning
12445 is found for template */
12446 struct iax_ie_data provdata;
12447 struct iax_ie_data ied;
12448 unsigned int sig;
12449 struct ast_sockaddr addr;
12450 int callno;
12451 struct create_addr_info cai;
12452
12453 memset(&cai, 0, sizeof(cai));
12454
12455 ast_debug(1, "Provisioning '%s' from template '%s'\n", dest, template);
12456
12457 if (iax_provision_build(&provdata, &sig, template, force)) {
12458 ast_debug(1, "No provisioning found for template '%s'\n", template);
12459 return 0;
12460 }
12461
12462 if (end) {
12463 ast_sockaddr_copy(&addr, end);
12464 cai.sockfd = sockfd;
12465 } else if (create_addr(dest, NULL, &addr, &cai))
12466 return -1;
12467
12468 /* Build the rest of the message */
12469 memset(&ied, 0, sizeof(ied));
12470 iax_ie_append_raw(&ied, IAX_IE_PROVISIONING, provdata.buf, provdata.pos);
12471
12472 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
12473 if (!callno)
12474 return -1;
12475
12476 if (iaxs[callno]) {
12477 /* Schedule autodestruct in case they don't ever give us anything back */
12478 iaxs[callno]->autoid = iax2_sched_replace(iaxs[callno]->autoid,
12479 sched, 15000, auto_hangup, (void *)(long)callno);
12480 ast_set_flag64(iaxs[callno], IAX_PROVISION);
12481 /* Got a call number now, so go ahead and send the provisioning information */
12482 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PROVISION, 0, ied.buf, ied.pos, -1);
12483 }
12484 ast_mutex_unlock(&iaxsl[callno]);
12485
12486 return 1;
12487}

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 8905 of file chan_iax2.c.

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

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 5569 of file chan_iax2.c.

5570{
5571 switch (option) {
5572 case AST_OPTION_SECURE_SIGNALING:
5573 case AST_OPTION_SECURE_MEDIA:
5574 {
5575 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5576 ast_mutex_lock(&iaxsl[callno]);
5577 *((int *) data) = ast_test_flag64(iaxs[callno], IAX_FORCE_ENCRYPT) ? 1 : 0;
5578 ast_mutex_unlock(&iaxsl[callno]);
5579 return 0;
5580 }
5581 default:
5582 return -1;
5583 }
5584}

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 3339 of file chan_iax2.c.

3340{
3341 iax2_lock_owner(callno);
3342 if (iaxs[callno] && iaxs[callno]->owner) {
3343 ast_queue_frame(iaxs[callno]->owner, f);
3344 ast_channel_unlock(iaxs[callno]->owner);
3345 }
3346 return 0;
3347}

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 3408 of file chan_iax2.c.

3409{
3410 iax2_lock_owner(callno);
3411 if (iaxs[callno] && iaxs[callno]->owner) {
3412 ast_queue_hangup(iaxs[callno]->owner);
3413 ast_channel_unlock(iaxs[callno]->owner);
3414 }
3415 return 0;
3416}

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 3362 of file chan_iax2.c.

3363{
3364 iax2_lock_owner(callno);
3365 if (iaxs[callno] && iaxs[callno]->owner) {
3366 ast_queue_hold(iaxs[callno]->owner, musicclass);
3367 ast_channel_unlock(iaxs[callno]->owner);
3368 }
3369 return 0;
3370}

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 3385 of file chan_iax2.c.

3386{
3387 iax2_lock_owner(callno);
3388 if (iaxs[callno] && iaxs[callno]->owner) {
3389 ast_queue_unhold(iaxs[callno]->owner);
3390 ast_channel_unlock(iaxs[callno]->owner);
3391 }
3392 return 0;
3393}

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 5586 of file chan_iax2.c.

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

References ast_debug, and ast_null_frame.

◆ iax2_register()

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

Definition at line 9019 of file chan_iax2.c.

9020{
9021 char copy[256];
9022 char *username, *hostname, *secret;
9023 char *porta;
9024 char *stringp=NULL;
9025
9026 if (!value)
9027 return -1;
9028
9029 ast_copy_string(copy, value, sizeof(copy));
9030 stringp = copy;
9031 username = strsep(&stringp, "@");
9032 hostname = strsep(&stringp, "@");
9033
9034 if (!hostname) {
9035 ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d\n", lineno);
9036 return -1;
9037 }
9038
9039 stringp = username;
9040 username = strsep(&stringp, ":");
9041 secret = strsep(&stringp, ":");
9042 stringp = hostname;
9043 hostname = strsep(&stringp, ":");
9044 porta = strsep(&stringp, ":");
9045
9046 if (porta && !atoi(porta)) {
9047 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
9048 return -1;
9049 }
9050
9051 return iax2_append_register(hostname, username, secret, porta);
9052}

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 12703 of file chan_iax2.c.

12704{
12705 int callno;
12706 int res;
12707 struct ast_sockaddr addr;
12708 struct ast_channel *c;
12709 struct parsed_dial_string pds;
12710 struct create_addr_info cai;
12711 char *tmpstr;
12712 ast_callid callid;
12713
12714 memset(&pds, 0, sizeof(pds));
12715 tmpstr = ast_strdupa(data);
12716 parse_dial_string(tmpstr, &pds);
12717
12718 callid = ast_read_threadstorage_callid();
12719
12720 if (ast_strlen_zero(pds.peer)) {
12721 ast_log(LOG_WARNING, "No peer provided in the IAX2 dial string '%s'\n", data);
12722 return NULL;
12723 }
12724 memset(&cai, 0, sizeof(cai));
12725 cai.capability = iax2_capability;
12726
12727 ast_copy_flags64(&cai, &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12728
12729 /* Populate our address from the given */
12730 if (create_addr(pds.peer, NULL, &addr, &cai)) {
12731 *cause = AST_CAUSE_UNREGISTERED;
12732 return NULL;
12733 }
12734
12735 if (pds.port) {
12736 int bindport;
12737 ast_parse_arg(pds.port, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535);
12738 ast_sockaddr_set_port(&addr, bindport);
12739 }
12740
12741 callno = find_callno_locked(0, 0, &addr, NEW_FORCE, cai.sockfd, 0);
12742 if (callno < 1) {
12743 ast_log(LOG_WARNING, "Unable to create call\n");
12744 *cause = AST_CAUSE_CONGESTION;
12745 return NULL;
12746 }
12747
12748 /* If this is a trunk, update it now */
12749 ast_copy_flags64(iaxs[callno], &cai, IAX_TRUNK | IAX_SENDANI | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
12750 if (ast_test_flag64(&cai, IAX_TRUNK)) {
12751 int new_callno;
12752 if ((new_callno = make_trunk(callno, 1)) != -1)
12753 callno = new_callno;
12754 }
12755 iaxs[callno]->maxtime = cai.maxtime;
12756 if (callid) {
12757 iax_pvt_callid_set(callno, callid);
12758 }
12759
12760 if (cai.found) {
12761 ast_string_field_set(iaxs[callno], host, pds.peer);
12762 }
12763
12764 c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, &cai.prefs, assignedids,
12765 requestor, cai.found);
12766
12767 ast_mutex_unlock(&iaxsl[callno]);
12768
12769 if (c) {
12770 struct ast_format_cap *joint;
12771 struct ast_format *format;
12772 if (callid) {
12773 ast_channel_lock(c);
12774 ast_channel_callid_set(c, callid);
12775 ast_channel_unlock(c);
12776 }
12777
12778 joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
12779 if (!joint) {
12780 ast_hangup(c);
12781 return NULL;
12782 }
12783
12784 ast_format_cap_get_compatible(ast_channel_nativeformats(c), cap, joint);
12785
12786 /* If there is no joint format find one through translation */
12787 if (!ast_format_cap_count(joint)) {
12788 struct ast_format *best_fmt_cap = NULL;
12789 struct ast_format *best_fmt_native = NULL;
12790
12791 res = ast_translator_best_choice(cap, ast_channel_nativeformats(c), &best_fmt_cap, &best_fmt_native);
12792 if (res < 0) {
12793 struct ast_str *native_cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
12794 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
12795
12796 ast_log(LOG_WARNING, "Unable to create translator path for %s to %s on %s\n",
12797 ast_format_cap_get_names(ast_channel_nativeformats(c), &native_cap_buf),
12798 ast_format_cap_get_names(cap, &cap_buf),
12799 ast_channel_name(c));
12800 ast_hangup(c);
12801 ao2_ref(joint, -1);
12802 return NULL;
12803 }
12804 ast_format_cap_append(joint, best_fmt_native, 0);
12805 ao2_ref(best_fmt_cap, -1);
12806 ao2_ref(best_fmt_native, -1);
12807 }
12808 ast_channel_nativeformats_set(c, joint);
12809 format = ast_format_cap_get_format(ast_channel_nativeformats(c), 0);
12810 ast_channel_set_readformat(c, format);
12811 ast_channel_set_writeformat(c, format);
12812
12813 ao2_ref(joint, -1);
12814 ao2_ref(format, -1);
12815 }
12816
12817 return c;
12818}

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 1772 of file chan_iax2.c.

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

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 1766 of file chan_iax2.c.

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

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 6696 of file chan_iax2.c.

6697{
6698 /* Queue a packet for delivery on a given private structure. Use "ts" for
6699 timestamp, or calculate if ts is 0. Send immediately without retransmission
6700 or delayed, with retransmission */
6701 struct ast_iax2_full_hdr *fh;
6702 struct ast_iax2_mini_hdr *mh;
6703 struct ast_iax2_video_hdr *vh;
6704 struct {
6705 struct iax_frame fr2;
6706 unsigned char buffer[4096];
6707 } frb;
6708 struct iax_frame *fr;
6709 int res;
6710 int sendmini=0;
6711 unsigned int lastsent;
6712 unsigned int fts;
6713
6714 frb.fr2.afdatalen = sizeof(frb.buffer);
6715
6716 if (!pvt) {
6717 ast_log(LOG_WARNING, "No private structure for packet?\n");
6718 return -1;
6719 }
6720
6721 lastsent = pvt->lastsent;
6722
6723 /* Calculate actual timestamp */
6724 fts = calc_timestamp(pvt, ts, f);
6725
6726 /* Bail here if this is an "interp" frame; we don't want or need to send these placeholders out
6727 * (the endpoint should detect the lost packet itself). But, we want to do this here, so that we
6728 * increment the "predicted timestamps" for voice, if we're predicting */
6729 if(f->frametype == AST_FRAME_VOICE && f->datalen == 0)
6730 return 0;
6731#if 0
6732 ast_log(LOG_NOTICE,
6733 "f->frametype %c= AST_FRAME_VOICE, %sencrypted, %srotation scheduled...\n",
6734 *("=!" + (f->frametype == AST_FRAME_VOICE)),
6735 IAX_CALLENCRYPTED(pvt) ? "" : "not ",
6736 pvt->keyrotateid != -1 ? "" : "no "
6737 );
6738#endif
6739 if (pvt->keyrotateid == -1 && f->frametype == AST_FRAME_VOICE && IAX_CALLENCRYPTED(pvt)) {
6740 iax2_key_rotate(pvt);
6741 }
6742
6743 if ((ast_test_flag64(pvt, IAX_TRUNK) ||
6744 (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)) ||
6745 ((fts & 0xFFFF0000L) == ((lastsent + 0x10000) & 0xFFFF0000L))))
6746 /* High two bytes are the same on timestamp, or sending on a trunk */ &&
6747 (f->frametype == AST_FRAME_VOICE)
6748 /* is a voice frame */ &&
6749 (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svoiceformat)) ==
6750 AST_FORMAT_CMP_EQUAL)
6751 /* is the same type */ ) {
6752 /* Force immediate rather than delayed transmission */
6753 now = 1;
6754 /* Mark that mini-style frame is appropriate */
6755 sendmini = 1;
6756 }
6757 if ( f->frametype == AST_FRAME_VIDEO ) {
6758 /*
6759 * If the lower 15 bits of the timestamp roll over, or if
6760 * the video format changed then send a full frame.
6761 * Otherwise send a mini video frame
6762 */
6763 if (((fts & 0xFFFF8000L) == (pvt->lastvsent & 0xFFFF8000L)) &&
6764 (ast_format_cmp(f->subclass.format, ast_format_compatibility_bitfield2format(pvt->svideoformat)) ==
6765 AST_FORMAT_CMP_EQUAL)
6766 ) {
6767 now = 1;
6768 sendmini = 1;
6769 } else {
6770 now = 0;
6771 sendmini = 0;
6772 }
6773 pvt->lastvsent = fts;
6774 }
6775 if (f->frametype == AST_FRAME_IAX) {
6776 /* 0x8000 marks this message as TX:, this bit will be stripped later */
6777 pvt->last_iax_message = f->subclass.integer | MARK_IAX_SUBCLASS_TX;
6778 if (!pvt->first_iax_message) {
6779 pvt->first_iax_message = pvt->last_iax_message;
6780 }
6781 }
6782 /* Allocate an iax_frame */
6783 if (now) {
6784 fr = &frb.fr2;
6785 } else
6786 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));
6787 if (!fr) {
6788 ast_log(LOG_WARNING, "Out of memory\n");
6789 return -1;
6790 }
6791 /* Copy our prospective frame into our immediate or retransmitted wrapper */
6792 iax_frame_wrap(fr, f);
6793
6794 fr->ts = fts;
6795 fr->callno = pvt->callno;
6796 fr->transfer = transfer;
6797 fr->final = final;
6798 fr->encmethods = 0;
6799 if (!sendmini) {
6800 /* We need a full frame */
6801 if (seqno > -1)
6802 fr->oseqno = seqno;
6803 else
6804 fr->oseqno = pvt->oseqno++;
6805 fr->iseqno = pvt->iseqno;
6806 fh = (struct ast_iax2_full_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_full_hdr));
6807 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
6808 fh->ts = htonl(fr->ts);
6809 fh->oseqno = fr->oseqno;
6810 if (transfer) {
6811 fh->iseqno = 0;
6812 } else
6813 fh->iseqno = fr->iseqno;
6814 /* Keep track of the last thing we've acknowledged */
6815 if (!transfer)
6816 pvt->aseqno = fr->iseqno;
6817 fh->type = fr->af.frametype & 0xFF;
6818
6819 if (fr->af.frametype == AST_FRAME_VIDEO) {
6820 iax2_format tmpfmt = ast_format_compatibility_format2bitfield(fr->af.subclass.format);
6821 tmpfmt |= fr->af.subclass.frame_ending ? 0x1LL : 0;
6822 fh->csub = compress_subclass(tmpfmt | ((tmpfmt & 0x1LL) << 6));
6823 } else if (fr->af.frametype == AST_FRAME_VOICE) {
6824 fh->csub = compress_subclass(ast_format_compatibility_format2bitfield(fr->af.subclass.format));
6825 } else {
6826 fh->csub = compress_subclass(fr->af.subclass.integer);
6827 }
6828
6829 if (transfer) {
6830 fr->dcallno = pvt->transfercallno;
6831 } else
6832 fr->dcallno = pvt->peercallno;
6833 fh->dcallno = htons(fr->dcallno);
6834 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
6835 fr->data = fh;
6836 fr->retries = 0;
6837 /* Retry after 2x the ping time has passed */
6838 fr->retrytime = pvt->pingtime * 2;
6839 if (fr->retrytime < MIN_RETRY_TIME)
6840 fr->retrytime = MIN_RETRY_TIME;
6841 if (fr->retrytime > MAX_RETRY_TIME)
6842 fr->retrytime = MAX_RETRY_TIME;
6843 /* Acks' don't get retried */
6844 if ((f->frametype == AST_FRAME_IAX) && (f->subclass.integer == IAX_COMMAND_ACK))
6845 fr->retries = -1;
6846 else if (f->frametype == AST_FRAME_VOICE)
6847 pvt->svoiceformat = ast_format_compatibility_format2bitfield(f->subclass.format);
6848 else if (f->frametype == AST_FRAME_VIDEO)
6849 pvt->svideoformat = ast_format_compatibility_format2bitfield(f->subclass.format);
6850 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
6851 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
6852 if (fr->transfer)
6853 iax_outputframe(fr, NULL, 2, &pvt->transfer, fr->datalen - sizeof(struct ast_iax2_full_hdr));
6854 else
6855 iax_outputframe(fr, NULL, 2, &pvt->addr, fr->datalen - sizeof(struct ast_iax2_full_hdr));
6856 encrypt_frame(&pvt->ecx, fh, pvt->semirand, &fr->datalen);
6857 fr->encmethods = pvt->encmethods;
6858 fr->ecx = pvt->ecx;
6859 fr->mydcx = pvt->mydcx;
6860 memcpy(fr->semirand, pvt->semirand, sizeof(fr->semirand));
6861 } else
6862 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
6863 }
6864
6865 if (now) {
6866 res = send_packet(fr);
6867 } else
6868 res = iax2_transmit(fr);
6869 } else {
6870 if (ast_test_flag64(pvt, IAX_TRUNK)) {
6871 iax2_trunk_queue(pvt, fr);
6872 res = 0;
6873 } else if (fr->af.frametype == AST_FRAME_VIDEO) {
6874 /* Video frame have no sequence number */
6875 fr->oseqno = -1;
6876 fr->iseqno = -1;
6877 vh = (struct ast_iax2_video_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_video_hdr));
6878 vh->zeros = 0;
6879 vh->callno = htons(0x8000 | fr->callno);
6880 vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass.frame_ending ? 0x8000 : 0));
6881 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
6882 fr->data = vh;
6883 fr->retries = -1;
6884 res = send_packet(fr);
6885 } else {
6886 /* Mini-frames have no sequence number */
6887 fr->oseqno = -1;
6888 fr->iseqno = -1;
6889 /* Mini frame will do */
6890 mh = (struct ast_iax2_mini_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_mini_hdr));
6891 mh->callno = htons(fr->callno);
6892 mh->ts = htons(fr->ts & 0xFFFF);
6893 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
6894 fr->data = mh;
6895 fr->retries = -1;
6896 if (pvt->transferring == TRANSFER_MEDIAPASS)
6897 fr->transfer = 1;
6898 if (ast_test_flag64(pvt, IAX_ENCRYPTED)) {
6899 if (ast_test_flag64(pvt, IAX_KEYPOPULATED)) {
6900 encrypt_frame(&pvt->ecx, (struct ast_iax2_full_hdr *)mh, pvt->semirand, &fr->datalen);
6901 } else
6902 ast_log(LOG_WARNING, "Supposed to send packet encrypted, but no key?\n");
6903 }
6904 res = send_packet(fr);
6905 }
6906 }
6907 return res;
6908}

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 4449 of file chan_iax2.c.

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

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 4444 of file chan_iax2.c.

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

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 4437 of file chan_iax2.c.

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

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 5497 of file chan_iax2.c.

5498{
5499 struct ast_option_header *h;
5500 int res;
5501
5502 switch (option) {
5503 case AST_OPTION_TXGAIN:
5504 case AST_OPTION_RXGAIN:
5505 /* these two cannot be sent, because they require a result */
5506 errno = ENOSYS;
5507 return -1;
5508 case AST_OPTION_OPRMODE:
5509 errno = EINVAL;
5510 return -1;
5511 case AST_OPTION_SECURE_SIGNALING:
5512 case AST_OPTION_SECURE_MEDIA:
5513 {
5514 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5515 ast_mutex_lock(&iaxsl[callno]);
5516 if ((*(int *) data)) {
5517 ast_set_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
5518 } else {
5519 ast_clear_flag64(iaxs[callno], IAX_FORCE_ENCRYPT);
5520 }
5521 ast_mutex_unlock(&iaxsl[callno]);
5522 return 0;
5523 }
5524 /* These options are sent to the other side across the network where
5525 * they will be passed to whatever channel is bridged there. Don't
5526 * do anything silly like pass an option that transmits pointers to
5527 * memory on this machine to a remote machine to use */
5528 case AST_OPTION_TONE_VERIFY:
5529 case AST_OPTION_TDD:
5530 case AST_OPTION_RELAXDTMF:
5531 case AST_OPTION_AUDIO_MODE:
5532 case AST_OPTION_DIGIT_DETECT:
5533 case AST_OPTION_FAX_DETECT:
5534 {
5535 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5536 struct chan_iax2_pvt *pvt;
5537
5538 ast_mutex_lock(&iaxsl[callno]);
5539 pvt = iaxs[callno];
5540
5541 if (wait_for_peercallno(pvt)) {
5542 ast_mutex_unlock(&iaxsl[callno]);
5543 return -1;
5544 }
5545
5546 ast_mutex_unlock(&iaxsl[callno]);
5547
5548 if (!(h = ast_malloc(datalen + sizeof(*h)))) {
5549 return -1;
5550 }
5551
5552 h->flag = AST_OPTION_FLAG_REQUEST;
5553 h->option = htons(option);
5554 memcpy(h->data, data, datalen);
5555 res = send_command_locked(PTR_TO_CALLNO(ast_channel_tech_pvt(c)), AST_FRAME_CONTROL,
5556 AST_CONTROL_OPTION, 0, (unsigned char *) h,
5557 datalen + sizeof(*h), -1);
5558 ast_free(h);
5559 return res;
5560 }
5561 default:
5562 return -1;
5563 }
5564
5565 /* Just in case someone does a break instead of a return */
5566 return -1;
5567}

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, ast_option_header::flag, IAX_FORCE_ENCRYPT, iaxs, iaxsl, ast_option_header::option, 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 5917 of file chan_iax2.c.

5918{
5919 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
5920 struct iax_ie_data ied = { "", };
5921 char tmp[256], *context;
5922 enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
5923 ast_copy_string(tmp, dest, sizeof(tmp));
5924 context = strchr(tmp, '@');
5925 if (context) {
5926 *context = '\0';
5927 context++;
5928 }
5929 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
5930 if (context)
5931 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
5932 ast_debug(1, "Transferring '%s' to '%s'\n", ast_channel_name(c), dest);
5933 ast_queue_control_data(c, AST_CONTROL_TRANSFER, &message, sizeof(message));
5934 return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
5935}

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, 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 4420 of file chan_iax2.c.

4421{
4422 fr->sentyet = 0;
4423
4424 return ast_taskprocessor_push(transmit_processor, transmit_frame, fr);
4425}

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 9647 of file chan_iax2.c.

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

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 6413 of file chan_iax2.c.

6414{
6415 struct ast_frame *f;
6416 struct iax2_trunk_peer *tpeer;
6417 void *tmp, *ptr;
6418 struct timeval now;
6419 struct ast_iax2_meta_trunk_entry *met;
6420 struct ast_iax2_meta_trunk_mini *mtm;
6421
6422 f = &fr->af;
6423 tpeer = find_tpeer(&pvt->addr, pvt->sockfd);
6424 if (tpeer) {
6425
6426 if (tpeer->trunkdatalen + f->datalen + 4 >= tpeer->trunkdataalloc) {
6427 /* Need to reallocate space */
6428 if (tpeer->trunkdataalloc < trunkmaxsize) {
6429 if (!(tmp = ast_realloc(tpeer->trunkdata, tpeer->trunkdataalloc + DEFAULT_TRUNKDATA + IAX2_TRUNK_PREFACE))) {
6430 ast_mutex_unlock(&tpeer->lock);
6431 return -1;
6432 }
6433
6434 tpeer->trunkdataalloc += DEFAULT_TRUNKDATA;
6435 tpeer->trunkdata = tmp;
6436 ast_debug(1, "Expanded trunk '%s' to %u bytes\n", ast_sockaddr_stringify(&tpeer->addr), tpeer->trunkdataalloc);
6437 } else {
6438 ast_log(LOG_WARNING, "Maximum trunk data space exceeded to %s\n", ast_sockaddr_stringify(&tpeer->addr));
6439 ast_mutex_unlock(&tpeer->lock);
6440 return -1;
6441 }
6442 }
6443
6444 /* Append to meta frame */
6445 ptr = tpeer->trunkdata + IAX2_TRUNK_PREFACE + tpeer->trunkdatalen;
6446 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS)) {
6447 mtm = (struct ast_iax2_meta_trunk_mini *)ptr;
6448 mtm->len = htons(f->datalen);
6449 mtm->mini.callno = htons(pvt->callno);
6450 mtm->mini.ts = htons(0xffff & fr->ts);
6451 ptr += sizeof(struct ast_iax2_meta_trunk_mini);
6452 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_mini);
6453 } else {
6454 met = (struct ast_iax2_meta_trunk_entry *)ptr;
6455 /* Store call number and length in meta header */
6456 met->callno = htons(pvt->callno);
6457 met->len = htons(f->datalen);
6458 /* Advance pointers/decrease length past trunk entry header */
6459 ptr += sizeof(struct ast_iax2_meta_trunk_entry);
6460 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
6461 }
6462 /* Copy actual trunk data */
6463 memcpy(ptr, f->data.ptr, f->datalen);
6464 tpeer->trunkdatalen += f->datalen;
6465
6466 tpeer->calls++;
6467
6468 /* track the largest mtu we actually have sent */
6469 if (tpeer->trunkdatalen + f->datalen + 4 > trunk_maxmtu)
6470 trunk_maxmtu = tpeer->trunkdatalen + f->datalen + 4 ;
6471
6472 /* if we have enough for a full MTU, ship it now without waiting */
6473 if (global_max_trunk_mtu > 0 && tpeer->trunkdatalen + f->datalen + 4 >= global_max_trunk_mtu) {
6474 now = ast_tvnow();
6475 send_trunk(tpeer, &now);
6476 trunk_untimed ++;
6477 }
6478
6479 ast_mutex_unlock(&tpeer->lock);
6480 }
6481 return 0;
6482}

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 9568 of file chan_iax2.c.

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

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 7836 of file chan_iax2.c.

7837{
7838 unsigned short callno = PTR_TO_CALLNO(ast_channel_tech_pvt(c));
7839 int res = -1;
7840 ast_mutex_lock(&iaxsl[callno]);
7841 if (iaxs[callno]) {
7842 /* If there's an outstanding error, return failure now */
7843 if (!iaxs[callno]->error) {
7844 if (ast_test_flag64(iaxs[callno], IAX_ALREADYGONE))
7845 res = 0;
7846 /* Don't waste bandwidth sending null frames */
7847 else if (f->frametype == AST_FRAME_NULL)
7848 res = 0;
7849 else if ((f->frametype == AST_FRAME_VOICE) && ast_test_flag64(iaxs[callno], IAX_QUELCH))
7850 res = 0;
7851 else if (!ast_test_flag(&iaxs[callno]->state, IAX_STATE_STARTED))
7852 res = 0;
7853 else
7854 /* Simple, just queue for transmission */
7855 res = iax2_send(iaxs[callno], f, 0, -1, 0, 0, 0);
7856 } else {
7857 ast_debug(1, "Write error: %s\n", strerror(errno));
7858 }
7859 }
7860 /* If it's already gone, just return */
7861 ast_mutex_unlock(&iaxsl[callno]);
7862 return res;
7863}

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 1283 of file chan_iax2.c.

1284{
1285 if (iaxdebug)
1286 ast_verbose("%s", data);
1287}

References ast_verbose, and iaxdebug.

Referenced by load_module().

◆ iax_error_output()

static void iax_error_output ( const char *  data)
static

Definition at line 1289 of file chan_iax2.c.

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

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 1265 of file chan_iax2.c.

1266{
1267 if (iaxdebug ||
1268 (addr && !ast_sockaddr_isnull(&debugaddr) &&
1269 (!ast_sockaddr_port(&debugaddr) ||
1270 ast_sockaddr_port(&debugaddr) == ast_sockaddr_port(addr)) &&
1271 !ast_sockaddr_cmp_addr(&debugaddr, addr))) {
1272
1273 if (iaxdebug) {
1274 iax_showframe(f, fhi, rx, addr, datalen);
1275 } else {
1276 iaxdebug = 1;
1277 iax_showframe(f, fhi, rx, addr, datalen);
1278 iaxdebug = 0;
1279 }
1280 }
1281}

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 1213 of file chan_iax2.c.

1214{
1215 return iaxs[callno]->callid;
1216}

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 1223 of file chan_iax2.c.

1224{
1225 ast_callid callid = ast_create_callid();
1226 char buffer[AST_CALLID_BUFFER_LENGTH];
1227 ast_callid_strnprint(buffer, sizeof(buffer), callid);
1228 iax_pvt_callid_set(callno, callid);
1229}

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 1218 of file chan_iax2.c.

1219{
1220 iaxs[callno]->callid = callid;
1221}

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 2372 of file chan_iax2.c.

2373{
2374 struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
2375 if (new) {
2376 size_t afdatalen = new->afdatalen;
2377 memcpy(new, fr, sizeof(*new));
2378 iax_frame_wrap(new, &fr->af);
2379 new->afdatalen = afdatalen;
2380 new->data = NULL;
2381 new->datalen = 0;
2382 new->direction = DIRECTION_INGRESS;
2383 new->retrans = -1;
2384 }
2385 return new;
2386}

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 1656 of file chan_iax2.c.

1657{
1658 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1659 AST_LIST_LOCK(&dynamic_list);
1660 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1661 AST_LIST_UNLOCK(&dynamic_list);
1662 } else {
1663 AST_LIST_LOCK(&idle_list);
1664 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1665 AST_LIST_UNLOCK(&idle_list);
1666 }
1667
1668 return;
1669}

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 6496 of file chan_iax2.c.

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

References aes_key::raw.

Referenced by authenticate_reply().

◆ jb_debug_output()

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

Definition at line 1318 of file chan_iax2.c.

1319{
1320 va_list args;
1321 char buf[1024];
1322
1323 va_start(args, fmt);
1324 vsnprintf(buf, sizeof(buf), fmt, args);
1325 va_end(args);
1326
1327 ast_verbose("%s", buf);
1328}

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 1294 of file chan_iax2.c.

1295{
1296 va_list args;
1297 char buf[1024];
1298
1299 va_start(args, fmt);
1300 vsnprintf(buf, sizeof(buf), fmt, args);
1301 va_end(args);
1302
1303 ast_log(LOG_ERROR, "%s", buf);
1304}

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 1306 of file chan_iax2.c.

1307{
1308 va_list args;
1309 char buf[1024];
1310
1311 va_start(args, fmt);
1312 vsnprintf(buf, sizeof(buf), fmt, args);
1313 va_end(args);
1314
1315 ast_log(LOG_WARNING, "%s", buf);
1316}

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 14992 of file chan_iax2.c.

14993{
14994 static const char config[] = "iax.conf";
14995 int x = 0;
14996 struct iax2_registry *reg = NULL;
14997
14998 if (!(iax2_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
14999 return AST_MODULE_LOAD_DECLINE;
15000 }
15001 ast_format_cap_append_by_type(iax2_tech.capabilities, AST_MEDIA_TYPE_UNKNOWN);
15002
15003 if (load_objects()) {
15004 ao2_ref(iax2_tech.capabilities, -1);
15005 iax2_tech.capabilities = NULL;
15006 return AST_MODULE_LOAD_DECLINE;
15007 }
15008
15009 memset(iaxs, 0, sizeof(iaxs));
15010
15011 for (x = 0; x < ARRAY_LEN(iaxsl); x++) {
15012 ast_mutex_init(&iaxsl[x]);
15013 }
15014
15015 if (!(sched = ast_sched_context_create())) {
15016 ast_log(LOG_ERROR, "Failed to create scheduler thread\n");
15017 ao2_ref(iax2_tech.capabilities, -1);
15018 iax2_tech.capabilities = NULL;
15019 return AST_MODULE_LOAD_DECLINE;
15020 }
15021
15022 if (ast_sched_start_thread(sched)) {
15023 ast_sched_context_destroy(sched);
15024 ao2_ref(iax2_tech.capabilities, -1);
15025 iax2_tech.capabilities = NULL;
15026 sched = NULL;
15027 return AST_MODULE_LOAD_DECLINE;
15028 }
15029
15030 if (!(io = io_context_create())) {
15031 ast_log(LOG_ERROR, "Failed to create I/O context\n");
15032 ast_sched_context_destroy(sched);
15033 ao2_ref(iax2_tech.capabilities, -1);
15034 iax2_tech.capabilities = NULL;
15035 sched = NULL;
15036 return AST_MODULE_LOAD_DECLINE;
15037 }
15038
15039 if (!(netsock = ast_netsock_list_alloc())) {
15040 ast_log(LOG_ERROR, "Failed to create netsock list\n");
15041 io_context_destroy(io);
15042 ast_sched_context_destroy(sched);
15043 ao2_ref(iax2_tech.capabilities, -1);
15044 iax2_tech.capabilities = NULL;
15045 sched = NULL;
15046 return AST_MODULE_LOAD_DECLINE;
15047 }
15048 ast_netsock_init(netsock);
15049
15050 outsock = ast_netsock_list_alloc();
15051 if (!outsock) {
15052 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
15053 io_context_destroy(io);
15054 ast_sched_context_destroy(sched);
15055 ao2_ref(iax2_tech.capabilities, -1);
15056 iax2_tech.capabilities = NULL;
15057 sched = NULL;
15058 return AST_MODULE_LOAD_DECLINE;
15059 }
15060 ast_netsock_init(outsock);
15061
15062 randomcalltokendata = ast_random();
15063
15064 iax_set_output(iax_debug_output);
15065 iax_set_error(iax_error_output);
15066 jb_setoutput(jb_error_output, jb_warning_output, NULL);
15067
15068 if ((timer = ast_timer_open())) {
15069 ast_timer_set_rate(timer, 1000 / trunkfreq);
15070 }
15071
15072 if (set_config(config, 0, 0) == -1) {
15073 if (timer) {
15074 ast_timer_close(timer);
15075 timer = NULL;
15076 }
15077 __unload_module();
15078 return AST_MODULE_LOAD_DECLINE;
15079 }
15080
15081 ast_cli_register_multiple(cli_iax2, ARRAY_LEN(cli_iax2));
15082
15083 ast_register_application_xml(papp, iax2_prov_app);
15084
15085 ast_custom_function_register(&iaxpeer_function);
15086 ast_custom_function_register(&iaxvar_function);
15087
15088 ast_manager_register_xml("IAXpeers", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peers);
15089 ast_manager_register_xml("IAXpeerlist", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_peer_list);
15090 ast_manager_register_xml("IAXnetstats", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_netstats);
15091 ast_manager_register_xml("IAXregistry", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_iax2_show_registry);
15092
15093 if (ast_channel_register(&iax2_tech)) {
15094 ast_log(LOG_ERROR, "Unable to register channel class %s\n", "IAX2");
15095 __unload_module();
15096 return AST_MODULE_LOAD_DECLINE;
15097 }
15098
15099 if (ast_register_switch(&iax2_switch)) {
15100 ast_log(LOG_ERROR, "Unable to register IAX switch\n");
15101 }
15102
15103 if (start_network_thread()) {
15104 ast_log(LOG_ERROR, "Unable to start network thread\n");
15105 __unload_module();
15106 return AST_MODULE_LOAD_DECLINE;
15107 } else {
15108 ast_verb(2, "IAX Ready and Listening\n");
15109 }
15110
15111 AST_LIST_LOCK(&registrations);
15112 AST_LIST_TRAVERSE(&registrations, reg, entry)
15113 iax2_do_register(reg);
15114 AST_LIST_UNLOCK(&registrations);
15115
15116 ao2_callback(peers, 0, peer_set_sock_cb, NULL);
15117 ao2_callback(peers, 0, iax2_poke_peer_cb, NULL);
15118
15119
15120 iax_firmware_reload();
15121 iax_provision_reload(0);
15122
15123 ast_realtime_require_field("iaxpeers", "name", RQ_CHAR, 10, "ipaddr", RQ_CHAR, 15, "port", RQ_UINTEGER2, 5, "regseconds", RQ_UINTEGER2, 6, SENTINEL);
15124
15125 network_change_stasis_subscribe();
15126
15127 return AST_MODULE_LOAD_SUCCESS;
15128}

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 14899 of file chan_iax2.c.

14900{
14901 peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
14902 peercnts = callno_limits = calltoken_ignores = NULL;
14903
14904 peers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
14905 peer_hash_cb, NULL, peer_cmp_cb);
14906 if (!peers) {
14907 goto container_fail;
14908 }
14909
14910 users = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_USER_BUCKETS,
14911 user_hash_cb, NULL, user_cmp_cb);
14912 if (!users) {
14913 goto container_fail;
14914 }
14915
14916 iax_peercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14917 IAX_MAX_CALLS, pvt_hash_cb, NULL, pvt_cmp_cb);
14918 if (!iax_peercallno_pvts) {
14919 goto container_fail;
14920 }
14921
14922 iax_transfercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14923 IAX_MAX_CALLS, transfercallno_pvt_hash_cb, NULL, transfercallno_pvt_cmp_cb);
14924 if (!iax_transfercallno_pvts) {
14925 goto container_fail;
14926 }
14927
14928 peercnts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
14929 peercnt_hash_cb, NULL, peercnt_cmp_cb);
14930 if (!peercnts) {
14931 goto container_fail;
14932 }
14933
14934 callno_limits = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14935 MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
14936 if (!callno_limits) {
14937 goto container_fail;
14938 }
14939
14940 calltoken_ignores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
14941 MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
14942 if (!calltoken_ignores) {
14943 goto container_fail;
14944 }
14945
14946 if (create_callno_pools()) {
14947 goto container_fail;
14948 }
14949
14950 transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT);
14951 if (!transmit_processor) {
14952 goto container_fail;
14953 }
14954
14955 return 0;
14956
14957container_fail:
14958 if (peers) {
14959 ao2_ref(peers, -1);
14960 }
14961 if (users) {
14962 ao2_ref(users, -1);
14963 }
14964 if (iax_peercallno_pvts) {
14965 ao2_ref(iax_peercallno_pvts, -1);
14966 }
14967 if (iax_transfercallno_pvts) {
14968 ao2_ref(iax_transfercallno_pvts, -1);
14969 }
14970 if (peercnts) {
14971 ao2_ref(peercnts, -1);
14972 }
14973 if (callno_limits) {
14974 ao2_ref(callno_limits, -1);
14975 }
14976 if (calltoken_ignores) {
14977 ao2_ref(calltoken_ignores, -1);
14978 }
14979 return -1;
14980}

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 9864 of file chan_iax2.c.

9865{
9866 int localjitter = -1, localdelay = 0, locallost = -1, locallosspct = -1, localdropped = 0, localooo = -1, localpackets = -1;
9867 jb_info jbinfo;
9868
9869 ast_mutex_lock(&iaxsl[callno]);
9870 if (iaxs[callno] && iaxs[callno]->owner && ast_channel_name(iaxs[callno]->owner)) {
9871 if(ast_test_flag64(iaxs[callno], IAX_USEJITTERBUF)) {
9872 jb_getinfo(iaxs[callno]->jb, &jbinfo);
9873 localjitter = jbinfo.jitter;
9874 localdelay = jbinfo.current - jbinfo.min;
9875 locallost = jbinfo.frames_lost;
9876 locallosspct = jbinfo.losspct/1000;
9877 localdropped = jbinfo.frames_dropped;
9878 localooo = jbinfo.frames_ooo;
9879 localpackets = jbinfo.frames_in;
9880 }
9881 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",
9882 ast_channel_name(iaxs[callno]->owner),
9883 iaxs[callno]->pingtime,
9884 localjitter,
9885 localdelay,
9886 locallost,
9887 locallosspct,
9888 localdropped,
9889 localooo,
9890 localpackets,
9891 iaxs[callno]->remote_rr.jitter,
9892 iaxs[callno]->remote_rr.delay,
9893 iaxs[callno]->remote_rr.losscnt,
9894 iaxs[callno]->remote_rr.losspct/1000,
9895 iaxs[callno]->remote_rr.dropped,
9896 iaxs[callno]->remote_rr.ooo,
9897 iaxs[callno]->remote_rr.packets);
9898 }
9899 ast_mutex_unlock(&iaxsl[callno]);
9900}

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 2419 of file chan_iax2.c.

2420{
2421 int x;
2422 int res= 0;
2423 callno_entry entry;
2424 if (iaxs[callno]->oseqno) {
2425 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
2426 return -1;
2427 }
2428 if (callno >= TRUNK_CALL_START) {
2429 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
2430 return -1;
2431 }
2432
2433 if (get_unused_callno(
2434 CALLNO_TYPE_TRUNK,
2435 CALLNO_ENTRY_IS_VALIDATED(iaxs[callno]->callno_entry),
2436 &entry)) {
2437 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
2438 return -1;
2439 }
2440
2441 x = CALLNO_ENTRY_GET_CALLNO(entry);
2442 ast_mutex_lock(&iaxsl[x]);
2443
2444 /*!
2445 * \note We delete these before switching the slot, because if
2446 * they fire in the meantime, they will generate a warning.
2447 */
2448 AST_SCHED_DEL(sched, iaxs[callno]->pingid);
2449 AST_SCHED_DEL(sched, iaxs[callno]->lagid);
2450 iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
2451 iaxs[x] = iaxs[callno];
2452 iaxs[x]->callno = x;
2453
2454 /* since we copied over the pvt from a different callno, make sure the old entry is replaced
2455 * before assigning the new one */
2456 if (iaxs[x]->callno_entry) {
2457 iax2_sched_add(
2458 sched,
2459 MIN_REUSE_TIME * 1000,
2460 replace_callno,
2461 CALLNO_ENTRY_TO_PTR(iaxs[x]->callno_entry));
2462
2463 }
2464 iaxs[x]->callno_entry = entry;
2465
2466 iaxs[callno] = NULL;
2467 /* Update the two timers that should have been started */
2468 iaxs[x]->pingid = iax2_sched_add(sched,
2469 ping_time * 1000, send_ping, (void *)(long)x);
2470 iaxs[x]->lagid = iax2_sched_add(sched,
2471 lagrq_time * 1000, send_lagrq, (void *)(long)x);
2472
2473 if (locked)
2474 ast_mutex_unlock(&iaxsl[callno]);
2475 res = x;
2476 if (!locked)
2477 ast_mutex_unlock(&iaxsl[x]);
2478
2479 /* We moved this call from a non-trunked to a trunked call */
2480 ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
2481
2482 return res;
2483}

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 7351 of file chan_iax2.c.

7352{
7353 ast_cli_netstats(s, -1, 0);
7354 astman_append(s, "\r\n");
7355 return RESULT_SUCCESS;
7356}

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 7420 of file chan_iax2.c.

7421{
7422 struct show_peers_context cont = {
7423 .havepattern = 0,
7424 .idtext = "",
7425 .registeredonly = 0,
7426
7427 .peerlist = 1,
7428
7429 .total_peers = 0,
7430 .online_peers = 0,
7431 .offline_peers = 0,
7432 .unmonitored_peers = 0,
7433 };
7434
7435 struct iax2_peer *peer = NULL;
7436 struct ao2_iterator i;
7437
7438 const char *id = astman_get_header(m,"ActionID");
7439
7440 if (!ast_strlen_zero(id)) {
7441 snprintf(cont.idtext, sizeof(cont.idtext), "ActionID: %s\r\n", id);
7442 }
7443
7444 astman_send_listack(s, m, "IAX Peer status list will follow", "start");
7445
7446 i = ao2_iterator_init(peers, 0);
7447 for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
7448 _iax2_show_peers_one(-1, s, &cont, peer);
7449 }
7450 ao2_iterator_destroy(&i);
7451
7452 astman_send_list_complete_start(s, m, "PeerlistComplete", cont.total_peers);
7453 astman_send_list_complete_end(s);
7454
7455 return RESULT_SUCCESS;
7456}

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 7398 of file chan_iax2.c.

7399{
7400 static const char * const a[] = { "iax2", "show", "peers" };
7401 const char *id = astman_get_header(m,"ActionID");
7402 char idtext[256] = "";
7403 int total = 0;
7404
7405 if (!ast_strlen_zero(id))
7406 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
7407
7408 astman_send_listack(s, m, "Peer status list will follow", "start");
7409
7410 /* List the peers in separate manager events */
7411 __iax2_show_peers(-1, &total, s, 3, a);
7412
7413 /* Send final confirmation */
7414 astman_send_list_complete_start(s, m, "PeerlistComplete", total);
7415 astman_send_list_complete_end(s);
7416 return 0;
7417}

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 7522 of file chan_iax2.c.

7523{
7524 const char *id = astman_get_header(m, "ActionID");
7525 struct iax2_registry *reg = NULL;
7526 char idtext[256] = "";
7527 char host[80] = "";
7528 char perceived[80] = "";
7529 int total = 0;
7530
7531 if (!ast_strlen_zero(id))
7532 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
7533
7534 astman_send_listack(s, m, "Registrations will follow", "start");
7535
7536 AST_LIST_LOCK(&registrations);
7537 AST_LIST_TRAVERSE(&registrations, reg, entry) {
7538 snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(&reg->addr));
7539
7540 snprintf(perceived, sizeof(perceived), "%s", ast_sockaddr_isnull(&reg->us) ? "<Unregistered>" : ast_sockaddr_stringify(&reg->us));
7541
7542 astman_append(s,
7543 "Event: RegistryEntry\r\n"
7544 "%s"
7545 "Host: %s\r\n"
7546 "DNSmanager: %s\r\n"
7547 "Username: %s\r\n"
7548 "Perceived: %s\r\n"
7549 "Refresh: %d\r\n"
7550 "State: %s\r\n"
7551 "\r\n", idtext, host, (reg->dnsmgr) ? "Y" : "N", reg->username, perceived,
7552 reg->refresh, regstate2str(reg->regstate));
7553
7554 total++;
7555 }
7556 AST_LIST_UNLOCK(&registrations);
7557
7558 astman_send_list_complete_start(s, m, "RegistrationsComplete", total);
7559 astman_send_list_complete_end(s);
7560
7561 return 0;
7562}

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 2401 of file chan_iax2.c.

2402{
2403 if (!ast_sockaddr_cmp(&cur->addr, addr)) {
2404 /* This is the main host */
2405 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
2406 (check_dcallno ? dcallno == cur->callno : 1) ) {
2407 /* That's us. Be sure we keep track of the peer call number */
2408 return 1;
2409 }
2410 }
2411 if (!ast_sockaddr_cmp(&cur->transfer, addr) && cur->transferring) {
2412 /* We're transferring */
2413 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
2414 return 1;
2415 }
2416 return 0;
2417}

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_extension_state_get_device_causing_channel(), 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(), 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(), pbx_find_extension(), pvt_cmp_cb(), read_dirs_cb(), realtime_switch_common(), remove_inheritable_header(), 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 6528 of file chan_iax2.c.

6529{
6530#if 0
6531 /* Debug with "fake encryption" */
6532 int x;
6533 if (len % 16)
6534 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
6535 for (x=0;x<len;x++)
6536 dst[x] = src[x] ^ 0xff;
6537#else
6538 unsigned char lastblock[16] = { 0 };
6539 int x;
6540 while(len > 0) {
6541 ast_aes_decrypt(src, dst, dcx);
6542 for (x=0;x<16;x++)
6543 dst[x] ^= lastblock[x];
6544 memcpy(lastblock, src, sizeof(lastblock));
6545 dst += 16;
6546 src += 16;
6547 len -= 16;
6548 }
6549#endif
6550}

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 6552 of file chan_iax2.c.

6553{
6554#if 0
6555 /* Debug with "fake encryption" */
6556 int x;
6557 if (len % 16)
6558 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
6559 for (x=0;x<len;x++)
6560 dst[x] = src[x] ^ 0xff;
6561#else
6562 unsigned char curblock[16] = { 0 };
6563 int x;
6564 while(len > 0) {
6565 for (x=0;x<16;x++)
6566 curblock[x] ^= src[x];
6567 ast_aes_encrypt(curblock, dst, ecx);
6568 memcpy(curblock, dst, sizeof(curblock));
6569 dst += 16;
6570 src += 16;
6571 len -= 16;
6572 }
6573#endif
6574}

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 8189 of file chan_iax2.c.

8190{
8191 /* Select exactly one common encryption if there are any */
8192 p->encmethods &= enc;
8193 if (p->encmethods) {
8194 if (!(p->encmethods & IAX_ENCRYPT_KEYROTATE)){ /* if key rotation is not supported, turn off keyrotation. */
8195 p->keyrotateid = -2;
8196 }
8197 if (p->encmethods & IAX_ENCRYPT_AES128)
8198 p->encmethods = IAX_ENCRYPT_AES128;
8199 else
8200 p->encmethods = 0;
8201 }
8202}

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 1570 of file chan_iax2.c.

1571{
1572 struct iax2_registry *reg;
1573 network_change_sched_id = -1;
1574 AST_LIST_LOCK(&registrations);
1575 AST_LIST_TRAVERSE(&registrations, reg, entry) {
1576 iax2_do_register(reg);
1577 }
1578 AST_LIST_UNLOCK(&registrations);
1579
1580 return 0;
1581}

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 1583 of file chan_iax2.c.

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

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

Referenced by network_change_stasis_subscribe().

◆ network_change_stasis_subscribe()

static void network_change_stasis_subscribe ( void  )
static

Definition at line 1540 of file chan_iax2.c.

1541{
1542 if (!network_change_sub) {
1543 network_change_sub = stasis_subscribe(ast_system_topic(),
1544 network_change_stasis_cb, NULL);
1545 stasis_subscription_accept_message_type(network_change_sub, ast_network_change_type());
1546 stasis_subscription_set_filter(network_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
1547 }
1548}

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 1550 of file chan_iax2.c.

1551{
1552 network_change_sub = stasis_unsubscribe_and_join(network_change_sub);
1553}

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 12820 of file chan_iax2.c.

12821{
12822 int res;
12823
12824 if (timer) {
12825 ast_io_add(io, ast_timer_fd(timer), timing_read, AST_IO_IN | AST_IO_PRI, NULL);
12826 }
12827
12828 for (;;) {
12829 pthread_testcancel();
12830 /* Wake up once a second just in case SIGURG was sent while
12831 * we weren't in poll(), to make sure we don't hang when trying
12832 * to unload. */
12833 res = ast_io_wait(io, 1000);
12834 /* Timeout(=0), and EINTR is not a thread exit condition. We do
12835 * not want to exit the thread loop on these conditions. */
12836 if (res < 0 && errno != -EINTR) {
12837 ast_log(LOG_ERROR, "IAX2 network thread unexpected exit: %s\n", strerror(errno));
12838 break;
12839 }
12840 }
12841
12842 return NULL;
12843}

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 2329 of file chan_iax2.c.

2330{
2331 struct chan_iax2_pvt *tmp;
2332 jb_conf jbconf;
2333
2334 if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
2335 return NULL;
2336 }
2337
2338 tmp->pingid = -1;
2339 tmp->lagid = -1;
2340 tmp->autoid = -1;
2341 tmp->authid = -1;
2342 tmp->initid = -1;
2343 tmp->keyrotateid = -1;
2344 tmp->jbid = -1;
2345
2346 if (ast_string_field_init(tmp, 32)) {
2347 ao2_ref(tmp, -1);
2348 tmp = NULL;
2349 return NULL;
2350 }
2351
2352 tmp->prefs = prefs_global;
2353
2354 ast_string_field_set(tmp,exten, "s");
2355 ast_string_field_set(tmp,host, host);
2356
2357 tmp->jb = jb_new();
2358 jbconf.max_jitterbuf = maxjitterbuffer;
2359 jbconf.resync_threshold = resyncthreshold;
2360 jbconf.max_contig_interp = maxjitterinterps;
2361 jbconf.target_extra = jittertargetextra;
2362 jb_setconf(tmp->jb,&jbconf);
2363
2364 AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
2365
2366 tmp->hold_signaling = 1;
2367 AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
2368
2369 return tmp;
2370}

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
datathe string to be parsed
pdspointer 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 5145 of file chan_iax2.c.

5146{
5147 char *outkey = NULL;
5148
5149 if (ast_strlen_zero(data))
5150 return;
5151
5152 pds->peer = strsep(&data, "/");
5153 pds->exten = strsep(&data, "/");
5154 pds->options = data;
5155
5156 if (pds->exten) {
5157 data = pds->exten;
5158 pds->exten = strsep(&data, "@");
5159 pds->context = data;
5160 }
5161
5162 if (strchr(pds->peer, '@')) {
5163 data = pds->peer;
5164 pds->username = strsep(&data, "@");
5165 pds->peer = data;
5166 }
5167
5168 if (pds->username) {
5169 data = pds->username;
5170 pds->username = strsep(&data, ":");
5171 pds->password = strsep(&data, ":");
5172 outkey = data;
5173 }
5174
5175 data = pds->peer;
5176 pds->peer = strsep(&data, ":");
5177 pds->port = data;
5178
5179 /*
5180 * Check for a key name wrapped in [] in the password position.
5181 * If found, move it to the key field instead.
5182 * Also allow for both key and secret to be specified, now that
5183 * encryption is possible with RSA authentication.
5184 */
5185
5186 if (pds->password && (pds->password[0] == '[')) { /* key (then maybe secret) */
5187 pds->key = ast_strip_quoted(pds->password, "[", "]");
5188 if (ast_strlen_zero(outkey)) {
5189 pds->password = NULL;
5190 ast_debug(1, "Outkey (%s), no secret\n", pds->key);
5191 } else {
5192 pds->password = outkey;
5193 ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
5194 }
5195 } else if (outkey && (outkey[0] == '[')) { /* secret, then key */
5196 pds->key = ast_strip_quoted(outkey, "[", "]");
5197 if (ast_strlen_zero(pds->password)) {
5198 ast_debug(1, "Outkey (%s), no secret\n", pds->key);
5199 } else {
5200 ast_debug(1, "Outkey (%s) and secret (%s)\n", pds->key, pds->password);
5201 }
5202 }
5203}

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 2059 of file chan_iax2.c.

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

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 13616 of file chan_iax2.c.

13617{
13618 struct iax2_peer *peer = obj;
13619
13620 ast_set_flag64(peer, IAX_DELME);
13621
13622 return 0;
13623}

References ast_set_flag64, and IAX_DELME.

Referenced by delete_users().

◆ peer_destructor()

static void peer_destructor ( void *  obj)
static

Definition at line 13013 of file chan_iax2.c.

13014{
13015 struct iax2_peer *peer = obj;
13016 int callno = peer->callno;
13017
13018 ast_free_acl_list(peer->acl);
13019
13020 if (callno > 0) {
13021 ast_mutex_lock(&iaxsl[callno]);
13022 iax2_destroy(callno);
13023 ast_mutex_unlock(&iaxsl[callno]);
13024 }
13025
13026 register_peer_exten(peer, 0);
13027
13028 if (peer->dnsmgr)
13029 ast_dnsmgr_release(peer->dnsmgr);
13030
13031 if (peer->mwi_event_sub) {
13032 peer->mwi_event_sub = ast_mwi_unsubscribe(peer->mwi_event_sub);
13033 }
13034
13035 ast_string_field_free_memory(peer);
13036
13037 ast_endpoint_shutdown(peer->endpoint);
13038}

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 2048 of file chan_iax2.c.

2049{
2050 const struct iax2_peer *peer = obj;
2051 const char *name = obj;
2052
2053 return ast_str_hash(flags & OBJ_KEY ? name : peer->name);
2054}

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 2108 of file chan_iax2.c.

2109{
2110 ao2_ref(peer, +1);
2111 return peer;
2112}

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 14853 of file chan_iax2.c.

14854{
14855 struct iax2_peer *peer = obj;
14856
14857 if (peer->sockfd < 0)
14858 peer->sockfd = defaultsockfd;
14859
14860 return 0;
14861}

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 12943 of file chan_iax2.c.

12944{
12945 struct ast_sockaddr addr;
12946 int nonlocal = 1;
12947 int port = IAX_DEFAULT_PORTNO;
12948 int sockfd = defaultsockfd;
12949 char *tmp;
12950 char *host;
12951 char *portstr;
12952
12953 tmp = ast_strdupa(srcaddr);
12954 ast_sockaddr_split_hostport(tmp, &host, &portstr, 0);
12955
12956 if (portstr) {
12957 port = atoi(portstr);
12958 if (port < 1)
12959 port = IAX_DEFAULT_PORTNO;
12960 }
12961
12962 addr.ss.ss_family = AST_AF_UNSPEC;
12963 if (!ast_get_ip(&addr, host)) {
12964 struct ast_netsock *sock;
12965
12966 if (check_srcaddr(&addr) == 0) {
12967 /* ip address valid. */
12968 ast_sockaddr_set_port(&addr, port);
12969
12970 if (!(sock = ast_netsock_find(netsock, &addr)))
12971 sock = ast_netsock_find(outsock, &addr);
12972 if (sock) {
12973 sockfd = ast_netsock_sockfd(sock);
12974 nonlocal = 0;
12975 } else {
12976 /* INADDR_ANY matches anyway! */
12977 ast_sockaddr_parse(&addr, "0.0.0.0", 0);
12978 ast_sockaddr_set_port(&addr, port);
12979 if (ast_netsock_find(netsock, &addr)) {
12980 sock = ast_netsock_bind(outsock, io, srcaddr, port, qos.tos, qos.cos, socket_read, NULL);
12981 if (sock) {
12982 sockfd = ast_netsock_sockfd(sock);
12983 ast_netsock_unref(sock);
12984 nonlocal = 0;
12985 } else {
12986 nonlocal = 2;
12987 }
12988 }
12989 }
12990 }
12991 }
12992
12993 peer->sockfd = sockfd;
12994
12995 if (nonlocal == 1) {
12996 ast_log(LOG_WARNING,
12997 "Non-local or unbound address specified (%s) in sourceaddress for '%s', reverting to default\n",
12998 srcaddr,
12999 peer->name);
13000 return -1;
13001 } else if (nonlocal == 2) {
13002 ast_log(LOG_WARNING,
13003 "Unable to bind to sourceaddress '%s' for '%s', reverting to default\n",
13004 srcaddr,
13005 peer->name);
13006 return -1;
13007 } else {
13008 ast_debug(1, "Using sourceaddress %s for '%s'\n", srcaddr, peer->name);
13009 return 0;
13010 }
13011}

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 3878 of file chan_iax2.c.

3879{
3880 int res = 0;
3881 if (peer->maxms) {
3882 if (peer->lastms < 0) {
3883 ast_copy_string(status, "UNREACHABLE", statuslen);
3884 } else if (peer->lastms > peer->maxms) {
3885 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
3886 res = 1;
3887 } else if (peer->lastms) {
3888 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
3889 res = 1;
3890 } else {
3891 ast_copy_string(status, "UNKNOWN", statuslen);
3892 }
3893 } else {
3894 ast_copy_string(status, "Unmonitored", statuslen);
3895 res = -1;
3896 }
3897 return res;
3898}

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 2114 of file chan_iax2.c.

2115{
2116 ao2_ref(peer, -1);
2117 return NULL;
2118}

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 2717 of file chan_iax2.c.

2718{
2719 struct peercnt *peercnt;
2720 int res = 0;
2721 struct peercnt tmp;
2722
2723 ast_sockaddr_copy(&tmp.addr, addr);
2724
2725 /* Reasoning for peercnts container lock: Two identical ip addresses
2726 * could be added by different threads at the "same time". Without the container
2727 * lock, both threads could alloc space for the same object and attempt
2728 * to link to table. With the lock, one would create the object and link
2729 * to table while the other would find the already created peercnt object
2730 * rather than creating a new one. */
2731 ao2_lock(peercnts);
2732 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2733 ao2_lock(peercnt);
2734 } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2735 ao2_lock(peercnt);
2736 /* create and set defaults */
2737 ast_sockaddr_copy(&peercnt->addr, addr);
2738 set_peercnt_limit(peercnt);
2739 /* guarantees it does not go away after unlocking table
2740 * ao2_find automatically adds this */
2741 ao2_link(peercnts, peercnt);
2742 } else {
2743 ao2_unlock(peercnts);
2744 return -1;
2745 }
2746
2747 /* check to see if the address has hit its callno limit. If not increment cur. */
2748 if (peercnt->limit > peercnt->cur) {
2749 peercnt->cur++;
2750 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(addr));
2751 } else { /* max num call numbers for this peer has been reached! */
2752 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_sockaddr_stringify_addr(addr));
2753 res = -1;
2754 }
2755
2756 /* clean up locks and ref count */
2757 ao2_unlock(peercnt);
2758 ao2_unlock(peercnts);
2759 ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2760
2761 return res;
2762}

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 2555 of file chan_iax2.c.

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

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 2545 of file chan_iax2.c.

2546{
2547 const struct peercnt *peercnt = obj;
2548
2549 if (ast_sockaddr_isnull(&peercnt->addr)) {
2550 return 0;
2551 }
2552 return ast_sockaddr_hash(&peercnt->addr);
2553}

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 2689 of file chan_iax2.c.

2690{
2691 /* this function turns off and on custom callno limits set by peer registration */
2692 struct peercnt *peercnt;
2693 struct peercnt tmp;
2694
2695 ast_sockaddr_copy(&tmp.addr, sockaddr);
2696
2697 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2698 peercnt->reg = reg;
2699 if (limit) {
2700 peercnt->limit = limit;
2701 } else {
2702 set_peercnt_limit(peercnt);
2703 }
2704 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_sockaddr_stringify_addr(sockaddr), peercnt->limit, peercnt->reg);
2705 ao2_ref(peercnt, -1); /* decrement ref from find */
2706 }
2707}

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 2768 of file chan_iax2.c.

2769{
2770 struct ast_sockaddr addr;
2771
2772 ast_sockaddr_copy(&addr, &peercnt->addr);
2773
2774 /*
2775 * Container locked here since peercnt may be unlinked from
2776 * list. If left unlocked, peercnt_add could try and grab this
2777 * entry from the table and modify it at the "same time" this
2778 * thread attempts to unlink it.
2779 */
2780 ao2_lock(peercnts);
2781 peercnt->cur--;
2782 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(&addr));
2783 /* if this was the last connection from the peer remove it from table */
2784 if (peercnt->cur == 0) {
2785 ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2786 }
2787 ao2_unlock(peercnts);
2788}

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 2808 of file chan_iax2.c.

2809{
2810 struct peercnt *peercnt;
2811 struct peercnt tmp;
2812
2813 ast_sockaddr_copy(&tmp.addr, addr);
2814
2815 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2816 peercnt_remove(peercnt);
2817 ao2_ref(peercnt, -1); /* decrement ref from find */
2818 }
2819 return 0;
2820}

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 2794 of file chan_iax2.c.

2795{
2796 struct peercnt *peercnt = (struct peercnt *) obj;
2797
2798 peercnt_remove(peercnt);
2799 ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2800
2801 return 0;
2802}

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 14168 of file chan_iax2.c.

14169{
14170 struct ao2_iterator i;
14171 struct iax2_peer *peer;
14172
14173 i = ao2_iterator_init(peers, 0);
14174 while ((peer = ao2_iterator_next(&i))) {
14175 iax2_poke_peer(peer, 0);
14176 peer_unref(peer);
14177 }
14178 ao2_iterator_destroy(&i);
14179}

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

2679{
2680 struct addr_range *addr_range = obj;
2681
2682 return addr_range->delme ? CMP_MATCH : 0;
2683}

References CMP_MATCH, and addr_range::delme.

Referenced by reload_config().

◆ prune_peers()

static void prune_peers ( void  )
static

Definition at line 13679 of file chan_iax2.c.

13680{
13681 struct iax2_peer *peer;
13682 struct ao2_iterator i;
13683
13684 i = ao2_iterator_init(peers, 0);
13685 while ((peer = ao2_iterator_next(&i))) {
13686 if (ast_test_flag64(peer, IAX_DELME) || ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
13687 unlink_peer(peer);
13688 }
13689 peer_unref(peer);
13690 }
13691 ao2_iterator_destroy(&i);
13692}

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 13663 of file chan_iax2.c.

13664{
13665 struct iax2_user *user;
13666 struct ao2_iterator i;
13667
13668 i = ao2_iterator_init(users, 0);
13669 while ((user = ao2_iterator_next(&i))) {
13670 if (ast_test_flag64(user, IAX_DELME) || ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
13671 ao2_unlink(users, user);
13672 }
13673 user_unref(user);
13674 }
13675 ao2_iterator_destroy(&i);
13676}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_unlink, ast_test_flag64, IAX_DELME, IAX_RTCACHEFRIENDS, 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 14870 of file chan_iax2.c.

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

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 2282 of file chan_iax2.c.

2283{
2284 struct chan_iax2_pvt *pvt = obj;
2285 struct iax_frame *cur = NULL;
2286 struct signaling_queue_entry *s = NULL;
2287
2288 ast_mutex_lock(&iaxsl[pvt->callno]);
2289
2290 iax2_destroy_helper(pvt);
2291
2292 sched_delay_remove(&pvt->addr, pvt->callno_entry);
2293 pvt->callno_entry = 0;
2294
2295 /* Already gone */
2296 ast_set_flag64(pvt, IAX_ALREADYGONE);
2297
2298 AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
2299 /* Cancel any pending transmissions */
2300 cur->retries = -1;
2301 }
2302
2303 ast_mutex_unlock(&iaxsl[pvt->callno]);
2304
2305 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2306 free_signaling_queue_entry(s);
2307 }
2308
2309 if (pvt->reg) {
2310 pvt->reg->callno = 0;
2311 }
2312
2313 if (!pvt->owner) {
2314 jb_frame frame;
2315 if (pvt->vars) {
2316 ast_variables_destroy(pvt->vars);
2317 pvt->vars = NULL;
2318 }
2319
2320 while (jb_getall(pvt->jb, &frame) == JB_OK) {
2321 iax2_frame_free(frame.data);
2322 }
2323
2324 jb_destroy(pvt->jb);
2325 ast_string_field_free_memory(pvt);
2326 }
2327}

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 14863 of file chan_iax2.c.

14864{
14865 const struct chan_iax2_pvt *pvt = obj;
14866
14867 return pvt->peercallno;
14868}

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 2257 of file chan_iax2.c.

2258{
2259 struct signaling_queue_entry *qe;
2260
2261 if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
2262 return 1; /* do not queue this frame */
2263 } else if (!(qe = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
2264 return -1; /* out of memory */
2265 }
2266
2267 /* copy ast_frame into our queue entry */
2268 qe->f = *f;
2269 if (qe->f.datalen) {
2270 /* if there is data in this frame copy it over as well */
2271 if (!(qe->f.data.ptr = ast_malloc(qe->f.datalen))) {
2272 free_signaling_queue_entry(qe);
2273 return -1;
2274 }
2275 memcpy(qe->f.data.ptr, f->data.ptr, qe->f.datalen);
2276 }
2277 AST_LIST_INSERT_TAIL(&pvt->signaling_queue, qe, next);
2278
2279 return 0;
2280}

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 8173 of file chan_iax2.c.

8174{
8175 struct ast_iax2_full_hdr fh;
8176 fh.scallno = htons(src | IAX_FLAG_FULL);
8177 fh.dcallno = htons(dst);
8178 fh.ts = 0;
8179 fh.oseqno = 0;
8180 fh.iseqno = 0;
8181 fh.type = AST_FRAME_IAX;
8182 fh.csub = compress_subclass(IAX_COMMAND_INVAL);
8183 iax_outputframe(NULL, &fh, 0, addr, 0);
8184
8185 ast_debug(1, "Raw Hangup %s, src=%d, dst=%d\n", ast_sockaddr_stringify(addr), src, dst);
8186 return ast_sendto(sockfd, &fh, sizeof(fh), 0, addr);
8187}

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 4470 of file chan_iax2.c.

4471{
4472 struct ast_variable *var = NULL;
4473 struct ast_variable *tmp;
4474 struct iax2_peer *peer=NULL;
4475 time_t regseconds = 0, nowtime;
4476 int dynamic=0;
4477 char *str_addr, *str_port;
4478
4479 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
4480 str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
4481
4482 if (peername) {
4483 var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", SENTINEL);
4484 if (!var && !ast_sockaddr_isnull(addr)) {
4485 var = ast_load_realtime("iaxpeers", "name", peername, "host", str_addr, SENTINEL);
4486 }
4487 } else if (!ast_sockaddr_isnull(addr)) {
4488 var = ast_load_realtime("iaxpeers", "ipaddr", str_addr, "port", str_port, SENTINEL);
4489 if (var) {
4490 /* We'll need the peer name in order to build the structure! */
4491 for (tmp = var; tmp; tmp = tmp->next) {
4492 if (!strcasecmp(tmp->name, "name"))
4493 peername = tmp->value;
4494 }
4495 }
4496 }
4497 if (!var && peername) { /* Last ditch effort */
4498 var = ast_load_realtime("iaxpeers", "name", peername, SENTINEL);
4499 /*!\note
4500 * If this one loaded something, then we need to ensure that the host
4501 * field matched. The only reason why we can't have this as a criteria
4502 * is because we only have the IP address and the host field might be
4503 * set as a name (and the reverse PTR might not match).
4504 */
4505 if (var && !ast_sockaddr_isnull(addr)) {
4506 for (tmp = var; tmp; tmp = tmp->next) {
4507 if (!strcasecmp(tmp->name, "host")) {
4508 struct ast_sockaddr *hostaddr = NULL;
4509
4510 if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
4511 || ast_sockaddr_cmp_addr(hostaddr, addr)) {
4512 /* No match */
4513 ast_variables_destroy(var);
4514 var = NULL;
4515 }
4516 ast_free(hostaddr);
4517 break;
4518 }
4519 }
4520 }
4521 }
4522 if (!var)
4523 return NULL;
4524
4525 peer = build_peer(peername, var, NULL, ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
4526
4527 if (!peer) {
4528 ast_variables_destroy(var);
4529 return NULL;
4530 }
4531
4532 for (tmp = var; tmp; tmp = tmp->next) {
4533 /* Make sure it's not a user only... */
4534 if (!strcasecmp(tmp->name, "type")) {
4535 if (strcasecmp(tmp->value, "friend") &&
4536 strcasecmp(tmp->value, "peer")) {
4537 /* Whoops, we weren't supposed to exist! */
4538 peer = peer_unref(peer);
4539 break;
4540 }
4541 } else if (!strcasecmp(tmp->name, "regseconds")) {
4542 ast_get_time_t(tmp->value, &regseconds, 0, NULL);
4543 } else if (!strcasecmp(tmp->name, "ipaddr")) {
4544 int setport = ast_sockaddr_port(&peer->addr);
4545 if (ast_parse_arg(tmp->value, PARSE_ADDR | PARSE_PORT_FORBID, NULL)) {
4546 ast_log(LOG_WARNING, "Failed to parse sockaddr '%s' for ipaddr of realtime peer '%s'\n", tmp->value, tmp->name);
4547 } else {
4548 ast_sockaddr_parse(&peer->addr, tmp->value, 0);
4549 }
4550 ast_sockaddr_set_port(&peer->addr, setport);
4551 } else if (!strcasecmp(tmp->name, "port")) {
4552 int bindport;
4553 if (ast_parse_arg(tmp->value, PARSE_UINT32 | PARSE_IN_RANGE, &bindport, 0, 65535)) {
4554 bindport = IAX_DEFAULT_PORTNO;
4555 }
4556 ast_sockaddr_set_port(&peer->addr, bindport);
4557 } else if (!strcasecmp(tmp->name, "host")) {
4558 if (!strcasecmp(tmp->value, "dynamic"))
4559 dynamic = 1;
4560 }
4561 }
4562
4563 ast_variables_destroy(var);
4564
4565 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
4566 ast_copy_flags64(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
4567 if (ast_test_flag64(peer, IAX_RTAUTOCLEAR)) {
4568 if (peer->expire > -1) {
4569 if (!AST_SCHED_DEL(sched, peer->expire)) {
4570 peer->expire = -1;
4571 peer_unref(peer);
4572 }
4573 }
4574 peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
4575 if (peer->expire == -1)
4576 peer_unref(peer);
4577 }
4578 ao2_link(peers, peer);
4579 if (ast_test_flag64(peer, IAX_DYNAMIC))
4580 reg_source_db(peer);
4581 } else {
4582 ast_set_flag64(peer, IAX_TEMPONLY);
4583 }
4584
4585 if (!ast_test_flag64(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
4586 time(&nowtime);
4587 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
4588 memset(&peer->addr, 0, sizeof(peer->addr));
4589 realtime_update_peer(peer->name, &peer->addr, 0);
4590 ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
4591 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
4592 }
4593 else {
4594 ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
4595 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
4596 }
4597 }
4598
4599 return peer;
4600}

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 4677 of file chan_iax2.c.

4678{
4679 char regseconds[20];
4680 const char *sysname = ast_config_AST_SYSTEM_NAME;
4681 char *syslabel = NULL;
4682 char *port;
4683
4684 if (ast_strlen_zero(sysname)) /* No system name, disable this */
4685 sysname = NULL;
4686 else if (ast_test_flag64(&globalflags, IAX_RTSAVE_SYSNAME))
4687 syslabel = "regserver";
4688
4689 snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
4690 port = ast_strdupa(ast_sockaddr_stringify_port(sockaddr));
4691 ast_update_realtime("iaxpeers", "name", peername,
4692 "ipaddr", ast_sockaddr_isnull(sockaddr) ? "" : ast_sockaddr_stringify_addr(sockaddr),
4693 "port", ast_sockaddr_isnull(sockaddr) ? "" : port,
4694 "regseconds", regseconds, syslabel, sysname, SENTINEL); /* note syslabel can be NULL */
4695}

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 4602 of file chan_iax2.c.

4603{
4604 struct ast_variable *var;
4605 struct ast_variable *tmp;
4606 struct iax2_user *user=NULL;
4607 char *str_addr, *str_port;
4608
4609 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
4610 str_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
4611
4612 var = ast_load_realtime("iaxusers", "name", username, "host", "dynamic", SENTINEL);
4613 if (!var)
4614 var = ast_load_realtime("iaxusers", "name", username, "host", str_addr, SENTINEL);
4615 if (!var && !ast_sockaddr_isnull(addr)) {
4616 var = ast_load_realtime("iaxusers", "name", username, "ipaddr", str_addr, "port", str_port, SENTINEL);
4617 if (!var)
4618 var = ast_load_realtime("iaxusers", "ipaddr", str_addr, "port", str_port, SENTINEL);
4619 }
4620 if (!var) { /* Last ditch effort */
4621 var = ast_load_realtime("iaxusers", "name", username, SENTINEL);
4622 /*!\note
4623 * If this one loaded something, then we need to ensure that the host
4624 * field matched. The only reason why we can't have this as a criteria
4625 * is because we only have the IP address and the host field might be
4626 * set as a name (and the reverse PTR might not match).
4627 */
4628 if (var) {
4629 for (tmp = var; tmp; tmp = tmp->next) {
4630 if (!strcasecmp(tmp->name, "host")) {
4631 struct ast_sockaddr *hostaddr = NULL;
4632
4633 if (!ast_sockaddr_resolve(&hostaddr, tmp->value, PARSE_PORT_FORBID, AST_AF_UNSPEC)
4634 || ast_sockaddr_cmp_addr(hostaddr, addr)) {
4635 /* No match */
4636 ast_variables_destroy(var);
4637 var = NULL;
4638 }
4639 ast_free(hostaddr);
4640 break;
4641 }
4642 }
4643 }
4644 }
4645 if (!var)
4646 return NULL;
4647
4648 tmp = var;
4649 while(tmp) {
4650 /* Make sure it's not a peer only... */
4651 if (!strcasecmp(tmp->name, "type")) {
4652 if (strcasecmp(tmp->value, "friend") &&
4653 strcasecmp(tmp->value, "user")) {
4654 return NULL;
4655 }
4656 }
4657 tmp = tmp->next;
4658 }
4659
4660 user = build_user(username, var, NULL, !ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS));
4661
4662 ast_variables_destroy(var);
4663
4664 if (!user)
4665 return NULL;
4666
4667 if (ast_test_flag64((&globalflags), IAX_RTCACHEFRIENDS)) {
4668 ast_set_flag64(user, IAX_RTCACHEFRIENDS);
4669 ao2_link(users, user);
4670 } else {
4671 ast_set_flag64(user, IAX_TEMPONLY);
4672 }
4673
4674 return user;
4675}

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, 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 9143 of file chan_iax2.c.

9144{
9145 char data[80];
9146 char *expiry;
9147
9148 if (ast_test_flag64(p, IAX_TEMPONLY) || ast_db_get("IAX/Registry", p->name, data, sizeof(data))) {
9149 return;
9150 }
9151
9152 expiry = strrchr(data, ':');
9153 if (!expiry) {
9154 ast_log(LOG_NOTICE, "IAX/Registry astdb entry missing expiry: '%s'\n", data);
9155 return;
9156 }
9157 *expiry++ = '\0';
9158
9159 if (!ast_sockaddr_parse(&p->addr, data, PARSE_PORT_REQUIRE)) {
9160 ast_log(LOG_NOTICE, "IAX/Registry astdb host:port invalid - '%s'\n", data);
9161 return;
9162 }
9163
9164 p->expiry = atoi(expiry);
9165
9166 ast_verb(3, "Seeding '%s' at %s for %d\n", p->name,
9167 ast_sockaddr_stringify(&p->addr), p->expiry);
9168
9169 iax2_poke_peer(p, 0);
9170 if (p->expire > -1) {
9171 if (!AST_SCHED_DEL(sched, p->expire)) {
9172 p->expire = -1;
9173 peer_unref(p);
9174 }
9175 }
9176
9177 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9178
9179 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
9180 if (p->expire == -1) {
9181 peer_unref(p);
9182 }
9183
9184 if (iax2_regfunk) {
9185 iax2_regfunk(p->name, 1);
9186 }
9187
9188 register_peer_exten(p, 1);
9189}

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 9055 of file chan_iax2.c.

9056{
9057 char multi[256];
9058 char *stringp, *ext;
9059 if (!ast_strlen_zero(regcontext)) {
9060 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
9061 stringp = multi;
9062 while((ext = strsep(&stringp, "&"))) {
9063 if (onoff) {
9064 if (!ast_exists_extension(NULL, regcontext, ext, 1, NULL))
9065 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL,
9066 "Noop", ast_strdup(peer->name), ast_free_ptr, "IAX2");
9067 } else
9068 ast_context_remove_extension(regcontext, ext, 1, NULL);
9069 }
9070 }
9071}

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 8356 of file chan_iax2.c.

8357{
8358 char requeststr[256] = "";
8359 char peer[256] = "";
8360 char md5secret[256] = "";
8361 char rsasecret[256] = "";
8362 char secret[256] = "";
8363 struct iax2_peer *p = NULL;
8364 struct ast_key *key;
8365 char *keyn;
8366 int x;
8367 int expire = 0;
8368 int res = -1;
8369
8370 ast_clear_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8371 /* iaxs[callno]->peer[0] = '\0'; not necc. any more-- stringfield is pre-inited to null string */
8372 if (ies->username)
8373 ast_copy_string(peer, ies->username, sizeof(peer));
8374 if (ies->password)
8375 ast_copy_string(secret, ies->password, sizeof(secret));
8376 if (ies->md5_result)
8377 ast_copy_string(md5secret, ies->md5_result, sizeof(md5secret));
8378 if (ies->rsa_result)
8379 ast_copy_string(rsasecret, ies->rsa_result, sizeof(rsasecret));
8380 if (ies->refresh)
8381 expire = ies->refresh;
8382
8383 if (ast_strlen_zero(peer)) {
8384 ast_log(LOG_NOTICE, "Empty registration from %s\n", ast_sockaddr_stringify_addr(addr));
8385 return -1;
8386 }
8387
8388 /* SLD: first call to lookup peer during registration */
8389 ast_mutex_unlock(&iaxsl[callno]);
8390 p = find_peer(peer, 1);
8391 ast_mutex_lock(&iaxsl[callno]);
8392 if (!p || !iaxs[callno]) {
8393 if (iaxs[callno]) {
8394 int plaintext = ((last_authmethod & IAX_AUTH_PLAINTEXT) | (iaxs[callno]->authmethods & IAX_AUTH_PLAINTEXT));
8395 /* Anything, as long as it's non-blank */
8396 ast_string_field_set(iaxs[callno], secret, "badsecret");
8397 /* An AUTHREQ must be sent in response to a REGREQ of an invalid peer unless
8398 * 1. A challenge already exists indicating a AUTHREQ was already sent out.
8399 * 2. A plaintext secret is present in ie as result of a previous AUTHREQ requesting it.
8400 * 3. A plaintext secret is present in the ie and the last_authmethod used by a peer happened
8401 * to be plaintext, indicating it is an authmethod used by other peers on the system.
8402 *
8403 * If none of these cases exist, res will be returned as 0 without authentication indicating
8404 * an AUTHREQ needs to be sent out. */
8405
8406 if (ast_strlen_zero(iaxs[callno]->challenge) &&
8407 !(!ast_strlen_zero(secret) && plaintext)) {
8408 /* by setting res to 0, an REGAUTH will be sent */
8409 res = 0;
8410 }
8411 }
8412 if (authdebug && !p)
8413 ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
8414 goto return_unref;
8415 }
8416
8417 if (!ast_test_flag64(p, IAX_DYNAMIC)) {
8418 if (authdebug)
8419 ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, ast_sockaddr_stringify_addr(addr));
8420 goto return_unref;
8421 }
8422
8423 if (!ast_apply_acl(p->acl, addr, "IAX2 Peer ACL: ")) {
8424 if (authdebug)
8425 ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
8426 goto return_unref;
8427 }
8428 ast_string_field_set(iaxs[callno], secret, p->secret);
8429 ast_string_field_set(iaxs[callno], inkeys, p->inkeys);
8430 /* Check secret against what we have on file */
8431 if (!ast_strlen_zero(rsasecret) && (p->authmethods & IAX_AUTH_RSA) && !ast_strlen_zero(iaxs[callno]->challenge)) {
8432 if (!ast_strlen_zero(p->inkeys)) {
8433 char *tmpkey;
8434 char *stringp=NULL;
8435 if (!(tmpkey = ast_strdup(p->inkeys))) {
8436 ast_log(LOG_ERROR, "Unable to create a temporary string for parsing stored 'inkeys'\n");
8437 goto return_unref;
8438 }
8439 stringp = tmpkey;
8440 keyn = strsep(&stringp, ":");
8441 while(keyn) {
8442 key = ast_key_get(keyn, AST_KEY_PUBLIC);
8443 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
8444 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8445 break;
8446 } else if (!key)
8447 ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
8448 keyn = strsep(&stringp, ":");
8449 }
8450 ast_free(tmpkey);
8451 if (!keyn) {
8452 if (authdebug)
8453 ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
8454 goto return_unref;
8455 }
8456 } else {
8457 if (authdebug)
8458 ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
8459 goto return_unref;
8460 }
8461 } else if (!ast_strlen_zero(md5secret) && (p->authmethods & IAX_AUTH_MD5) && !ast_strlen_zero(iaxs[callno]->challenge)) {
8462 struct MD5Context md5;
8463 unsigned char digest[16];
8464 char *tmppw, *stringp;
8465
8466 tmppw = ast_strdupa(p->secret);
8467 stringp = tmppw;
8468 while((tmppw = strsep(&stringp, ";"))) {
8469 MD5Init(&md5);
8470 MD5Update(&md5, (unsigned char *)iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
8471 MD5Update(&md5, (unsigned char *)tmppw, strlen(tmppw));
8472 MD5Final(digest, &md5);
8473 for (x=0;x<16;x++)
8474 sprintf(requeststr + (x << 1), "%02hhx", digest[x]); /* safe */
8475 if (!strcasecmp(requeststr, md5secret))
8476 break;
8477 }
8478 if (tmppw) {
8479 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8480 } else {
8481 if (authdebug)
8482 ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", ast_sockaddr_stringify_addr(addr), p->name, requeststr, md5secret);
8483 goto return_unref;
8484 }
8485 } else if (!ast_strlen_zero(secret) && (p->authmethods & IAX_AUTH_PLAINTEXT)) {
8486 /* They've provided a plain text password and we support that */
8487 if (strcmp(secret, p->secret)) {
8488 if (authdebug)
8489 ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", ast_sockaddr_stringify_addr(addr), p->name);
8490 goto return_unref;
8491 } else
8492 ast_set_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED);
8493 } else if (!ast_strlen_zero(iaxs[callno]->challenge) && ast_strlen_zero(md5secret) && ast_strlen_zero(rsasecret)) {
8494 /* if challenge has been sent, but no challenge response if given, reject. */
8495 goto return_unref;
8496 }
8497 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
8498
8499 /* either Authentication has taken place, or a REGAUTH must be sent before verifying registration */
8500 res = 0;
8501
8502return_unref:
8503 if (iaxs[callno]) {
8504 ast_string_field_set(iaxs[callno], peer, peer);
8505
8506 /* Choose lowest expiry number */
8507 if (expire && (expire < iaxs[callno]->expiry)) {
8508 iaxs[callno]->expiry = expire;
8509 }
8510 }
8511
8512 if (p) {
8513 peer_unref(p);
8514 }
8515 return res;
8516}

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 9375 of file chan_iax2.c.

9376{
9377 struct iax_ie_data ied;
9378 struct iax2_peer *p;
9379 char challenge[10];
9380 const char *peer_name;
9381 int sentauthmethod;
9382
9383 peer_name = ast_strdupa(iaxs[callno]->peer);
9384
9385 /* SLD: third call to find_peer in registration */
9386 ast_mutex_unlock(&iaxsl[callno]);
9387 if ((p = find_peer(peer_name, 1))) {
9388 last_authmethod = p->authmethods;
9389 }
9390
9391 ast_mutex_lock(&iaxsl[callno]);
9392 if (!iaxs[callno])
9393 goto return_unref;
9394
9395 memset(&ied, 0, sizeof(ied));
9396 /* The selection of which delayed reject is sent may leak information,
9397 * if it sets a static response. For example, if a host is known to only
9398 * use MD5 authentication, then an RSA response would indicate that the
9399 * peer does not exist, and vice-versa.
9400 * Therefore, we use whatever the last peer used (which may vary over the
9401 * course of a server, which should leak minimal information). */
9402 sentauthmethod = p ? p->authmethods : last_authmethod ? last_authmethod : IAX_AUTH_MD5;
9403 if (!p) {
9404 iaxs[callno]->authmethods = sentauthmethod;
9405 }
9406 iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, sentauthmethod);
9407 if (sentauthmethod & (IAX_AUTH_RSA | IAX_AUTH_MD5)) {
9408 /* Build the challenge */
9409 snprintf(challenge, sizeof(challenge), "%d", (int)ast_random());
9410 ast_string_field_set(iaxs[callno], challenge, challenge);
9411 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, iaxs[callno]->challenge);
9412 }
9413 iax_ie_append_str(&ied, IAX_IE_USERNAME, peer_name);
9414
9415return_unref:
9416 if (p) {
9417 peer_unref(p);
9418 }
9419
9420 return iaxs[callno] ? send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGAUTH, 0, ied.buf, ied.pos, -1) : -1;
9421}

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 9423 of file chan_iax2.c.

9424{
9425 struct iax2_registry *reg;
9426 /* Start pessimistic */
9427 struct iax_ie_data ied;
9428 char peer[256] = "";
9429 char challenge[256] = "";
9430 int res;
9431 int authmethods = 0;
9432 if (ies->authmethods)
9433 authmethods = ies->authmethods;
9434 if (ies->username)
9435 ast_copy_string(peer, ies->username, sizeof(peer));
9436 if (ies->challenge)
9437 ast_copy_string(challenge, ies->challenge, sizeof(challenge));
9438 memset(&ied, 0, sizeof(ied));
9439 reg = iaxs[callno]->reg;
9440 if (reg) {
9441
9442 if (ast_sockaddr_cmp(&reg->addr, addr)) {
9443 ast_log(LOG_WARNING, "Received unsolicited registry authenticate request from '%s'\n", ast_sockaddr_stringify(addr));
9444 return -1;
9445 }
9446 if (ast_strlen_zero(reg->secret)) {
9447 ast_log(LOG_NOTICE, "No secret associated with peer '%s'\n", reg->username);
9448 reg->regstate = REG_STATE_NOAUTH;
9449 return -1;
9450 }
9451 iax_ie_append_str(&ied, IAX_IE_USERNAME, reg->username);
9452 iax_ie_append_short(&ied, IAX_IE_REFRESH, reg->refresh);
9453 if (reg->secret[0] == '[') {
9454 char tmpkey[256];
9455 ast_copy_string(tmpkey, reg->secret + 1, sizeof(tmpkey));
9456 tmpkey[strlen(tmpkey) - 1] = '\0';
9457 res = authenticate(challenge, NULL, tmpkey, authmethods, &ied, addr, NULL);
9458 } else
9459 res = authenticate(challenge, reg->secret, NULL, authmethods, &ied, addr, NULL);
9460 if (!res) {
9461 reg->regstate = REG_STATE_AUTHSENT;
9462 add_empty_calltoken_ie(iaxs[callno], &ied); /* this _MUST_ be the last ie added */
9463 return send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
9464 } else
9465 return -1;
9466 ast_log(LOG_WARNING, "Registry acknowledge on unknown registry '%s'\n", peer);
9467 } else
9468 ast_log(LOG_NOTICE, "Can't reregister without a reg\n");
9469 return -1;
9470}

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 7459 of file chan_iax2.c.

7460{
7461 switch(regstate) {
7462 case REG_STATE_UNREGISTERED:
7463 return "Unregistered";
7464 case REG_STATE_REGSENT:
7465 return "Request Sent";
7466 case REG_STATE_AUTHSENT:
7467 return "Auth. Sent";
7468 case REG_STATE_REGISTERED:
7469 return "Registered";
7470 case REG_STATE_REJECTED:
7471 return "Rejected";
7472 case REG_STATE_TIMEOUT:
7473 return "Timeout";
7474 case REG_STATE_NOAUTH:
7475 return "No Authentication";
7476 default:
7477 return "Unknown";
7478 }
7479}

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 14229 of file chan_iax2.c.

14230{
14231 return reload_config(0);
14232}

References reload_config().

Referenced by set_config().

◆ reload_config()

static int reload_config ( int  forced_reload)
static

Definition at line 14180 of file chan_iax2.c.

14181{
14182 static const char config[] = "iax.conf";
14183 struct iax2_registry *reg;
14184
14185 if (set_config(config, 1, forced_reload) > 0) {
14186 prune_peers();
14187 prune_users();
14188 ao2_callback(callno_limits, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
14189 ao2_callback(calltoken_ignores, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, prune_addr_range_cb, NULL);
14190 ao2_callback(peercnts, OBJ_NODATA, set_peercnt_limit_all_cb, NULL);
14191 trunk_timed = trunk_untimed = 0;
14192 trunk_nmaxmtu = trunk_maxmtu = 0;
14193 memset(&debugaddr, '\0', sizeof(debugaddr));
14194
14195 AST_LIST_LOCK(&registrations);
14196 AST_LIST_TRAVERSE(&registrations, reg, entry)
14197 iax2_do_register(reg);
14198 AST_LIST_UNLOCK(&registrations);
14199
14200 /* Qualify hosts, too */
14201 poke_all_peers();
14202 }
14203
14204 iax_firmware_reload();
14205 iax_provision_reload(1);
14206 ast_unload_realtime("iaxpeers");
14207
14208 return 0;
14209}

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.

◆ remove_by_peercallno()

static void remove_by_peercallno ( struct chan_iax2_pvt *  pvt)
static

Definition at line 2514 of file chan_iax2.c.

2515{
2516 if (!pvt->peercallno) {
2517 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2518 return;
2519 }
2520
2521 ao2_unlink(iax_peercallno_pvts, pvt);
2522}

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 2495 of file chan_iax2.c.

2496{
2497 if (!pvt->transfercallno) {
2498 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2499 return;
2500 }
2501
2502 ao2_unlink(iax_transfercallno_pvts, pvt);
2503}

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 3068 of file chan_iax2.c.

3069{
3070 callno_entry entry = PTR_TO_CALLNO_ENTRY(obj);
3071 struct call_number_pool *pool;
3072
3073 /* We lock here primarily to ensure thread safety of the
3074 * total_nonval_callno_used check and decrement */
3075 ast_mutex_lock(&callno_pool_lock);
3076
3077 if (!CALLNO_ENTRY_IS_VALIDATED(entry)) {
3078 if (total_nonval_callno_used) {
3079 total_nonval_callno_used--;
3080 } else {
3081 ast_log(LOG_ERROR,
3082 "Attempted to decrement total non calltoken validated "
3083 "callnumbers below zero. Callno is: %d\n",
3084 CALLNO_ENTRY_GET_CALLNO(entry));
3085 }
3086 }
3087
3088 if (CALLNO_ENTRY_GET_CALLNO(entry) < TRUNK_CALL_START) {
3089 pool = &callno_pool;
3090 } else {
3091 pool = &callno_pool_trunk;
3092 }
3093
3094 ast_assert(pool->capacity > pool->available);
3095
3096 /* This clears the validated flag */
3097 entry = CALLNO_ENTRY_GET_CALLNO(entry);
3098
3099 pool->numbers[pool->available] = entry;
3100 pool->available++;
3101
3102 ast_mutex_unlock(&callno_pool_lock);
3103
3104 return 0;
3105}

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 5003 of file chan_iax2.c.

5004{
5005 struct iax2_user *user = NULL;
5006 struct iax2_peer *peer = NULL;
5007
5008 if (ast_strlen_zero(name)) {
5009 return; /* no username given */
5010 }
5011
5012 if ((subclass == IAX_COMMAND_NEW) && (user = find_user(name)) && (user->calltoken_required == CALLTOKEN_AUTO)) {
5013 user->calltoken_required = CALLTOKEN_YES;
5014 } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(name, 1)) && (peer->calltoken_required == CALLTOKEN_AUTO)) {
5015 peer->calltoken_required = CALLTOKEN_YES;
5016 }
5017
5018 if (peer) {
5019 peer_unref(peer);
5020 }
5021 if (user) {
5022 user_unref(user);
5023 }
5024}

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 4921 of file chan_iax2.c.

4922{
4923 struct chan_iax2_pvt *pvt = iaxs[callno];
4924 int frametype = f->af.frametype;
4925 int subclass = f->af.subclass.integer;
4926 struct {
4927 struct ast_iax2_full_hdr fh;
4928 struct iax_ie_data ied;
4929 } data = {
4930 .ied.buf = { 0 },
4931 .ied.pos = 0,
4932 };
4933 /* total len - header len gives us the frame's IE len */
4934 int ie_data_pos = f->datalen - sizeof(struct ast_iax2_full_hdr);
4935
4936 if (!pvt) {
4937 return; /* this should not be possible if called from socket_process() */
4938 }
4939
4940 /*
4941 * Check to make sure last frame sent is valid for call token resend
4942 * 1. Frame should _NOT_ be encrypted since it starts the IAX dialog
4943 * 2. Frame should _NOT_ already have a destination callno
4944 * 3. Frame must be a valid iax_frame subclass capable of starting dialog
4945 * 4. Pvt must have a calltoken_ie_len which represents the number of
4946 * bytes at the end of the frame used for the previous calltoken ie.
4947 * 5. Pvt's calltoken_ie_len must be _LESS_ than the total IE length
4948 * 6. Total length of f->data must be _LESS_ than size of our data struct
4949 * because f->data must be able to fit within data.
4950 */
4951 if (f->encmethods || f->dcallno || !iax2_allow_new(frametype, subclass, 0)
4952 || !pvt->calltoken_ie_len || (pvt->calltoken_ie_len > ie_data_pos) ||
4953 (f->datalen > sizeof(data))) {
4954
4955 return; /* ignore resend, token was not valid for the dialog */
4956 }
4957
4958 /* token is valid
4959 * 1. Copy frame data over
4960 * 2. Redo calltoken IE, it will always be the last ie in the frame.
4961 * NOTE: Having the ie always be last is not protocol specified,
4962 * it is only an implementation choice. Since we only expect the ie to
4963 * be last for frames we have sent, this can no way be affected by
4964 * another end point.
4965 * 3. Remove frame from queue
4966 * 4. Free old frame
4967 * 5. Clear previous seqnos
4968 * 6. Resend with CALLTOKEN ie.
4969 */
4970
4971 /* ---1.--- */
4972 memcpy(&data, f->data, f->datalen);
4973 data.ied.pos = ie_data_pos;
4974
4975 /* ---2.--- */
4976 /* move to the beginning of the calltoken ie so we can write over it */
4977 data.ied.pos -= pvt->calltoken_ie_len;
4978 iax_ie_append_str(&data.ied, IAX_IE_CALLTOKEN, newtoken);
4979
4980 /* make sure to update token length incase it ever has to be stripped off again */
4981 pvt->calltoken_ie_len = data.ied.pos - ie_data_pos; /* new pos minus old pos tells how big token ie is */
4982
4983 /* ---3.--- */
4984 AST_LIST_REMOVE(&frame_queue[callno], f, list);
4985
4986 /* ---4.--- */
4987 iax2_frame_free(f);
4988
4989 /* ---5.--- */
4990 pvt->oseqno = 0;
4991 pvt->rseqno = 0;
4992 pvt->iseqno = 0;
4993 pvt->aseqno = 0;
4994 if (pvt->peercallno) {
4995 remove_by_peercallno(pvt);
4996 pvt->peercallno = 0;
4997 }
4998
4999 /* ---6.--- */
5000 send_command(pvt, AST_FRAME_IAX, subclass, 0, data.ied.buf, data.ied.pos, -1);
5001}

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 9834 of file chan_iax2.c.

9835{
9836 int i;
9837 unsigned int length, offset = 0;
9838 char full_osptoken[IAX_MAX_OSPBUFF_SIZE];
9839
9840 for (i = 0; i < IAX_MAX_OSPBLOCK_NUM; i++) {
9841 length = ies->ospblocklength[i];
9842 if (length != 0) {
9843 if (length > IAX_MAX_OSPBLOCK_SIZE) {
9844 /* OSP token block length wrong, clear buffer */
9845 offset = 0;
9846 break;
9847 } else {
9848 memcpy(full_osptoken + offset, ies->osptokenblock[i], length);
9849 offset += length;
9850 }
9851 } else {
9852 break;
9853 }
9854 }
9855 *(full_osptoken + offset) = '\0';
9856 if (strlen(full_osptoken) != offset) {
9857 /* OSP token length wrong, clear buffer */
9858 *full_osptoken = '\0';
9859 }
9860
9861 ast_string_field_set(iaxs[fr->callno], osptoken, full_osptoken);
9862}

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 9823 of file chan_iax2.c.

9824{
9825 iaxs[fr->callno]->remote_rr.jitter = ies->rr_jitter;
9826 iaxs[fr->callno]->remote_rr.losspct = ies->rr_loss >> 24;
9827 iaxs[fr->callno]->remote_rr.losscnt = ies->rr_loss & 0xffffff;
9828 iaxs[fr->callno]->remote_rr.packets = ies->rr_pkts;
9829 iaxs[fr->callno]->remote_rr.delay = ies->rr_delay;
9830 iaxs[fr->callno]->remote_rr.dropped = ies->rr_dropped;
9831 iaxs[fr->callno]->remote_rr.ooo = ies->rr_ooo;
9832}

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 3140 of file chan_iax2.c.

3141{
3142 int i;
3143 struct peercnt *peercnt;
3144 struct peercnt tmp;
3145
3146 ast_sockaddr_copy(&tmp.addr, addr);
3147
3148 if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
3149 /* refcount is incremented with ao2_find. keep that ref for the scheduler */
3150 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_sockaddr_stringify_addr(addr), MIN_REUSE_TIME);
3151 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
3152 if (i == -1) {
3153 ao2_ref(peercnt, -1);
3154 }
3155 }
3156
3157 iax2_sched_add(
3158 sched,
3159 MIN_REUSE_TIME * 1000,
3160 replace_callno,
3161 CALLNO_ENTRY_TO_PTR(entry));
3162}

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 4329 of file chan_iax2.c.

4330{
4331 int type, len;
4332 int ret;
4333 int needfree = 0;
4334
4335 /*
4336 * Clear fr->af.data if there is no data in the buffer. Things
4337 * like AST_CONTROL_HOLD without a suggested music class must
4338 * have a NULL pointer.
4339 */
4340 if (!fr->af.datalen) {
4341 memset(&fr->af.data, 0, sizeof(fr->af.data));
4342 }
4343
4344 /* Attempt to recover wrapped timestamps */
4345 unwrap_timestamp(fr);
4346
4347 /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
4348 if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
4349 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
4350 else {
4351#if 0
4352 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
4353#endif
4354 fr->af.delivery = ast_tv(0,0);
4355 }
4356
4357 type = JB_TYPE_CONTROL;
4358 len = 0;
4359
4360 if(fr->af.frametype == AST_FRAME_VOICE) {
4361 type = JB_TYPE_VOICE;
4362 len = ast_codec_samples_count(&fr->af) / (ast_format_get_sample_rate(fr->af.subclass.format) / 1000);
4363 } else if(fr->af.frametype == AST_FRAME_CNG) {
4364 type = JB_TYPE_SILENCE;
4365 }
4366
4367 if ( (!ast_test_flag64(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
4368 if (tsout)
4369 *tsout = fr->ts;
4370 __do_deliver(fr);
4371 return -1;
4372 }
4373
4374 /* insert into jitterbuffer */
4375 /* TODO: Perhaps we could act immediately if it's not droppable and late */
4376 ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
4377 calc_rxstamp(iaxs[fr->callno],fr->ts));
4378 if (ret == JB_DROP) {
4379 needfree++;
4380 } else if (ret == JB_SCHED) {
4381 update_jbsched(iaxs[fr->callno]);
4382 }
4383 if (tsout)
4384 *tsout = fr->ts;
4385 if (needfree) {
4386 /* Free our iax frame */
4387 iax2_frame_free(fr);
4388 return -1;
4389 }
4390 return 0;
4391}

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 2222 of file chan_iax2.c.

2223{
2224 unsigned short callno = PTR_TO_CALLNO(vid);
2225 ast_mutex_lock(&iaxsl[callno]);
2226 if (iaxs[callno]) {
2227 ast_debug(1, "Really destroying %d now...\n", callno);
2228 iax2_destroy(callno);
2229 }
2230 ast_mutex_unlock(&iaxsl[callno]);
2231 return 0;
2232}

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 4883 of file chan_iax2.c.

4886{
4887 struct {
4888 struct ast_iax2_full_hdr f;
4889 struct iax_ie_data ied;
4890 } data;
4891 size_t size = sizeof(struct ast_iax2_full_hdr);
4892
4893 if (ied) {
4894 size += ied->pos;
4895 memcpy(&data.ied, ied->buf, ied->pos);
4896 }
4897
4898 data.f.scallno = htons(0x8000 | callno);
4899 data.f.dcallno = htons(dcallno & ~IAX_FLAG_RETRANS);
4900 data.f.ts = htonl(ts);
4901 data.f.iseqno = seqno;
4902 data.f.oseqno = 0;
4903 data.f.type = AST_FRAME_IAX;
4904 data.f.csub = compress_subclass(command);
4905
4906 iax_outputframe(NULL, &data.f, 0, addr, size - sizeof(struct ast_iax2_full_hdr));
4907
4908 return ast_sendto(sockfd, &data, size, 0, addr);
4909}

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 7884 of file chan_iax2.c.

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

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 7909 of file chan_iax2.c.

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

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 7919 of file chan_iax2.c.

7920{
7921 return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
7922}

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 7895 of file chan_iax2.c.

7896{
7897 int res;
7898 ast_mutex_lock(&iaxsl[callno]);
7899 res = send_command(iaxs[callno], type, command, ts, data, datalen, seqno);
7900 ast_mutex_unlock(&iaxsl[callno]);
7901 return res;
7902}

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 7924 of file chan_iax2.c.

7925{
7926 return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
7927}

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 1890 of file chan_iax2.c.

1891{
1892#ifdef SCHED_MULTITHREADED
1893 if (schedule_action(__send_lagrq, data))
1894#endif
1895 __send_lagrq(data);
1896 return 0;
1897}

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 3488 of file chan_iax2.c.

3489{
3490 int res;
3491 int callno = f->callno;
3492
3493 /* Don't send if there was an error, but return error instead */
3494 if (!callno || !iaxs[callno] || iaxs[callno]->error)
3495 return -1;
3496
3497 /* Called with iaxsl held */
3498 if (iaxdebug) {
3499 ast_debug(8, "Sending %u on %d/%d to %s\n", f->ts, callno, iaxs[callno]->peercallno, ast_sockaddr_stringify(&iaxs[callno]->addr));
3500 }
3501 if (f->transfer) {
3502 iax_outputframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
3503 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->transfer);
3504 } else {
3505 iax_outputframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
3506 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->addr);
3507 }
3508 if (res < 0) {
3509 if (iaxdebug)
3510 ast_debug(1, "Received error: %s\n", strerror(errno));
3511 handle_error();
3512 } else
3513 res = 0;
3514
3515 return res;
3516}

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 1826 of file chan_iax2.c.

1827{
1828#ifdef SCHED_MULTITHREADED
1829 if (schedule_action(__send_ping, data))
1830#endif
1831 __send_ping(data);
1832
1833 return 0;
1834}

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 2244 of file chan_iax2.c.

2245{
2246 struct signaling_queue_entry *s = NULL;
2247
2248 while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2249 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
2250 free_signaling_queue_entry(s);
2251 }
2252 pvt->hold_signaling = 0;
2253}

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 9604 of file chan_iax2.c.

9605{
9606 int res = 0;
9607 struct iax_frame *fr;
9608 struct ast_iax2_meta_hdr *meta;
9609 struct ast_iax2_meta_trunk_hdr *mth;
9610 int calls = 0;
9611
9612 /* Point to frame */
9613 fr = (struct iax_frame *)tpeer->trunkdata;
9614 /* Point to meta data */
9615 meta = (struct ast_iax2_meta_hdr *)fr->afdata;
9616 mth = (struct ast_iax2_meta_trunk_hdr *)meta->data;
9617 if (tpeer->trunkdatalen) {
9618 /* We're actually sending a frame, so fill the meta trunk header and meta header */
9619 meta->zeros = 0;
9620 meta->metacmd = IAX_META_TRUNK;
9621 if (ast_test_flag64(&globalflags, IAX_TRUNKTIMESTAMPS))
9622 meta->cmddata = IAX_META_TRUNK_MINI;
9623 else
9624 meta->cmddata = IAX_META_TRUNK_SUPERMINI;
9625 mth->ts = htonl(calc_txpeerstamp(tpeer, trunkfreq, now));
9626 /* And the rest of the ast_iax2 header */
9627 fr->direction = DIRECTION_OUTGRESS;
9628 fr->retrans = -1;
9629 fr->transfer = 0;
9630 /* Any appropriate call will do */
9631 fr->data = fr->afdata;
9632 fr->datalen = tpeer->trunkdatalen + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr);
9633 res = transmit_trunk(fr, &tpeer->addr, tpeer->sockfd);
9634 calls = tpeer->calls;
9635#if 0
9636 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));
9637#endif
9638 /* Reset transmit trunk side data */
9639 tpeer->trunkdatalen = 0;
9640 tpeer->calls = 0;
9641 }
9642 if (res < 0)
9643 return res;
9644 return calls;
9645}

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, 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 13711 of file chan_iax2.c.

13712{
13713 struct ast_config *cfg;
13714 iax2_format capability;
13715 struct ast_variable *v;
13716 char *cat;
13717 const char *utype;
13718 const char *tosval;
13719 int format;
13720 int portno = IAX_DEFAULT_PORTNO;
13721 int x;
13722 int mtuv;
13723 int subscribe_network_change = 1;
13724 struct iax2_user *user;
13725 struct iax2_peer *peer;
13726 struct ast_netsock *ns;
13727 struct ast_flags config_flags = { (reload && !forced) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
13728 struct ast_sockaddr bindaddr;
13729 struct iax2_codec_pref prefs_new;
13730
13731 cfg = ast_config_load(config_file, config_flags);
13732
13733 if (!cfg) {
13734 ast_log(LOG_ERROR, "Unable to load config %s\n", config_file);
13735 return -1;
13736 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
13737 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13738 if ((cfg = ast_config_load(config_file, config_flags)) == CONFIG_STATUS_FILEINVALID) {
13739 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13740 return 0;
13741 }
13742 if (!cfg) {
13743 /* should have been able to load the config here */
13744 ast_log(LOG_ERROR, "Unable to load config %s again\n", config_file);
13745 return -1;
13746 }
13747 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
13748 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config_file);
13749 return 0;
13750 } else { /* iax.conf changed */
13751 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
13752 }
13753
13754 if (reload) {
13755 set_config_destroy();
13756 }
13757
13758 ast_sockaddr_parse(&bindaddr, "0.0.0.0:0", 0);
13759
13760 /* Setup new codec prefs */
13761 capability = iax2_codec_pref_from_bitfield(&prefs_new, IAX_CAPABILITY_FULLBANDWIDTH);
13762
13763 /* Reset Global Flags */
13764 memset(&globalflags, 0, sizeof(globalflags));
13765 ast_set_flag64(&globalflags, IAX_RTUPDATE);
13766 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
13767
13768#ifdef SO_NO_CHECK
13769 nochecksums = 0;
13770#endif
13771 /* Reset default parking lot */
13772 default_parkinglot[0] = '\0';
13773
13774 min_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13775 max_reg_expire = IAX_DEFAULT_REG_EXPIRE;
13776 global_max_trunk_mtu = MAX_TRUNK_MTU;
13777 global_maxcallno = DEFAULT_MAXCALLNO_LIMIT;
13778 global_maxcallno_nonval = DEFAULT_MAXCALLNO_LIMIT_NONVAL;
13779
13780 maxauthreq = 3;
13781
13782 srvlookup = 0;
13783 iax2_authmethods = 0;
13784
13785 v = ast_variable_browse(cfg, "general");
13786
13787 /* Seed initial tos value */
13788 tosval = ast_variable_retrieve(cfg, "general", "tos");
13789 if (tosval) {
13790 if (ast_str2tos(tosval, &qos.tos))
13791 ast_log(LOG_WARNING, "Invalid tos value, refer to QoS documentation\n");
13792 }
13793 /* Seed initial cos value */
13794 tosval = ast_variable_retrieve(cfg, "general", "cos");
13795 if (tosval) {
13796 if (ast_str2cos(tosval, &qos.cos))
13797 ast_log(LOG_WARNING, "Invalid cos value, refer to QoS documentation\n");
13798 }
13799 while(v) {
13800 if (!strcasecmp(v->name, "bindport")) {
13801 if (reload) {
13802 ast_log(LOG_NOTICE, "Ignoring bindport on reload\n");
13803 }
13804 else if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE, &portno, 1024, 65535)) {
13805 portno = IAX_DEFAULT_PORTNO;
13806 }
13807 } else if (!strcasecmp(v->name, "pingtime")){
13808 ping_time = atoi(v->value);
13809 }
13810 else if (!strcasecmp(v->name, "iaxthreadcount")) {
13811 if (reload) {
13812 if (atoi(v->value) != iaxthreadcount)
13813 ast_log(LOG_NOTICE, "Ignoring any changes to iaxthreadcount during reload\n");
13814 } else {
13815 iaxthreadcount = atoi(v->value);
13816 if (iaxthreadcount < 1) {
13817 ast_log(LOG_NOTICE, "iaxthreadcount must be at least 1.\n");
13818 iaxthreadcount = 1;
13819 } else if (iaxthreadcount > 256) {
13820 ast_log(LOG_NOTICE, "limiting iaxthreadcount to 256\n");
13821 iaxthreadcount = 256;
13822 }
13823 }
13824 } else if (!strcasecmp(v->name, "iaxmaxthreadcount")) {
13825 if (reload) {
13826 AST_LIST_LOCK(&dynamic_list);
13827 iaxmaxthreadcount = atoi(v->value);
13828 AST_LIST_UNLOCK(&dynamic_list);
13829 } else {
13830 iaxmaxthreadcount = atoi(v->value);
13831 if (iaxmaxthreadcount < 0) {
13832 ast_log(LOG_NOTICE, "iaxmaxthreadcount must be at least 0.\n");
13833 iaxmaxthreadcount = 0;
13834 } else if (iaxmaxthreadcount > 256) {
13835 ast_log(LOG_NOTICE, "Limiting iaxmaxthreadcount to 256\n");
13836 iaxmaxthreadcount = 256;
13837 }
13838 }
13839 } else if (!strcasecmp(v->name, "nochecksums")) {
13840#ifdef SO_NO_CHECK
13841 if (ast_true(v->value))
13842 nochecksums = 1;
13843 else
13844 nochecksums = 0;
13845#else
13846 if (ast_true(v->value))
13847 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
13848#endif
13849 }
13850 else if (!strcasecmp(v->name, "maxjitterbuffer"))
13851 maxjitterbuffer = atoi(v->value);
13852 else if (!strcasecmp(v->name, "resyncthreshold"))
13853 resyncthreshold = atoi(v->value);
13854 else if (!strcasecmp(v->name, "maxjitterinterps"))
13855 maxjitterinterps = atoi(v->value);
13856 else if (!strcasecmp(v->name, "jittertargetextra"))
13857 jittertargetextra = atoi(v->value);
13858 else if (!strcasecmp(v->name, "lagrqtime"))
13859 lagrq_time = atoi(v->value);
13860 else if (!strcasecmp(v->name, "maxregexpire"))
13861 max_reg_expire = atoi(v->value);
13862 else if (!strcasecmp(v->name, "minregexpire"))
13863 min_reg_expire = atoi(v->value);
13864 else if (!strcasecmp(v->name, "bindaddr")) {
13865 if (reload) {
13866 ast_log(LOG_NOTICE, "Ignoring bindaddr on reload\n");
13867 } else {
13868
13869 if (!ast_parse_arg(v->value, PARSE_ADDR, NULL)) {
13870
13871 ast_sockaddr_parse(&bindaddr, v->value, 0);
13872
13873 if (!ast_sockaddr_port(&bindaddr)) {
13874 ast_sockaddr_set_port(&bindaddr, portno);
13875 }
13876
13877 if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
13878 ast_log(LOG_WARNING, "Unable to apply binding to '%s' at line %d\n", v->value, v->lineno);
13879 } else {
13880 ast_verb(2, "Binding IAX2 to address %s\n", ast_sockaddr_stringify(&bindaddr));
13881
13882 if (defaultsockfd < 0) {
13883 defaultsockfd = ast_netsock_sockfd(ns);
13884 }
13885 ast_netsock_unref(ns);
13886 }
13887
13888 } else {
13889 ast_log(LOG_WARNING, "Invalid address '%s' specified, at line %d\n", v->value, v->lineno);
13890 }
13891 }
13892 } else if (!strcasecmp(v->name, "auth")) {
13893 iax2_authmethods = get_auth_methods(v->value);
13894 if (iax2_authmethods & IAX_AUTH_PLAINTEXT) {
13895 ast_log(LOG_WARNING, "Default auth method is set to deprecated 'plaintext' at line %d of iax.conf\n", v->lineno);
13896 }
13897 } else if (!strcasecmp(v->name, "authdebug")) {
13898 authdebug = ast_true(v->value);
13899 } else if (!strcasecmp(v->name, "encryption")) {
13900 iax2_encryption |= get_encrypt_methods(v->value);
13901 if (!iax2_encryption) {
13902 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13903 }
13904 } else if (!strcasecmp(v->name, "forceencryption")) {
13905 if (ast_false(v->value)) {
13906 ast_clear_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13907 } else {
13908 iax2_encryption |= get_encrypt_methods(v->value);
13909 if (iax2_encryption) {
13910 ast_set_flag64((&globalflags), IAX_FORCE_ENCRYPT);
13911 }
13912 }
13913 } else if (!strcasecmp(v->name, "transfer")) {
13914 if (!strcasecmp(v->value, "mediaonly")) {
13915 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_TRANSFERMEDIA);
13916 } else if (ast_true(v->value)) {
13917 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, 0);
13918 } else
13919 ast_set_flags_to64((&globalflags), IAX_NOTRANSFER|IAX_TRANSFERMEDIA, IAX_NOTRANSFER);
13920 } else if (!strcasecmp(v->name, "codecpriority")) {
13921 if(!strcasecmp(v->value, "caller"))
13922 ast_set_flag64((&globalflags), IAX_CODEC_USER_FIRST);
13923 else if(!strcasecmp(v->value, "disabled"))
13924 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13925 else if(!strcasecmp(v->value, "reqonly")) {
13926 ast_set_flag64((&globalflags), IAX_CODEC_NOCAP);
13927 ast_set_flag64((&globalflags), IAX_CODEC_NOPREFS);
13928 }
13929 } else if (!strcasecmp(v->name, "jitterbuffer"))
13930 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_USEJITTERBUF);
13931 else if (!strcasecmp(v->name, "delayreject"))
13932 delayreject = ast_true(v->value);
13933 else if (!strcasecmp(v->name, "allowfwdownload"))
13934 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_ALLOWFWDOWNLOAD);
13935 else if (!strcasecmp(v->name, "rtcachefriends"))
13936 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTCACHEFRIENDS);
13937 else if (!strcasecmp(v->name, "rtignoreregexpire"))
13938 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTIGNOREREGEXPIRE);
13939 else if (!strcasecmp(v->name, "rtupdate"))
13940 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTUPDATE);
13941 else if (!strcasecmp(v->name, "rtsavesysname"))
13942 ast_set2_flag64((&globalflags), ast_true(v->value), IAX_RTSAVE_SYSNAME);
13943 else if (!strcasecmp(v->name, "trunktimestamps"))
13944 ast_set2_flag64(&globalflags, ast_true(v->value), IAX_TRUNKTIMESTAMPS);
13945 else if (!strcasecmp(v->name, "rtautoclear")) {
13946 int i = atoi(v->value);
13947 if(i > 0)
13948 global_rtautoclear = i;
13949 else
13950 i = 0;
13951 ast_set2_flag64((&globalflags), i || ast_true(v->value), IAX_RTAUTOCLEAR);
13952 } else if (!strcasecmp(v->name, "trunkfreq")) {
13953 trunkfreq = atoi(v->value);
13954 if (trunkfreq < 10) {
13955 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 10ms instead.\n");
13956 trunkfreq = 10;
13957 } else if (trunkfreq > 1000) {
13958 ast_log(LOG_NOTICE, "trunkfreq must be between 10ms and 1000ms, using 1000ms instead.\n");
13959 trunkfreq = 1000;
13960 }
13961 if (timer) {
13962 ast_timer_set_rate(timer, 1000 / trunkfreq);
13963 }
13964 } else if (!strcasecmp(v->name, "trunkmtu")) {
13965 mtuv = atoi(v->value);
13966 if (mtuv == 0 )
13967 global_max_trunk_mtu = 0;
13968 else if (mtuv >= 172 && mtuv < 4000)
13969 global_max_trunk_mtu = mtuv;
13970 else
13971 ast_log(LOG_NOTICE, "trunkmtu value out of bounds (%d) at line %d\n",
13972 mtuv, v->lineno);
13973 } else if (!strcasecmp(v->name, "trunkmaxsize")) {
13974 trunkmaxsize = atoi(v->value);
13975 if (trunkmaxsize == 0)
13976 trunkmaxsize = MAX_TRUNKDATA;
13977 } else if (!strcasecmp(v->name, "autokill")) {
13978 if (sscanf(v->value, "%30d", &x) == 1) {
13979 if (x >= 0)
13980 autokill = x;
13981 else
13982 ast_log(LOG_NOTICE, "Nice try, but autokill has to be >0 or 'yes' or 'no' at line %d\n", v->lineno);
13983 } else if (ast_true(v->value)) {
13984 autokill = DEFAULT_MAXMS;
13985 } else {
13986 autokill = 0;
13987 }
13988 } else if (!strcasecmp(v->name, "bandwidth")) {
13989 if (!strcasecmp(v->value, "low")) {
13990 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13991 IAX_CAPABILITY_LOWBANDWIDTH);
13992 } else if (!strcasecmp(v->value, "medium")) {
13993 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13994 IAX_CAPABILITY_MEDBANDWIDTH);
13995 } else if (!strcasecmp(v->value, "high")) {
13996 capability = iax2_codec_pref_from_bitfield(&prefs_new,
13997 IAX_CAPABILITY_FULLBANDWIDTH);
13998 } else {
13999 ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
14000 }
14001 } else if (!strcasecmp(v->name, "allow")) {
14002 iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 1);
14003 } else if (!strcasecmp(v->name, "disallow")) {
14004 iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 0);
14005 } else if (!strcasecmp(v->name, "register")) {
14006 iax2_register(v->value, v->lineno);
14007 } else if (!strcasecmp(v->name, "iaxcompat")) {
14008 iaxcompat = ast_true(v->value);
14009 } else if (!strcasecmp(v->name, "regcontext")) {
14010 ast_copy_string(regcontext, v->value, sizeof(regcontext));
14011 /* Create context if it doesn't exist already */
14012 ast_context_find_or_create(NULL, NULL, regcontext, "IAX2");
14013 } else if (!strcasecmp(v->name, "tos")) {
14014 if (ast_str2tos(v->value, &qos.tos))
14015 ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
14016 } else if (!strcasecmp(v->name, "cos")) {
14017 if (ast_str2cos(v->value, &qos.cos))
14018 ast_log(LOG_WARNING, "Invalid cos value at line %d, refer to QoS documentation\n", v->lineno);
14019 } else if (!strcasecmp(v->name, "parkinglot")) {
14020 ast_copy_string(default_parkinglot, v->value, sizeof(default_parkinglot));
14021 } else if (!strcasecmp(v->name, "accountcode")) {
14022 ast_copy_string(accountcode, v->value, sizeof(accountcode));
14023 } else if (!strcasecmp(v->name, "mohinterpret")) {
14024 ast_copy_string(mohinterpret, v->value, sizeof(mohinterpret));
14025 } else if (!strcasecmp(v->name, "mohsuggest")) {
14026 ast_copy_string(mohsuggest, v->value, sizeof(mohsuggest));
14027 } else if (!strcasecmp(v->name, "amaflags")) {
14028 format = ast_channel_string2amaflag(v->value);
14029 if (format < 0) {
14030 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
14031 } else {
14032 amaflags = format;
14033 }
14034 } else if (!strcasecmp(v->name, "language")) {
14035 ast_copy_string(language, v->value, sizeof(language));
14036 } else if (!strcasecmp(v->name, "maxauthreq")) {
14037 maxauthreq = atoi(v->value);
14038 if (maxauthreq < 0)
14039 maxauthreq = 0;
14040 } else if (!strcasecmp(v->name, "adsi")) {
14041 adsi = ast_true(v->value);
14042 } else if (!strcasecmp(v->name, "srvlookup")) {
14043 srvlookup = ast_true(v->value);
14044 } else if (!strcasecmp(v->name, "connectedline")) {
14045 if (ast_true(v->value)) {
14046 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
14047 } else if (!strcasecmp(v->value, "send")) {
14048 ast_clear_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
14049 ast_set_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
14050 } else if (!strcasecmp(v->value, "receive")) {
14051 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE);
14052 ast_set_flag64((&globalflags), IAX_RECVCONNECTEDLINE);
14053 } else {
14054 ast_clear_flag64((&globalflags), IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
14055 }
14056 } else if (!strcasecmp(v->name, "maxcallnumbers")) {
14057 if (sscanf(v->value, "%10hu", &global_maxcallno) != 1) {
14058 ast_log(LOG_WARNING, "maxcallnumbers must be set to a valid number. %s is not valid at line %d\n", v->value, v->lineno);
14059 }
14060 } else if (!strcasecmp(v->name, "maxcallnumbers_nonvalidated")) {
14061 if (sscanf(v->value, "%10hu", &global_maxcallno_nonval) != 1) {
14062 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);
14063 }
14064 } else if (!strcasecmp(v->name, "calltokenoptional")) {
14065 if (add_calltoken_ignore(v->value)) {
14066 ast_log(LOG_WARNING, "Invalid calltokenoptional address range - '%s' line %d\n", v->value, v->lineno);
14067 return -1;
14068 }
14069 } else if (!strcasecmp(v->name, "calltokenexpiration")) {
14070 int temp = -1;
14071 sscanf(v->value, "%u", &temp);
14072 if( temp <= 0 ){
14073 ast_log(LOG_WARNING, "Invalid calltokenexpiration value %s. Should be integer greater than 0.\n", v->value);
14074 } else {
14075 max_calltoken_delay = temp;
14076 }
14077 } else if (!strcasecmp(v->name, "subscribe_network_change_event")) {
14078 if (ast_true(v->value)) {
14079 subscribe_network_change = 1;
14080 } else if (ast_false(v->value)) {
14081 subscribe_network_change = 0;
14082 } else {
14083 ast_log(LOG_WARNING, "subscribe_network_change_event value %s is not valid at line %d.\n", v->value, v->lineno);
14084 }
14085 } else if (!strcasecmp(v->name, "shrinkcallerid")) {
14086 if (ast_true(v->value)) {
14087 ast_set_flag64((&globalflags), IAX_SHRINKCALLERID);
14088 } else if (ast_false(v->value)) {
14089 ast_clear_flag64((&globalflags), IAX_SHRINKCALLERID);
14090 } else {
14091 ast_log(LOG_WARNING, "shrinkcallerid value %s is not valid at line %d.\n", v->value, v->lineno);
14092 }
14093 }/*else if (strcasecmp(v->name,"type")) */
14094 /* ast_log(LOG_WARNING, "Ignoring %s\n", v->name); */
14095 v = v->next;
14096 }
14097
14098 if (subscribe_network_change) {
14099 network_change_stasis_subscribe();
14100 } else {
14101 network_change_stasis_unsubscribe();
14102 }
14103
14104 if (defaultsockfd < 0) {
14105
14106 ast_sockaddr_set_port(&bindaddr, portno);
14107
14108 if (!(ns = ast_netsock_bindaddr(netsock, io, &bindaddr, qos.tos, qos.cos, socket_read, NULL))) {
14109 ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
14110 } else {
14111 ast_verb(2, "Binding IAX2 to default address %s\n", ast_sockaddr_stringify(&bindaddr));
14112 defaultsockfd = ast_netsock_sockfd(ns);
14113 ast_netsock_unref(ns);
14114 }
14115 }
14116 if (reload) {
14117 ast_netsock_release(outsock);
14118 outsock = ast_netsock_list_alloc();
14119 if (!outsock) {
14120 ast_log(LOG_ERROR, "Could not allocate outsock list.\n");
14121 return -1;
14122 }
14123 ast_netsock_init(outsock);
14124 }
14125
14126 if (min_reg_expire > max_reg_expire) {
14127 ast_log(LOG_WARNING, "Minimum registration interval of %d is more than maximum of %d, resetting minimum to %d\n",
14128 min_reg_expire, max_reg_expire, max_reg_expire);
14129 min_reg_expire = max_reg_expire;
14130 }
14131 prefs_global = prefs_new;
14132 iax2_capability = capability;
14133
14134 cat = ast_category_browse(cfg, NULL);
14135 while(cat) {
14136 if (strcasecmp(cat, "general")) {
14137 utype = ast_variable_retrieve(cfg, cat, "type");
14138 if (!strcasecmp(cat, "callnumberlimits")) {
14139 build_callno_limits(ast_variable_browse(cfg, cat));
14140 } else if (utype) {
14141 if (!strcasecmp(utype, "user") || !strcasecmp(utype, "friend")) {
14142 user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
14143 if (user) {
14144 ao2_link(users, user);
14145 user = user_unref(user);
14146 }
14147 }
14148 if (!strcasecmp(utype, "peer") || !strcasecmp(utype, "friend")) {
14149 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
14150 if (peer) {
14151 if (ast_test_flag64(peer, IAX_DYNAMIC))
14152 reg_source_db(peer);
14153 ao2_link(peers, peer);
14154 peer = peer_unref(peer);
14155 }
14156 } else if (strcasecmp(utype, "user")) {
14157 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config_file);
14158 }
14159 } else
14160 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
14161 }
14162 cat = ast_category_browse(cfg, cat);
14163 }
14164 ast_config_destroy(cfg);
14165 return 1;
14166}

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_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, 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_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 13694 of file chan_iax2.c.

13695{
13696 strcpy(accountcode, "");
13697 strcpy(language, "");
13698 strcpy(mohinterpret, "");
13699 strcpy(mohsuggest, "");
13700 trunkmaxsize = MAX_TRUNKDATA;
13701 amaflags = 0;
13702 delayreject = 0;
13703 ast_clear_flag64((&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF |
13704 IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE);
13705 delete_users();
13706 ao2_callback(callno_limits, OBJ_NODATA, addr_range_delme_cb, NULL);
13707 ao2_callback(calltoken_ignores, OBJ_NODATA, addr_range_delme_cb, NULL);
13708}

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 10257 of file chan_iax2.c.

10258{
10259 iax2_lock_owner(callno);
10260 if (iaxs[callno] && iaxs[callno]->owner) {
10261 struct ast_channel *owner;
10262 const char *name;
10263
10264 owner = iaxs[callno]->owner;
10265 if (causecode) {
10266 ast_channel_hangupcause_set(owner, causecode);
10267 }
10268 name = ast_strdupa(ast_channel_name(owner));
10269 ast_channel_ref(owner);
10270 ast_channel_unlock(owner);
10271 ast_mutex_unlock(&iaxsl[callno]);
10272 ast_set_hangupsource(owner, name, 0);
10273 ast_channel_unref(owner);
10274 ast_mutex_lock(&iaxsl[callno]);
10275 }
10276}

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 2639 of file chan_iax2.c.

2640{
2641 uint16_t limit = global_maxcallno;
2642 struct addr_range *addr_range;
2643 struct ast_sockaddr addr;
2644
2645 ast_sockaddr_copy(&addr, &peercnt->addr);
2646
2647 if (peercnt->reg && peercnt->limit) {
2648 return; /* this peercnt has a custom limit set by a registration */
2649 }
2650
2651 if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &addr))) {
2652 limit = addr_range->limit;
2653 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_sockaddr_stringify(&addr));
2654 ao2_ref(addr_range, -1);
2655 }
2656
2657 peercnt->limit = limit;
2658}

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 2664 of file chan_iax2.c.

2665{
2666 struct peercnt *peercnt = obj;
2667
2668 set_peercnt_limit(peercnt);
2669 ast_debug(1, "Reset limits for peercnts table\n");
2670
2671 return 0;
2672}

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 1196 of file chan_iax2.c.

1197{
1198 ast_mutex_lock(lock);
1199 ast_cond_signal(cond);
1200 ast_mutex_unlock(lock);
1201}

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 12213 of file chan_iax2.c.

12214{
12215 int res = socket_process_helper(thread);
12216 if (ast_read_threadstorage_callid()) {
12217 ast_callid_threadassoc_remove();
12218 }
12219 return res;
12220}

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 10278 of file chan_iax2.c.

10279{
10280 struct ast_sockaddr addr;
10281 int res;
10282 int updatehistory=1;
10283 int new = NEW_PREVENT;
10284 int dcallno = 0;
10285 char decrypted = 0;
10286 struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)thread->buf;
10287 struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)thread->buf;
10288 struct ast_iax2_meta_hdr *meta = (struct ast_iax2_meta_hdr *)thread->buf;
10289 struct ast_iax2_video_hdr *vh = (struct ast_iax2_video_hdr *)thread->buf;
10290 struct iax_frame *fr;
10291 struct iax_frame *cur;
10292 struct ast_frame f = { 0, };
10293 struct ast_channel *c = NULL;
10294 struct iax2_dpcache *dp;
10295 struct iax2_peer *peer;
10296 struct iax_ies ies;
10297 struct iax_ie_data ied0, ied1;
10298 iax2_format format;
10299 int fd;
10300 int exists;
10301 int minivid = 0;
10302 char empty[32]=""; /* Safety measure */
10303 struct iax_frame *duped_fr;
10304 char host_pref_buf[128];
10305 char caller_pref_buf[128];
10306 struct iax2_codec_pref pref;
10307 char *using_prefs = "mine";
10308
10309 /* allocate an iax_frame with 4096 bytes of data buffer */
10310 fr = ast_alloca(sizeof(*fr) + 4096);
10311 memset(fr, 0, sizeof(*fr));
10312 fr->afdatalen = 4096; /* From ast_alloca() above */
10313
10314 /* Copy frequently used parameters to the stack */
10315 res = thread->buf_len;
10316 fd = thread->iofd;
10317 ast_sockaddr_copy(&addr, &thread->ioaddr);
10318
10319 if (res < sizeof(*mh)) {
10320 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, (int) sizeof(*mh));
10321 return 1;
10322 }
10323 if ((vh->zeros == 0) && (ntohs(vh->callno) & 0x8000)) {
10324 if (res < sizeof(*vh)) {
10325 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a video frame but is too short\n",
10326 ast_sockaddr_stringify(&addr));
10327 return 1;
10328 }
10329
10330 /* This is a video frame, get call number */
10331 fr->callno = find_callno(ntohs(vh->callno) & ~0x8000, dcallno, &addr, new, fd, 0);
10332 minivid = 1;
10333 } else if ((meta->zeros == 0) && !(ntohs(meta->metacmd) & 0x8000))
10334 return socket_process_meta(res, meta, &addr, fd, fr);
10335
10336#ifdef DEBUG_SUPPORT
10337 if (res >= sizeof(*fh))
10338 iax_outputframe(NULL, fh, 1, &addr, res - sizeof(*fh));
10339#endif
10340 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10341 if (res < sizeof(*fh)) {
10342 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a full frame but is too short\n",
10343 ast_sockaddr_stringify(&addr));
10344 return 1;
10345 }
10346
10347 /* Get the destination call number */
10348 dcallno = ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS;
10349
10350
10351 /* check to make sure this full frame isn't encrypted before we attempt
10352 * to look inside of it. If it is encrypted, decrypt it first. Its ok if the
10353 * callno is not found here, that just means one hasn't been allocated for
10354 * this connection yet. */
10355 if ((dcallno != 1) && (fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, NEW_PREVENT, fd, 1))) {
10356 ast_mutex_lock(&iaxsl[fr->callno]);
10357 if (iaxs[fr->callno] && ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED)) {
10358 if (decrypt_frame(fr->callno, fh, &f, &res)) {
10359 ast_log(LOG_NOTICE, "Packet Decrypt Failed!\n");
10360 ast_mutex_unlock(&iaxsl[fr->callno]);
10361 return 1;
10362 }
10363 decrypted = 1;
10364 }
10365 ast_mutex_unlock(&iaxsl[fr->callno]);
10366 }
10367
10368 /* Retrieve the type and subclass */
10369 f.frametype = fh->type;
10370 if (f.frametype == AST_FRAME_VIDEO) {
10371 f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub & ~0x40));
10372 if (!f.subclass.format) {
10373 return 1;
10374 }
10375 if ((fh->csub >> 6) & 0x1) {
10376 f.subclass.frame_ending = 1;
10377 }
10378 } else if (f.frametype == AST_FRAME_VOICE) {
10379 f.subclass.format = ast_format_compatibility_bitfield2format(uncompress_subclass(fh->csub));
10380 if (!f.subclass.format) {
10381 return 1;
10382 }
10383 } else {
10384 f.subclass.integer = uncompress_subclass(fh->csub);
10385 }
10386
10387 /* Deal with POKE/PONG without allocating a callno */
10388 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_POKE) {
10389 /* Reply back with a PONG, but don't care about the result. */
10390 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_PONG, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10391 return 1;
10392 } else if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_ACK && dcallno == 1) {
10393 /* Ignore */
10394 return 1;
10395 }
10396
10397 f.datalen = res - sizeof(*fh);
10398 if (f.datalen) {
10399 if (f.frametype == AST_FRAME_IAX) {
10400 if (iax_parse_ies(&ies, thread->buf + sizeof(struct ast_iax2_full_hdr), f.datalen)) {
10401 char subclass[40];
10402 iax_frame_subclass2str(f.subclass.integer, subclass, sizeof(subclass));
10403 ast_log(LOG_WARNING, "Undecodable %s frame received from '%s'\n", subclass, ast_sockaddr_stringify(&addr));
10404 ast_variables_destroy(ies.vars);
10405 return 1;
10406 }
10407 f.data.ptr = NULL;
10408 f.datalen = 0;
10409 } else {
10410 f.data.ptr = thread->buf + sizeof(struct ast_iax2_full_hdr);
10411 memset(&ies, 0, sizeof(ies));
10412 }
10413 } else {
10414 if (f.frametype == AST_FRAME_IAX)
10415 f.data.ptr = NULL;
10416 else
10417 f.data.ptr = empty;
10418 memset(&ies, 0, sizeof(ies));
10419 }
10420
10421 if (!dcallno && iax2_allow_new(f.frametype, f.subclass.integer, 1)) {
10422 /* only set NEW_ALLOW if calltoken checks out */
10423 if (handle_call_token(fh, &ies, &addr, fd)) {
10424 ast_variables_destroy(ies.vars);
10425 return 1;
10426 }
10427
10428 if (ies.calltoken && ies.calltokendata) {
10429 /* if we've gotten this far, and the calltoken ie data exists,
10430 * then calltoken validation _MUST_ have taken place. If calltoken
10431 * data is provided, it is always validated regardless of any
10432 * calltokenoptional or requirecalltoken options */
10433 new = NEW_ALLOW_CALLTOKEN_VALIDATED;
10434 } else {
10435 new = NEW_ALLOW;
10436 }
10437 }
10438 } else {
10439 /* Don't know anything about it yet */
10440 f.frametype = AST_FRAME_NULL;
10441 f.subclass.integer = 0;
10442 memset(&ies, 0, sizeof(ies));
10443 }
10444
10445 if (!fr->callno) {
10446 int check_dcallno = 0;
10447
10448 /*
10449 * We enforce accurate destination call numbers for ACKs. This forces the other
10450 * end to know the destination call number before call setup can complete.
10451 *
10452 * Discussed in the following thread:
10453 * http://lists.digium.com/pipermail/asterisk-dev/2008-May/033217.html
10454 */
10455
10456 if ((ntohs(mh->callno) & IAX_FLAG_FULL) && ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer == IAX_COMMAND_ACK))) {
10457 check_dcallno = 1;
10458 }
10459
10460 if (!(fr->callno = find_callno(ntohs(mh->callno) & ~IAX_FLAG_FULL, dcallno, &addr, new, fd, check_dcallno))) {
10461 ast_debug(1, "Received frame without existent call number (%d)\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
10462 if (f.frametype == AST_FRAME_IAX && f.subclass.integer == IAX_COMMAND_NEW) {
10463 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REJECT, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10464 } else if (f.frametype == AST_FRAME_IAX && (f.subclass.integer == IAX_COMMAND_REGREQ || f.subclass.integer == IAX_COMMAND_REGREL)) {
10465 send_apathetic_reply(1, ntohs(fh->scallno), &addr, IAX_COMMAND_REGREJ, ntohl(fh->ts), fh->iseqno + 1, fd, NULL);
10466 } else {
10467 ast_log(LOG_WARNING, "Silently dropping frame without existent call number: %d\n", ntohs(mh->callno) & ~IAX_FLAG_FULL);
10468 }
10469 ast_variables_destroy(ies.vars);
10470 return 1;
10471 }
10472 }
10473
10474 if (fr->callno > 0) {
10475 ast_callid mount_callid;
10476 ast_mutex_lock(&iaxsl[fr->callno]);
10477 if (iaxs[fr->callno] && ((mount_callid = iax_pvt_callid_get(fr->callno)))) {
10478 /* Bind to thread */
10479 ast_callid_threadassoc_add(mount_callid);
10480 }
10481 }
10482
10483 if (!fr->callno || !iaxs[fr->callno]) {
10484 /* A call arrived for a nonexistent destination. Unless it's an "inval"
10485 frame, reply with an inval */
10486 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10487 /* We can only raw hangup control frames */
10488 if (((f.subclass.integer != IAX_COMMAND_INVAL) &&
10489 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10490 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10491 (f.subclass.integer != IAX_COMMAND_FWDOWNL))||
10492 (f.frametype != AST_FRAME_IAX))
10493 raw_hangup(&addr, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, ntohs(mh->callno) & ~IAX_FLAG_FULL,
10494 fd);
10495 }
10496 if (fr->callno > 0){
10497 ast_mutex_unlock(&iaxsl[fr->callno]);
10498 }
10499 ast_variables_destroy(ies.vars);
10500 return 1;
10501 }
10502 if (ast_test_flag64(iaxs[fr->callno], IAX_ENCRYPTED) && !decrypted) {
10503 if (decrypt_frame(fr->callno, fh, &f, &res)) {
10504 ast_log(LOG_WARNING, "Packet Decrypt Failed!\n");
10505 ast_variables_destroy(ies.vars);
10506 ast_mutex_unlock(&iaxsl[fr->callno]);
10507 return 1;
10508 }
10509 decrypted = 1;
10510 }
10511
10512#ifdef DEBUG_SUPPORT
10513 if (decrypted) {
10514 iax_outputframe(NULL, fh, 3, &addr, res - sizeof(*fh));
10515 }
10516#endif
10517
10518 if (iaxs[fr->callno]->owner && fh->type == AST_FRAME_IAX &&
10519 (fh->csub == IAX_COMMAND_HANGUP
10520 || fh->csub == IAX_COMMAND_REJECT
10521 || fh->csub == IAX_COMMAND_REGREJ
10522 || fh->csub == IAX_COMMAND_TXREJ)) {
10523 struct ast_control_pvt_cause_code *cause_code;
10524 int data_size = sizeof(*cause_code);
10525 char subclass[40] = "";
10526
10527 /* get subclass text */
10528 iax_frame_subclass2str(fh->csub, subclass, sizeof(subclass));
10529
10530 /* add length of "IAX2 " */
10531 data_size += 5;
10532 /* for IAX hangup frames, add length of () and number */
10533 data_size += 3;
10534 if (ies.causecode > 9) {
10535 data_size++;
10536 }
10537 if (ies.causecode > 99) {
10538 data_size++;
10539 }
10540 /* add length of subclass */
10541 data_size += strlen(subclass);
10542
10543 cause_code = ast_alloca(data_size);
10544 memset(cause_code, 0, data_size);
10545 ast_copy_string(cause_code->chan_name, ast_channel_name(iaxs[fr->callno]->owner), AST_CHANNEL_NAME);
10546
10547 cause_code->ast_cause = ies.causecode;
10548 snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "IAX2 %s(%d)", subclass, ies.causecode);
10549
10550 iax2_lock_owner(fr->callno);
10551 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
10552 ast_queue_control_data(iaxs[fr->callno]->owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
10553 ast_channel_hangupcause_hash_set(iaxs[fr->callno]->owner, cause_code, data_size);
10554 ast_channel_unlock(iaxs[fr->callno]->owner);
10555 }
10556 if (!iaxs[fr->callno]) {
10557 ast_variables_destroy(ies.vars);
10558 ast_mutex_unlock(&iaxsl[fr->callno]);
10559 return 1;
10560 }
10561 }
10562
10563 /* count this frame */
10564 iaxs[fr->callno]->frames_received++;
10565
10566 if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) && !minivid &&
10567 f.subclass.integer != IAX_COMMAND_TXCNT && /* for attended transfer */
10568 f.subclass.integer != IAX_COMMAND_TXACC) { /* for attended transfer */
10569 unsigned short new_peercallno;
10570
10571 new_peercallno = (unsigned short) (ntohs(mh->callno) & ~IAX_FLAG_FULL);
10572 if (new_peercallno && new_peercallno != iaxs[fr->callno]->peercallno) {
10573 if (iaxs[fr->callno]->peercallno) {
10574 remove_by_peercallno(iaxs[fr->callno]);
10575 }
10576 iaxs[fr->callno]->peercallno = new_peercallno;
10577 store_by_peercallno(iaxs[fr->callno]);
10578 }
10579 }
10580 if (ntohs(mh->callno) & IAX_FLAG_FULL) {
10581 if (iaxdebug)
10582 ast_debug(1, "Received packet %d, (%u, %d)\n", fh->oseqno, f.frametype, f.subclass.integer);
10583 /* Check if it's out of order (and not an ACK or INVAL) */
10584 fr->oseqno = fh->oseqno;
10585 fr->iseqno = fh->iseqno;
10586 fr->ts = ntohl(fh->ts);
10587#ifdef IAXTESTS
10588 if (test_resync) {
10589 ast_debug(1, "Simulating frame ts resync, was %u now %u\n", fr->ts, fr->ts + test_resync);
10590 fr->ts += test_resync;
10591 }
10592#endif /* IAXTESTS */
10593#if 0
10594 if ( (ntohs(fh->dcallno) & IAX_FLAG_RETRANS) ||
10595 ( (f.frametype != AST_FRAME_VOICE) && ! (f.frametype == AST_FRAME_IAX &&
10596 (f.subclass == IAX_COMMAND_NEW ||
10597 f.subclass == IAX_COMMAND_AUTHREQ ||
10598 f.subclass == IAX_COMMAND_ACCEPT ||
10599 f.subclass == IAX_COMMAND_REJECT)) ) )
10600#endif
10601 if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) || (f.frametype != AST_FRAME_VOICE))
10602 updatehistory = 0;
10603 if ((iaxs[fr->callno]->iseqno != fr->oseqno) &&
10604 (iaxs[fr->callno]->iseqno ||
10605 ((f.subclass.integer != IAX_COMMAND_TXCNT) &&
10606 (f.subclass.integer != IAX_COMMAND_TXREADY) && /* for attended transfer */
10607 (f.subclass.integer != IAX_COMMAND_TXREL) && /* for attended transfer */
10608 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) && /* for attended transfer */
10609 (f.subclass.integer != IAX_COMMAND_TXACC)) ||
10610 (f.frametype != AST_FRAME_IAX))) {
10611 if (
10612 ((f.subclass.integer != IAX_COMMAND_ACK) &&
10613 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10614 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10615 (f.subclass.integer != IAX_COMMAND_TXREADY) && /* for attended transfer */
10616 (f.subclass.integer != IAX_COMMAND_TXREL) && /* for attended transfer */
10617 (f.subclass.integer != IAX_COMMAND_UNQUELCH ) && /* for attended transfer */
10618 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10619 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10620 (f.frametype != AST_FRAME_IAX)) {
10621 /* If it's not an ACK packet, it's out of order. */
10622 ast_debug(1, "Packet arrived out of order (expecting %d, got %d) (frametype = %u, subclass = %d)\n",
10623 iaxs[fr->callno]->iseqno, fr->oseqno, f.frametype, f.subclass.integer);
10624 /* Check to see if we need to request retransmission,
10625 * and take sequence number wraparound into account */
10626 if ((unsigned char) (iaxs[fr->callno]->iseqno - fr->oseqno) < 128) {
10627 /* If we've already seen it, ack it XXX There's a border condition here XXX */
10628 if ((f.frametype != AST_FRAME_IAX) ||
10629 ((f.subclass.integer != IAX_COMMAND_ACK) && (f.subclass.integer != IAX_COMMAND_INVAL))) {
10630 ast_debug(1, "Acking anyway\n");
10631 /* XXX Maybe we should handle its ack to us, but then again, it's probably outdated anyway, and if
10632 we have anything to send, we'll retransmit and get an ACK back anyway XXX */
10633 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10634 }
10635 } else {
10636 /* Send a VNAK requesting retransmission */
10637 iax2_vnak(fr->callno);
10638 }
10639 ast_variables_destroy(ies.vars);
10640 ast_mutex_unlock(&iaxsl[fr->callno]);
10641 return 1;
10642 }
10643 } else {
10644 /* Increment unless it's an ACK or VNAK */
10645 if (((f.subclass.integer != IAX_COMMAND_ACK) &&
10646 (f.subclass.integer != IAX_COMMAND_INVAL) &&
10647 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
10648 (f.subclass.integer != IAX_COMMAND_TXACC) &&
10649 (f.subclass.integer != IAX_COMMAND_VNAK)) ||
10650 (f.frametype != AST_FRAME_IAX))
10651 iaxs[fr->callno]->iseqno++;
10652 }
10653 /* Ensure text frames are NULL-terminated */
10654 if (f.frametype == AST_FRAME_TEXT && thread->buf[res - 1] != '\0') {
10655 if (res < thread->buf_size)
10656 thread->buf[res++] = '\0';
10657 else /* Trims one character from the text message, but that's better than overwriting the end of the buffer. */
10658 thread->buf[res - 1] = '\0';
10659 }
10660
10661 /* Handle implicit ACKing unless this is an INVAL, and only if this is
10662 from the real peer, not the transfer peer */
10663 if (!ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
10664 ((f.subclass.integer != IAX_COMMAND_INVAL) ||
10665 (f.frametype != AST_FRAME_IAX))) {
10666 unsigned char x;
10667 int call_to_destroy;
10668 /* First we have to qualify that the ACKed value is within our window */
10669 if (iaxs[fr->callno]->rseqno >= iaxs[fr->callno]->oseqno || (fr->iseqno >= iaxs[fr->callno]->rseqno && fr->iseqno < iaxs[fr->callno]->oseqno))
10670 x = fr->iseqno;
10671 else
10672 x = iaxs[fr->callno]->oseqno;
10673 if ((x != iaxs[fr->callno]->oseqno) || (iaxs[fr->callno]->oseqno == fr->iseqno)) {
10674 /* The acknowledgement is within our window. Time to acknowledge everything
10675 that it says to */
10676 for (x=iaxs[fr->callno]->rseqno; x != fr->iseqno; x++) {
10677 /* Ack the packet with the given timestamp */
10678 if (iaxdebug)
10679 ast_debug(1, "Cancelling transmission of packet %d\n", x);
10680 call_to_destroy = 0;
10681 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10682 /* If it's our call, and our timestamp, mark -1 retries */
10683 if (x == cur->oseqno) {
10684 cur->retries = -1;
10685 /* Destroy call if this is the end */
10686 if (cur->final)
10687 call_to_destroy = fr->callno;
10688 }
10689 }
10690 if (call_to_destroy) {
10691 if (iaxdebug)
10692 ast_debug(1, "Really destroying %d, having been acked on final message\n", call_to_destroy);
10693 ast_mutex_lock(&iaxsl[call_to_destroy]);
10694 iax2_destroy(call_to_destroy);
10695 ast_mutex_unlock(&iaxsl[call_to_destroy]);
10696 }
10697 }
10698 /* Note how much we've received acknowledgement for */
10699 if (iaxs[fr->callno])
10700 iaxs[fr->callno]->rseqno = fr->iseqno;
10701 else {
10702 /* Stop processing now */
10703 ast_variables_destroy(ies.vars);
10704 ast_mutex_unlock(&iaxsl[fr->callno]);
10705 return 1;
10706 }
10707 } else {
10708 ast_debug(1, "Received iseqno %d not within window %d->%d\n", fr->iseqno, iaxs[fr->callno]->rseqno, iaxs[fr->callno]->oseqno);
10709 }
10710 }
10711 if (ast_sockaddr_cmp(&addr, &iaxs[fr->callno]->addr) &&
10712 ((f.frametype != AST_FRAME_IAX) ||
10713 ((f.subclass.integer != IAX_COMMAND_TXACC) &&
10714 (f.subclass.integer != IAX_COMMAND_TXCNT)))) {
10715 /* Only messages we accept from a transfer host are TXACC and TXCNT */
10716 ast_variables_destroy(ies.vars);
10717 ast_mutex_unlock(&iaxsl[fr->callno]);
10718 return 1;
10719 }
10720
10721 /* when we receive the first full frame for a new incoming channel,
10722 it is safe to start the PBX on the channel because we have now
10723 completed a 3-way handshake with the peer */
10724 if ((f.frametype == AST_FRAME_VOICE) ||
10725 (f.frametype == AST_FRAME_VIDEO) ||
10726 (f.frametype == AST_FRAME_IAX)) {
10727 if (ast_test_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART)) {
10728 ast_clear_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
10729 if (!ast_iax2_new(fr->callno, AST_STATE_RING,
10730 iaxs[fr->callno]->chosenformat, &iaxs[fr->callno]->rprefs, NULL, NULL,
10731 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
10732 ast_variables_destroy(ies.vars);
10733 ast_mutex_unlock(&iaxsl[fr->callno]);
10734 return 1;
10735 }
10736 }
10737
10738 if (ies.vars) {
10739 struct ast_datastore *variablestore = NULL;
10740 struct ast_variable *var, *prev = NULL;
10741 AST_LIST_HEAD(, ast_var_t) *varlist;
10742
10743 iax2_lock_owner(fr->callno);
10744 if (!iaxs[fr->callno]) {
10745 ast_variables_destroy(ies.vars);
10746 ast_mutex_unlock(&iaxsl[fr->callno]);
10747 return 1;
10748 }
10749 if ((c = iaxs[fr->callno]->owner)) {
10750 varlist = ast_calloc(1, sizeof(*varlist));
10751 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
10752
10753 if (variablestore && varlist) {
10754 variablestore->data = varlist;
10755 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
10756 AST_LIST_HEAD_INIT(varlist);
10757 ast_debug(1, "I can haz IAX vars?\n");
10758 for (var = ies.vars; var; var = var->next) {
10759 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
10760 if (prev) {
10761 ast_free(prev);
10762 }
10763 prev = var;
10764 if (!newvar) {
10765 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
10766 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10767 } else {
10768 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
10769 }
10770 }
10771 if (prev) {
10772 ast_free(prev);
10773 }
10774 ies.vars = NULL;
10775 ast_channel_datastore_add(c, variablestore);
10776 } else {
10777 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
10778 if (variablestore) {
10779 ast_datastore_free(variablestore);
10780 }
10781 if (varlist) {
10782 ast_free(varlist);
10783 }
10784 }
10785 ast_channel_unlock(c);
10786 } else {
10787 /* No channel yet, so transfer the variables directly over to the pvt,
10788 * for later inheritance. */
10789 ast_debug(1, "No channel, so populating IAXVARs to the pvt, as an intermediate step.\n");
10790 for (var = ies.vars; var && var->next; var = var->next);
10791 if (var) {
10792 var->next = iaxs[fr->callno]->iaxvars;
10793 iaxs[fr->callno]->iaxvars = ies.vars;
10794 ies.vars = NULL;
10795 }
10796 }
10797 }
10798
10799 if (ies.vars) {
10800 ast_debug(1, "I have IAX variables, but they were not processed\n");
10801 }
10802 }
10803
10804 /* once we receive our first IAX Full Frame that is not CallToken related, send all
10805 * queued signaling frames that were being held. */
10806 if ((f.frametype == AST_FRAME_IAX) && (f.subclass.integer != IAX_COMMAND_CALLTOKEN) && iaxs[fr->callno]->hold_signaling) {
10807 send_signaling(iaxs[fr->callno]);
10808 }
10809
10810 if (f.frametype == AST_FRAME_VOICE) {
10811 if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->voiceformat) {
10812 iaxs[fr->callno]->voiceformat = ast_format_compatibility_format2bitfield(f.subclass.format);
10813 ast_debug(1, "Ooh, voice format changed to '%s'\n", ast_format_get_name(f.subclass.format));
10814 if (iaxs[fr->callno]->owner) {
10815 iax2_lock_owner(fr->callno);
10816 if (iaxs[fr->callno]) {
10817 if (iaxs[fr->callno]->owner) {
10818 struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
10819 if (native) {
10820 ast_format_cap_append(native, f.subclass.format, 0);
10821 ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
10822 if (ast_channel_readformat(iaxs[fr->callno]->owner)) {
10823 ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
10824 }
10825 ao2_ref(native, -1);
10826 }
10827 ast_channel_unlock(iaxs[fr->callno]->owner);
10828 }
10829 } else {
10830 ast_debug(1, "Neat, somebody took away the channel at a magical time but i found it!\n");
10831 /* Free remote variables (if any) */
10832 if (ies.vars) {
10833 ast_variables_destroy(ies.vars);
10834 ast_debug(1, "I can haz iaxvars, but they is no good. :-(\n");
10835 ies.vars = NULL;
10836 }
10837 ast_mutex_unlock(&iaxsl[fr->callno]);
10838 return 1;
10839 }
10840 }
10841 }
10842 }
10843 if (f.frametype == AST_FRAME_VIDEO) {
10844 if (ast_format_compatibility_format2bitfield(f.subclass.format) != iaxs[fr->callno]->videoformat) {
10845 ast_debug(1, "Ooh, video format changed to %s\n", ast_format_get_name(f.subclass.format));
10846 iaxs[fr->callno]->videoformat = ast_format_compatibility_format2bitfield(f.subclass.format);
10847 }
10848 }
10849 if (f.frametype == AST_FRAME_IAX) {
10850 AST_SCHED_DEL(sched, iaxs[fr->callno]->initid);
10851 /* Handle the IAX pseudo frame itself */
10852 if (iaxdebug)
10853 ast_debug(1, "IAX subclass %d received\n", f.subclass.integer);
10854
10855 /* Update last ts unless the frame's timestamp originated with us. */
10856 if (iaxs[fr->callno]->last < fr->ts &&
10857 f.subclass.integer != IAX_COMMAND_ACK &&
10858 f.subclass.integer != IAX_COMMAND_PONG &&
10859 f.subclass.integer != IAX_COMMAND_LAGRP) {
10860 iaxs[fr->callno]->last = fr->ts;
10861 if (iaxdebug)
10862 ast_debug(1, "For call=%d, set last=%u\n", fr->callno, fr->ts);
10863 }
10864 iaxs[fr->callno]->last_iax_message = f.subclass.integer;
10865 if (!iaxs[fr->callno]->first_iax_message) {
10866 iaxs[fr->callno]->first_iax_message = f.subclass.integer;
10867 }
10868 switch(f.subclass.integer) {
10869 case IAX_COMMAND_ACK:
10870 /* Do nothing */
10871 break;
10872 case IAX_COMMAND_QUELCH:
10873 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10874 ast_set_flag64(iaxs[fr->callno], IAX_QUELCH);
10875 if (ies.musiconhold) {
10876 const char *moh_suggest;
10877
10878 iax2_lock_owner(fr->callno);
10879 if (!iaxs[fr->callno] || !iaxs[fr->callno]->owner) {
10880 break;
10881 }
10882
10883 /*
10884 * We already hold the owner lock so we do not
10885 * need to check iaxs[fr->callno] after it returns.
10886 */
10887 moh_suggest = iaxs[fr->callno]->mohsuggest;
10888 iax2_queue_hold(fr->callno, moh_suggest);
10889 ast_channel_unlock(iaxs[fr->callno]->owner);
10890 }
10891 }
10892 break;
10893 case IAX_COMMAND_UNQUELCH:
10894 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10895 iax2_lock_owner(fr->callno);
10896 if (!iaxs[fr->callno]) {
10897 break;
10898 }
10899
10900 ast_clear_flag64(iaxs[fr->callno], IAX_QUELCH);
10901 if (!iaxs[fr->callno]->owner) {
10902 break;
10903 }
10904
10905 /*
10906 * We already hold the owner lock so we do not
10907 * need to check iaxs[fr->callno] after it returns.
10908 */
10909 iax2_queue_unhold(fr->callno);
10910 ast_channel_unlock(iaxs[fr->callno]->owner);
10911 }
10912 break;
10913 case IAX_COMMAND_TXACC:
10914 if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
10915 /* Ack the packet with the given timestamp */
10916 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
10917 /* Cancel any outstanding txcnt's */
10918 if (cur->transfer) {
10919 cur->retries = -1;
10920 }
10921 }
10922 memset(&ied1, 0, sizeof(ied1));
10923 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
10924 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
10925 iaxs[fr->callno]->transferring = TRANSFER_READY;
10926 }
10927 break;
10928 case IAX_COMMAND_NEW:
10929 /* Ignore if it's already up */
10930 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD))
10931 break;
10932 if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
10933 ast_mutex_unlock(&iaxsl[fr->callno]);
10934 check_provisioning(&addr, fd, ies.serviceident, ies.provver);
10935 ast_mutex_lock(&iaxsl[fr->callno]);
10936 if (!iaxs[fr->callno]) {
10937 break;
10938 }
10939 }
10940 /* If we're in trunk mode, do it now, and update the trunk number in our frame before continuing */
10941 if (ast_test_flag64(iaxs[fr->callno], IAX_TRUNK)) {
10942 int new_callno;
10943 if ((new_callno = make_trunk(fr->callno, 1)) != -1)
10944 fr->callno = new_callno;
10945 }
10946 /* For security, always ack immediately */
10947 if (delayreject)
10948 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
10949 if (check_access(fr->callno, &addr, &ies)) {
10950 /* They're not allowed on */
10951 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10952 if (authdebug) {
10953 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, who was trying to reach '%s@%s'\n",
10954 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10955 }
10956 break;
10957 }
10958 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_test_flag64(iaxs[fr->callno], IAX_FORCE_ENCRYPT)) {
10959 auth_fail(fr->callno, IAX_COMMAND_REJECT);
10960 ast_log(LOG_WARNING, "Rejected connect attempt. No secret present while force encrypt enabled.\n");
10961 break;
10962 }
10963 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
10964 const char *context, *exten, *cid_num;
10965
10966 context = ast_strdupa(iaxs[fr->callno]->context);
10967 exten = ast_strdupa(iaxs[fr->callno]->exten);
10968 cid_num = ast_strdupa(iaxs[fr->callno]->cid_num);
10969
10970 /* This might re-enter the IAX code and need the lock */
10971 ast_mutex_unlock(&iaxsl[fr->callno]);
10972 exists = ast_exists_extension(NULL, context, exten, 1, cid_num);
10973 ast_mutex_lock(&iaxsl[fr->callno]);
10974
10975 if (!iaxs[fr->callno]) {
10976 break;
10977 }
10978 } else
10979 exists = 0;
10980 /* Get OSP token if it does exist */
10981 save_osptoken(fr, &ies);
10982 if (ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) {
10983 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
10984 memset(&ied0, 0, sizeof(ied0));
10985 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
10986 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
10987 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
10988 if (!iaxs[fr->callno]) {
10989 break;
10990 }
10991 if (authdebug) {
10992 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
10993 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->exten, iaxs[fr->callno]->context);
10994 }
10995 } else {
10996 /* Select an appropriate format */
10997
10998 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
10999 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11000 using_prefs = "reqonly";
11001 } else {
11002 using_prefs = "disabled";
11003 }
11004 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
11005 memset(&pref, 0, sizeof(pref));
11006 strcpy(caller_pref_buf, "disabled");
11007 strcpy(host_pref_buf, "disabled");
11008 } else {
11009 struct ast_format *tmpfmt;
11010 using_prefs = "mine";
11011 /* If the information elements are in here... use them */
11012 if (ies.codec_prefs)
11013 iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
11014 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11015 /* If we are codec_first_choice we let the caller have the 1st shot at picking the codec.*/
11016 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11017 pref = iaxs[fr->callno]->rprefs;
11018 using_prefs = "caller";
11019 } else {
11020 pref = iaxs[fr->callno]->prefs;
11021 }
11022 } else
11023 pref = iaxs[fr->callno]->prefs;
11024
11025 format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
11026 iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
11027 iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
11028 }
11029 if (!format) {
11030 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP))
11031 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
11032 if (!format) {
11033 memset(&ied0, 0, sizeof(ied0));
11034 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11035 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11036 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11037 if (!iaxs[fr->callno]) {
11038 break;
11039 }
11040 if (authdebug) {
11041 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11042 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11043 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11044
11045 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11046 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11047 ast_sockaddr_stringify(&addr),
11048 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11049 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11050 } else {
11051 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11052 ast_sockaddr_stringify(&addr),
11053 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11054 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11055 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11056 }
11057 }
11058 } else {
11059 /* Pick one... */
11060 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11061 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
11062 format = 0;
11063 } else {
11064 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11065 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
11066 memset(&pref, 0, sizeof(pref));
11067 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11068 strcpy(caller_pref_buf,"disabled");
11069 strcpy(host_pref_buf,"disabled");
11070 } else {
11071 struct ast_format *tmpfmt;
11072 using_prefs = "mine";
11073 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11074 /* Do the opposite of what we tried above. */
11075 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11076 pref = iaxs[fr->callno]->prefs;
11077 } else {
11078 pref = iaxs[fr->callno]->rprefs;
11079 using_prefs = "caller";
11080 }
11081 format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11082 } else /* if no codec_prefs IE do it the old way */
11083 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11084 }
11085 }
11086
11087 if (!format) {
11088 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11089 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11090 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11091
11092 memset(&ied0, 0, sizeof(ied0));
11093 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11094 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11095 ast_log(LOG_ERROR, "No best format in '%s'???\n", iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
11096 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11097 if (!iaxs[fr->callno]) {
11098 break;
11099 }
11100 if (authdebug) {
11101 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11102 ast_sockaddr_stringify(&addr),
11103 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11104 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11105 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11106 }
11107 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11108 break;
11109 }
11110 }
11111 }
11112 if (format) {
11113 /* No authentication required, let them in */
11114 memset(&ied1, 0, sizeof(ied1));
11115 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
11116 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
11117 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
11118 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
11119 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11120 ast_verb(3, "Accepting UNAUTHENTICATED call from %s:\n"
11121 "%srequested format = %s,\n"
11122 "%srequested prefs = %s,\n"
11123 "%sactual format = %s,\n"
11124 "%shost prefs = %s,\n"
11125 "%spriority = %s\n",
11126 ast_sockaddr_stringify(&addr),
11127 VERBOSE_PREFIX_4,
11128 iax2_getformatname(iaxs[fr->callno]->peerformat),
11129 VERBOSE_PREFIX_4,
11130 caller_pref_buf,
11131 VERBOSE_PREFIX_4,
11132 iax2_getformatname(format),
11133 VERBOSE_PREFIX_4,
11134 host_pref_buf,
11135 VERBOSE_PREFIX_4,
11136 using_prefs);
11137
11138 iaxs[fr->callno]->chosenformat = format;
11139
11140 /* Since this is a new call, we should go ahead and set the callid for it. */
11141 iax_pvt_callid_new(fr->callno);
11142 ast_set_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
11143 } else {
11144 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11145 /* If this is a TBD call, we're ready but now what... */
11146 ast_verb(3, "Accepted unauthenticated TBD call from %s\n", ast_sockaddr_stringify(&addr));
11147 }
11148 }
11149 }
11150 break;
11151 }
11152 if (iaxs[fr->callno]->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA))
11153 merge_encryption(iaxs[fr->callno], ies.encmethods);
11154 else
11155 iaxs[fr->callno]->encmethods = 0;
11156 if (!authenticate_request(fr->callno) && iaxs[fr->callno])
11157 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED);
11158 break;
11159 case IAX_COMMAND_DPREQ:
11160 /* Request status in the dialplan */
11161 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD) &&
11162 !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED) && ies.called_number) {
11163 if (iaxcompat) {
11164 /* Spawn a thread for the lookup */
11165 spawn_dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num);
11166 } else {
11167 /* Just look it up */
11168 dp_lookup(fr->callno, iaxs[fr->callno]->context, ies.called_number, iaxs[fr->callno]->cid_num, 1);
11169 }
11170 }
11171 break;
11172 case IAX_COMMAND_HANGUP:
11173 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11174 ast_debug(1, "Immediately destroying %d, having received hangup\n", fr->callno);
11175 /* Set hangup cause according to remote and hangupsource */
11176 if (iaxs[fr->callno]->owner) {
11177 set_hangup_source_and_cause(fr->callno, ies.causecode);
11178 if (!iaxs[fr->callno]) {
11179 break;
11180 }
11181 }
11182
11183 /* Send ack immediately, before we destroy */
11184 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11185 iax2_destroy(fr->callno);
11186 break;
11187 case IAX_COMMAND_REJECT:
11188 /* Set hangup cause according to remote and hangup source */
11189 if (iaxs[fr->callno]->owner) {
11190 set_hangup_source_and_cause(fr->callno, ies.causecode);
11191 if (!iaxs[fr->callno]) {
11192 break;
11193 }
11194 }
11195
11196 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
11197 if (iaxs[fr->callno]->owner && authdebug)
11198 ast_log(LOG_WARNING, "Call rejected by %s: %s\n",
11199 ast_sockaddr_stringify(&addr),
11200 ies.cause ? ies.cause : "<Unknown>");
11201 ast_debug(1, "Immediately destroying %d, having received reject\n",
11202 fr->callno);
11203 }
11204 /* Send ack immediately, before we destroy */
11205 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK,
11206 fr->ts, NULL, 0, fr->iseqno);
11207 if (!ast_test_flag64(iaxs[fr->callno], IAX_PROVISION))
11208 iaxs[fr->callno]->error = EPERM;
11209 iax2_destroy(fr->callno);
11210 break;
11211 case IAX_COMMAND_TRANSFER:
11212 {
11213 iax2_lock_owner(fr->callno);
11214 if (!iaxs[fr->callno]) {
11215 /* Initiating call went away before we could transfer. */
11216 break;
11217 }
11218 if (iaxs[fr->callno]->owner) {
11219 struct ast_channel *owner = iaxs[fr->callno]->owner;
11220 char *context = ast_strdupa(iaxs[fr->callno]->context);
11221
11222 ast_channel_ref(owner);
11223 ast_channel_unlock(owner);
11224 ast_mutex_unlock(&iaxsl[fr->callno]);
11225
11226 if (ast_bridge_transfer_blind(1, owner, ies.called_number,
11227 context, NULL, NULL) != AST_BRIDGE_TRANSFER_SUCCESS) {
11228 ast_log(LOG_WARNING, "Blind transfer of '%s' to '%s@%s' failed\n",
11229 ast_channel_name(owner), ies.called_number,
11230 context);
11231 }
11232
11233 ast_channel_unref(owner);
11234 ast_mutex_lock(&iaxsl[fr->callno]);
11235 }
11236
11237 break;
11238 }
11239 case IAX_COMMAND_ACCEPT:
11240 /* Ignore if call is already up or needs authentication or is a TBD */
11241 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD | IAX_STATE_AUTHENTICATED))
11242 break;
11243 if (ast_test_flag64(iaxs[fr->callno], IAX_PROVISION)) {
11244 /* Send ack immediately, before we destroy */
11245 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11246 iax2_destroy(fr->callno);
11247 break;
11248 }
11249 if (ies.format) {
11250 iaxs[fr->callno]->peerformat = ies.format;
11251 } else {
11252 if (iaxs[fr->callno]->owner)
11253 iaxs[fr->callno]->peerformat = iax2_format_compatibility_cap2bitfield(ast_channel_nativeformats(iaxs[fr->callno]->owner));
11254 else
11255 iaxs[fr->callno]->peerformat = iaxs[fr->callno]->capability;
11256 }
11257 ast_verb(3, "Call accepted by %s (format %s)\n", ast_sockaddr_stringify(&addr),
11258 iax2_getformatname(iaxs[fr->callno]->peerformat));
11259 if (!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability)) {
11260 memset(&ied0, 0, sizeof(ied0));
11261 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11262 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11263 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11264 if (!iaxs[fr->callno]) {
11265 break;
11266 }
11267 if (authdebug) {
11268 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11269 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11270
11271 ast_log(LOG_NOTICE, "Rejected call to %s, format %s incompatible with our capability %s.\n",
11272 ast_sockaddr_stringify(&addr),
11273 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_buf),
11274 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11275 }
11276 } else {
11277 struct ast_format_cap *native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
11278
11279 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11280 iax2_lock_owner(fr->callno);
11281 if (iaxs[fr->callno] && iaxs[fr->callno]->owner && native) {
11282 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11283
11284 /* Switch us to use a compatible format */
11285 iax2_codec_pref_best_bitfield2cap(
11286 iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
11287 native);
11288 ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
11289 ast_verb(3, "Format for call is %s\n", ast_format_cap_get_names(ast_channel_nativeformats(iaxs[fr->callno]->owner), &cap_buf));
11290
11291 /* Setup read/write formats properly. */
11292 if (ast_channel_writeformat(iaxs[fr->callno]->owner))
11293 ast_set_write_format(iaxs[fr->callno]->owner, ast_channel_writeformat(iaxs[fr->callno]->owner));
11294 if (ast_channel_readformat(iaxs[fr->callno]->owner))
11295 ast_set_read_format(iaxs[fr->callno]->owner, ast_channel_readformat(iaxs[fr->callno]->owner));
11296 ast_channel_unlock(iaxs[fr->callno]->owner);
11297 }
11298
11299 ao2_cleanup(native);
11300 }
11301 if (iaxs[fr->callno]) {
11302 AST_LIST_LOCK(&dpcache);
11303 AST_LIST_TRAVERSE(&iaxs[fr->callno]->dpentries, dp, peer_list)
11304 if (!(dp->flags & CACHE_FLAG_TRANSMITTED))
11305 iax2_dprequest(dp, fr->callno);
11306 AST_LIST_UNLOCK(&dpcache);
11307 }
11308 break;
11309 case IAX_COMMAND_POKE:
11310 /* Send back a pong packet with the original timestamp */
11311 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, NULL, 0, -1);
11312 break;
11313 case IAX_COMMAND_PING:
11314 {
11315 struct iax_ie_data pingied;
11316 construct_rr(iaxs[fr->callno], &pingied);
11317 /* Send back a pong packet with the original timestamp */
11318 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_PONG, fr->ts, pingied.buf, pingied.pos, -1);
11319 }
11320 break;
11321 case IAX_COMMAND_PONG:
11322 /* Calculate ping time */
11323 iaxs[fr->callno]->pingtime = calc_timestamp(iaxs[fr->callno], 0, &f) - fr->ts;
11324 /* save RR info */
11325 save_rr(fr, &ies);
11326
11327 /* Good time to write jb stats for this call */
11328 log_jitterstats(fr->callno);
11329
11330 if (iaxs[fr->callno]->peerpoke) {
11331 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
11332 peer = iaxs[fr->callno]->peerpoke;
11333 if ((peer->lastms < 0) || (peer->historicms > peer->maxms)) {
11334 if (iaxs[fr->callno]->pingtime <= peer->maxms) {
11335 ast_log(LOG_NOTICE, "Peer '%s' is now REACHABLE! Time: %u\n", peer->name, iaxs[fr->callno]->pingtime);
11336 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
11337 blob = ast_json_pack("{s: s, s: I}",
11338 "peer_status", "Reachable",
11339 "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
11340 ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
11341 }
11342 } else if ((peer->historicms > 0) && (peer->historicms <= peer->maxms)) {
11343 if (iaxs[fr->callno]->pingtime > peer->maxms) {
11344 ast_log(LOG_NOTICE, "Peer '%s' is now TOO LAGGED (%u ms)!\n", peer->name, iaxs[fr->callno]->pingtime);
11345 ast_endpoint_set_state(peer->endpoint, AST_ENDPOINT_ONLINE);
11346 blob = ast_json_pack("{s: s, s: I}",
11347 "peer_status", "Lagged",
11348 "time", (ast_json_int_t)iaxs[fr->callno]->pingtime);
11349 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", peer->name); /* Activate notification */
11350 }
11351 }
11352 ast_endpoint_blob_publish(peer->endpoint, ast_endpoint_state_type(), blob);
11353 peer->lastms = iaxs[fr->callno]->pingtime;
11354 if (peer->smoothing && (peer->lastms > -1))
11355 peer->historicms = (iaxs[fr->callno]->pingtime + peer->historicms) / 2;
11356 else if (peer->smoothing && peer->lastms < 0)
11357 peer->historicms = (0 + peer->historicms) / 2;
11358 else
11359 peer->historicms = iaxs[fr->callno]->pingtime;
11360
11361 /* Remove scheduled iax2_poke_noanswer */
11362 if (peer->pokeexpire > -1) {
11363 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
11364 peer_unref(peer);
11365 peer->pokeexpire = -1;
11366 }
11367 }
11368 /* Schedule the next cycle */
11369 if ((peer->lastms < 0) || (peer->historicms > peer->maxms))
11370 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqnotok, iax2_poke_peer_s, peer_ref(peer));
11371 else
11372 peer->pokeexpire = iax2_sched_add(sched, peer->pokefreqok, iax2_poke_peer_s, peer_ref(peer));
11373 if (peer->pokeexpire == -1)
11374 peer_unref(peer);
11375 /* and finally send the ack */
11376 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11377 /* And wrap up the qualify call */
11378 iax2_destroy(fr->callno);
11379 peer->callno = 0;
11380 ast_debug(1, "Peer %s: got pong, lastms %d, historicms %d, maxms %d\n", peer->name, peer->lastms, peer->historicms, peer->maxms);
11381 }
11382 break;
11383 case IAX_COMMAND_LAGRQ:
11384 case IAX_COMMAND_LAGRP:
11385 f.src = "LAGRQ";
11386 f.mallocd = 0;
11387 f.offset = 0;
11388 f.samples = 0;
11389 iax_frame_wrap(fr, &f);
11390 if (f.subclass.integer == IAX_COMMAND_LAGRQ) {
11391 /* Received a LAGRQ - echo back a LAGRP */
11392 fr->af.subclass.integer = IAX_COMMAND_LAGRP;
11393 iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
11394 } else {
11395 /* Received LAGRP in response to our LAGRQ */
11396 unsigned int ts;
11397 /* This is a reply we've been given, actually measure the difference */
11398 ts = calc_timestamp(iaxs[fr->callno], 0, &fr->af);
11399 iaxs[fr->callno]->lag = ts - fr->ts;
11400 if (iaxdebug)
11401 ast_debug(1, "Peer %s lag measured as %dms\n",
11402 ast_sockaddr_stringify(&addr), iaxs[fr->callno]->lag);
11403 }
11404 break;
11405 case IAX_COMMAND_AUTHREQ:
11406 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
11407 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>");
11408 break;
11409 }
11410 if (authenticate_reply(iaxs[fr->callno], &iaxs[fr->callno]->addr, &ies, iaxs[fr->callno]->secret, iaxs[fr->callno]->outkey)) {
11411 struct ast_frame hangup_fr = { .frametype = AST_FRAME_CONTROL,
11412 .subclass.integer = AST_CONTROL_HANGUP,
11413 };
11414 ast_log(LOG_WARNING,
11415 "I don't know how to authenticate %s to %s\n",
11416 ies.username ? ies.username : "<unknown>", ast_sockaddr_stringify(&addr));
11417 iax2_queue_frame(fr->callno, &hangup_fr);
11418 }
11419 break;
11420 case IAX_COMMAND_AUTHREP:
11421 /* For security, always ack immediately */
11422 if (delayreject)
11423 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11424 /* Ignore once we've started */
11425 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED | IAX_STATE_TBD)) {
11426 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>");
11427 break;
11428 }
11429 if (authenticate_verify(iaxs[fr->callno], &ies)) {
11430 if (authdebug)
11431 ast_log(LOG_WARNING, "Host %s failed to authenticate as %s\n", ast_sockaddr_stringify(&addr),
11432 iaxs[fr->callno]->username);
11433 memset(&ied0, 0, sizeof(ied0));
11434 auth_fail(fr->callno, IAX_COMMAND_REJECT);
11435 break;
11436 }
11437 if (strcasecmp(iaxs[fr->callno]->exten, "TBD")) {
11438 /* This might re-enter the IAX code and need the lock */
11439 exists = ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num);
11440 } else
11441 exists = 0;
11442 if (strcmp(iaxs[fr->callno]->exten, "TBD") && !exists) {
11443 if (authdebug)
11444 ast_log(LOG_WARNING, "Rejected connect attempt from %s, request '%s@%s' does not exist\n",
11445 ast_sockaddr_stringify(&addr),
11446 iaxs[fr->callno]->exten,
11447 iaxs[fr->callno]->context);
11448 memset(&ied0, 0, sizeof(ied0));
11449 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11450 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11451 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11452 if (!iaxs[fr->callno]) {
11453 break;
11454 }
11455 } else {
11456 /* Select an appropriate format */
11457 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11458 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11459 using_prefs = "reqonly";
11460 } else {
11461 using_prefs = "disabled";
11462 }
11463 format = iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability;
11464 memset(&pref, 0, sizeof(pref));
11465 strcpy(caller_pref_buf, "disabled");
11466 strcpy(host_pref_buf, "disabled");
11467 } else {
11468 struct ast_format *tmpfmt;
11469 using_prefs = "mine";
11470 if (ies.codec_prefs)
11471 iax2_codec_pref_convert(&iaxs[fr->callno]->rprefs, ies.codec_prefs, 32, 0);
11472 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11473 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11474 pref = iaxs[fr->callno]->rprefs;
11475 using_prefs = "caller";
11476 } else {
11477 pref = iaxs[fr->callno]->prefs;
11478 }
11479 } else /* if no codec_prefs IE do it the old way */
11480 pref = iaxs[fr->callno]->prefs;
11481 format = iax2_codec_choose(&pref, iaxs[fr->callno]->capability & iaxs[fr->callno]->peercapability);
11482 iax2_codec_pref_string(&iaxs[fr->callno]->rprefs, caller_pref_buf, sizeof(caller_pref_buf) - 1);
11483 iax2_codec_pref_string(&iaxs[fr->callno]->prefs, host_pref_buf, sizeof(host_pref_buf) - 1);
11484 }
11485 if (!format) {
11486 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11487 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11488 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11489
11490 if(!ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11491 ast_debug(1, "We don't do requested format %s, falling back to peer capability '%s'\n",
11492 iax2_getformatname(iaxs[fr->callno]->peerformat),
11493 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf));
11494 format = iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability;
11495 }
11496 if (!format) {
11497 if (authdebug) {
11498 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11499 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11500 ast_sockaddr_stringify(&addr),
11501 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11502 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11503 } else {
11504 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11505 ast_sockaddr_stringify(&addr),
11506 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11507 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11508 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11509 }
11510 }
11511 memset(&ied0, 0, sizeof(ied0));
11512 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11513 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11514 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11515 if (!iaxs[fr->callno]) {
11516 break;
11517 }
11518 } else {
11519 /* Pick one... */
11520 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11521 if(!(iaxs[fr->callno]->peerformat & iaxs[fr->callno]->capability))
11522 format = 0;
11523 } else {
11524 if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
11525 using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
11526 memset(&pref, 0, sizeof(pref));
11527 format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)
11528 ? iaxs[fr->callno]->peerformat
11529 : iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11530 strcpy(caller_pref_buf,"disabled");
11531 strcpy(host_pref_buf,"disabled");
11532 } else {
11533 struct ast_format *tmpfmt;
11534 using_prefs = "mine";
11535 if (iax2_codec_pref_index(&iaxs[fr->callno]->rprefs, 0, &tmpfmt)) {
11536 /* Do the opposite of what we tried above. */
11537 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_USER_FIRST)) {
11538 pref = iaxs[fr->callno]->prefs;
11539 } else {
11540 pref = iaxs[fr->callno]->rprefs;
11541 using_prefs = "caller";
11542 }
11543 format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11544 } else /* if no codec_prefs IE do it the old way */
11545 format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
11546 }
11547 }
11548 if (!format) {
11549 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11550 struct ast_str *peer_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11551 struct ast_str *peer_form_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11552
11553 ast_log(LOG_ERROR, "No best format in %s???\n",
11554 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability, &cap_buf));
11555 if (authdebug) {
11556 if (ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)) {
11557 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested '%s' incompatible with our capability '%s'.\n",
11558 ast_sockaddr_stringify(&addr),
11559 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11560 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11561 } else {
11562 ast_log(LOG_WARNING, "Rejected connect attempt from %s, requested/capability '%s'/'%s' incompatible with our capability '%s'.\n",
11563 ast_sockaddr_stringify(&addr),
11564 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &peer_form_buf),
11565 iax2_getformatname_multiple(iaxs[fr->callno]->peercapability, &peer_buf),
11566 iax2_getformatname_multiple(iaxs[fr->callno]->capability, &cap_buf));
11567 }
11568 }
11569 memset(&ied0, 0, sizeof(ied0));
11570 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "Unable to negotiate codec");
11571 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL);
11572 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11573 if (!iaxs[fr->callno]) {
11574 break;
11575 }
11576 }
11577 }
11578 }
11579 if (format) {
11580 /* Authentication received */
11581 memset(&ied1, 0, sizeof(ied1));
11582 iax_ie_append_int(&ied1, IAX_IE_FORMAT, format);
11583 iax_ie_append_versioned_uint64(&ied1, IAX_IE_FORMAT2, 0, format);
11584 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied1.buf, ied1.pos, -1);
11585 if (strcmp(iaxs[fr->callno]->exten, "TBD")) {
11586 char authmethodnames[AUTH_METHOD_NAMES_BUFSIZE];
11587 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11588 ast_verb(3, "Accepting AUTHENTICATED call from %s:\n"
11589 "%srequested auth methods = (%s),\n"
11590 "%sactual auth method = %s,\n"
11591 "%sencrypted = %s,\n"
11592 "%srequested format = %s,\n"
11593 "%srequested prefs = %s,\n"
11594 "%sactual format = %s,\n"
11595 "%shost prefs = %s,\n"
11596 "%spriority = %s\n",
11597 ast_sockaddr_stringify(&addr),
11598 VERBOSE_PREFIX_4,
11599 auth_method_names(iaxs[fr->callno]->authmethods, authmethodnames),
11600 VERBOSE_PREFIX_4,
11601 auth_method_labels[iaxs[fr->callno]->eff_auth_method],
11602 VERBOSE_PREFIX_4,
11603 IAX_CALLENCRYPTED(iaxs[fr->callno]) ? "yes" : "no",
11604 VERBOSE_PREFIX_4,
11605 iax2_getformatname(iaxs[fr->callno]->peerformat),
11606 VERBOSE_PREFIX_4,
11607 caller_pref_buf,
11608 VERBOSE_PREFIX_4,
11609 iax2_getformatname(format),
11610 VERBOSE_PREFIX_4,
11611 host_pref_buf,
11612 VERBOSE_PREFIX_4,
11613 using_prefs);
11614
11615 /* Unlike unauthenticated calls, we don't need to store
11616 * the chosen format for channel creation.
11617 * However, this is helpful for __get_from_jb. */
11618 iaxs[fr->callno]->chosenformat = format;
11619
11620 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11621 c = ast_iax2_new(fr->callno, AST_STATE_RING, format,
11622 &iaxs[fr->callno]->rprefs, NULL, NULL, 1);
11623 if (!c) {
11624 iax2_destroy(fr->callno);
11625 } else if (ies.vars) {
11626 struct ast_datastore *variablestore;
11627 struct ast_variable *var, *prev = NULL;
11628 AST_LIST_HEAD(, ast_var_t) *varlist;
11629 varlist = ast_calloc(1, sizeof(*varlist));
11630 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11631 if (variablestore && varlist) {
11632 variablestore->data = varlist;
11633 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11634 AST_LIST_HEAD_INIT(varlist);
11635 ast_debug(1, "I can haz IAX vars? w00t\n");
11636 for (var = ies.vars; var; var = var->next) {
11637 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11638 if (prev)
11639 ast_free(prev);
11640 prev = var;
11641 if (!newvar) {
11642 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
11643 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11644 } else {
11645 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11646 }
11647 }
11648 if (prev)
11649 ast_free(prev);
11650 ies.vars = NULL;
11651 ast_channel_datastore_add(c, variablestore);
11652 } else {
11653 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11654 if (variablestore)
11655 ast_datastore_free(variablestore);
11656 if (varlist)
11657 ast_free(varlist);
11658 }
11659 }
11660 } else {
11661 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11662 /* If this is a TBD call, we're ready but now what... */
11663 ast_verb(3, "Accepted AUTHENTICATED TBD call from %s\n", ast_sockaddr_stringify(&addr));
11664 if (ast_test_flag64(iaxs[fr->callno], IAX_IMMEDIATE)) {
11665 goto immediatedial;
11666 }
11667 }
11668 }
11669 }
11670 break;
11671 case IAX_COMMAND_DIAL:
11672immediatedial:
11673 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD)) {
11674 ast_clear_flag(&iaxs[fr->callno]->state, IAX_STATE_TBD);
11675 ast_string_field_set(iaxs[fr->callno], exten, ies.called_number ? ies.called_number : "s");
11676 if (!ast_exists_extension(NULL, iaxs[fr->callno]->context, iaxs[fr->callno]->exten, 1, iaxs[fr->callno]->cid_num)) {
11677 if (authdebug)
11678 ast_log(LOG_WARNING, "Rejected dial attempt from %s, request '%s@%s' does not exist\n",
11679 ast_sockaddr_stringify(&addr),
11680 iaxs[fr->callno]->exten,
11681 iaxs[fr->callno]->context);
11682 memset(&ied0, 0, sizeof(ied0));
11683 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No such context/extension");
11684 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_NO_ROUTE_DESTINATION);
11685 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11686 if (!iaxs[fr->callno]) {
11687 break;
11688 }
11689 } else {
11690 struct ast_str *cap_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
11691 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11692 ast_verb(3, "Accepting DIAL from %s, formats = %s\n",
11693 ast_sockaddr_stringify(&addr),
11694 iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &cap_buf));
11695 ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
11696 send_command(iaxs[fr->callno], AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, 0, NULL, 0, -1);
11697 c = ast_iax2_new(fr->callno, AST_STATE_RING,
11698 iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
11699 NULL, NULL, 1);
11700 if (!c) {
11701 iax2_destroy(fr->callno);
11702 } else if (ies.vars) {
11703 struct ast_datastore *variablestore;
11704 struct ast_variable *var, *prev = NULL;
11705 AST_LIST_HEAD(, ast_var_t) *varlist;
11706 varlist = ast_calloc(1, sizeof(*varlist));
11707 variablestore = ast_datastore_alloc(&iax2_variable_datastore_info, NULL);
11708 ast_debug(1, "I can haz IAX vars? w00t\n");
11709 if (variablestore && varlist) {
11710 variablestore->data = varlist;
11711 variablestore->inheritance = DATASTORE_INHERIT_FOREVER;
11712 AST_LIST_HEAD_INIT(varlist);
11713 for (var = ies.vars; var; var = var->next) {
11714 struct ast_var_t *newvar = ast_var_assign(var->name, var->value);
11715 if (prev)
11716 ast_free(prev);
11717 prev = var;
11718 if (!newvar) {
11719 /* Don't abort list traversal, as this would leave ies.vars in an inconsistent state. */
11720 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11721 } else {
11722 AST_LIST_INSERT_TAIL(varlist, newvar, entries);
11723 }
11724 }
11725 if (prev)
11726 ast_free(prev);
11727 ies.vars = NULL;
11728 ast_channel_datastore_add(c, variablestore);
11729 } else {
11730 ast_log(LOG_ERROR, "Memory allocation error while processing IAX2 variables\n");
11731 if (variablestore)
11732 ast_datastore_free(variablestore);
11733 if (varlist)
11734 ast_free(varlist);
11735 }
11736 }
11737 }
11738 }
11739 break;
11740 case IAX_COMMAND_INVAL:
11741 iaxs[fr->callno]->error = ENOTCONN;
11742 ast_debug(1, "Immediately destroying %d, having received INVAL\n", fr->callno);
11743 iax2_destroy(fr->callno);
11744 ast_debug(1, "Destroying call %d\n", fr->callno);
11745 break;
11746 case IAX_COMMAND_VNAK:
11747 ast_debug(1, "Received VNAK: resending outstanding frames\n");
11748 /* Force retransmission */
11749 vnak_retransmit(fr->callno, fr->iseqno);
11750 break;
11751 case IAX_COMMAND_REGREQ:
11752 case IAX_COMMAND_REGREL:
11753 /* For security, always ack immediately */
11754 if (delayreject)
11755 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11756 if (register_verify(fr->callno, &addr, &ies)) {
11757 if (!iaxs[fr->callno]) {
11758 break;
11759 }
11760 /* Send delayed failure */
11761 auth_fail(fr->callno, IAX_COMMAND_REGREJ);
11762 break;
11763 }
11764 if (!iaxs[fr->callno]) {
11765 break;
11766 }
11767 if ((ast_strlen_zero(iaxs[fr->callno]->secret) && ast_strlen_zero(iaxs[fr->callno]->inkeys)) ||
11768 ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED)) {
11769
11770 if (f.subclass.integer == IAX_COMMAND_REGREL) {
11771 ast_sockaddr_setnull(&addr);
11772 }
11773 if (update_registry(&addr, fr->callno, ies.devicetype, fd, ies.refresh)) {
11774 ast_log(LOG_WARNING, "Registry error\n");
11775 }
11776 if (!iaxs[fr->callno]) {
11777 break;
11778 }
11779 if (ies.provverpres && ies.serviceident && !(ast_sockaddr_isnull(&addr))) {
11780 ast_mutex_unlock(&iaxsl[fr->callno]);
11781 check_provisioning(&addr, fd, ies.serviceident, ies.provver);
11782 ast_mutex_lock(&iaxsl[fr->callno]);
11783 }
11784 break;
11785 }
11786 registry_authrequest(fr->callno);
11787 break;
11788 case IAX_COMMAND_REGACK:
11789 if (iax2_ack_registry(&ies, &addr, fr->callno)) {
11790 ast_log(LOG_WARNING, "Registration failure\n");
11791 }
11792 /* Send ack immediately, before we destroy */
11793 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11794 iax2_destroy(fr->callno);
11795 break;
11796 case IAX_COMMAND_REGREJ:
11797 if (iaxs[fr->callno]->reg) {
11798 if (authdebug) {
11799 ast_log(LOG_NOTICE, "Registration of '%s' rejected: '%s' from: '%s'\n",
11800 iaxs[fr->callno]->reg->username, ies.cause ? ies.cause : "<unknown>",
11801 ast_sockaddr_stringify(&addr));
11802 }
11803 iax2_publish_registry(iaxs[fr->callno]->reg->username, ast_sockaddr_stringify(&addr), "Rejected", S_OR(ies.cause, "<unknown>"));
11804 iaxs[fr->callno]->reg->regstate = REG_STATE_REJECTED;
11805 }
11806 /* Send ack immediately, before we destroy */
11807 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11808 iax2_destroy(fr->callno);
11809 break;
11810 case IAX_COMMAND_REGAUTH:
11811 /* Authentication request */
11812 if (registry_rerequest(&ies, fr->callno, &addr)) {
11813 memset(&ied0, 0, sizeof(ied0));
11814 iax_ie_append_str(&ied0, IAX_IE_CAUSE, "No authority found");
11815 iax_ie_append_byte(&ied0, IAX_IE_CAUSECODE, AST_CAUSE_FACILITY_NOT_SUBSCRIBED);
11816 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11817 }
11818 break;
11819 case IAX_COMMAND_TXREJ:
11820 while (iaxs[fr->callno]
11821 && iaxs[fr->callno]->bridgecallno
11822 && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
11823 DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
11824 }
11825 if (!iaxs[fr->callno]) {
11826 break;
11827 }
11828
11829 iaxs[fr->callno]->transferring = TRANSFER_NONE;
11830 ast_verb(3, "Channel '%s' unable to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
11831 memset(&iaxs[fr->callno]->transfer, 0, sizeof(iaxs[fr->callno]->transfer));
11832
11833 if (!iaxs[fr->callno]->bridgecallno) {
11834 break;
11835 }
11836
11837 if (iaxs[iaxs[fr->callno]->bridgecallno]
11838 && iaxs[iaxs[fr->callno]->bridgecallno]->transferring) {
11839 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_NONE;
11840 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
11841 }
11842 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11843 break;
11844 case IAX_COMMAND_TXREADY:
11845 while (iaxs[fr->callno]
11846 && iaxs[fr->callno]->bridgecallno
11847 && ast_mutex_trylock(&iaxsl[iaxs[fr->callno]->bridgecallno])) {
11848 DEADLOCK_AVOIDANCE(&iaxsl[fr->callno]);
11849 }
11850 if (!iaxs[fr->callno]) {
11851 break;
11852 }
11853
11854 if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
11855 iaxs[fr->callno]->transferring = TRANSFER_READY;
11856 } else if (iaxs[fr->callno]->transferring == TRANSFER_MBEGIN) {
11857 iaxs[fr->callno]->transferring = TRANSFER_MREADY;
11858 } else {
11859 if (iaxs[fr->callno]->bridgecallno) {
11860 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11861 }
11862 break;
11863 }
11864 ast_verb(3, "Channel '%s' ready to transfer\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>");
11865
11866 if (!iaxs[fr->callno]->bridgecallno) {
11867 break;
11868 }
11869
11870 if (!iaxs[iaxs[fr->callno]->bridgecallno]
11871 || (iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_READY
11872 && iaxs[iaxs[fr->callno]->bridgecallno]->transferring != TRANSFER_MREADY)) {
11873 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11874 break;
11875 }
11876
11877 /* Both sides are ready */
11878
11879 /* XXX what isn't checked here is that both sides match transfer types. */
11880
11881 if (iaxs[fr->callno]->transferring == TRANSFER_MREADY) {
11882 ast_verb(3, "Attempting media bridge of %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
11883 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
11884
11885 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_MEDIA;
11886 iaxs[fr->callno]->transferring = TRANSFER_MEDIA;
11887
11888 memset(&ied0, 0, sizeof(ied0));
11889 memset(&ied1, 0, sizeof(ied1));
11890 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11891 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11892 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied0.buf, ied0.pos, -1);
11893 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXMEDIA, 0, ied1.buf, ied1.pos, -1);
11894 } else {
11895 ast_verb(3, "Releasing %s and %s\n", iaxs[fr->callno]->owner ? ast_channel_name(iaxs[fr->callno]->owner) : "<Unknown>",
11896 iaxs[iaxs[fr->callno]->bridgecallno]->owner ? ast_channel_name(iaxs[iaxs[fr->callno]->bridgecallno]->owner) : "<Unknown>");
11897
11898 iaxs[iaxs[fr->callno]->bridgecallno]->transferring = TRANSFER_RELEASED;
11899 iaxs[fr->callno]->transferring = TRANSFER_RELEASED;
11900 ast_set_flag64(iaxs[iaxs[fr->callno]->bridgecallno], IAX_ALREADYGONE);
11901 ast_set_flag64(iaxs[fr->callno], IAX_ALREADYGONE);
11902
11903 /* Stop doing lag & ping requests */
11904 stop_stuff(fr->callno);
11905 stop_stuff(iaxs[fr->callno]->bridgecallno);
11906
11907 memset(&ied0, 0, sizeof(ied0));
11908 memset(&ied1, 0, sizeof(ied1));
11909 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[iaxs[fr->callno]->bridgecallno]->peercallno);
11910 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->peercallno);
11911 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied0.buf, ied0.pos, -1);
11912 send_command(iaxs[iaxs[fr->callno]->bridgecallno], AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied1.buf, ied1.pos, -1);
11913 }
11914 ast_mutex_unlock(&iaxsl[iaxs[fr->callno]->bridgecallno]);
11915 break;
11916 case IAX_COMMAND_TXREQ:
11917 try_transfer(iaxs[fr->callno], &ies);
11918 break;
11919 case IAX_COMMAND_TXCNT:
11920 if (iaxs[fr->callno]->transferring)
11921 send_command_transfer(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, NULL, 0);
11922 break;
11923 case IAX_COMMAND_TXREL:
11924 /* Send ack immediately, rather than waiting until we've changed addresses */
11925 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
11926 complete_transfer(fr->callno, &ies);
11927 stop_stuff(fr->callno); /* for attended transfer to work with libiax */
11928 break;
11929 case IAX_COMMAND_TXMEDIA:
11930 if (iaxs[fr->callno]->transferring == TRANSFER_READY) {
11931 AST_LIST_TRAVERSE(&frame_queue[fr->callno], cur, list) {
11932 /* Cancel any outstanding frames and start anew */
11933 if (cur->transfer) {
11934 cur->retries = -1;
11935 }
11936 }
11937 /* Start sending our media to the transfer address, but otherwise leave the call as-is */
11938 iaxs[fr->callno]->transferring = TRANSFER_MEDIAPASS;
11939 }
11940 break;
11941 case IAX_COMMAND_RTKEY:
11942 if (!IAX_CALLENCRYPTED(iaxs[fr->callno])) {
11943 ast_log(LOG_WARNING,
11944 "we've been told to rotate our encryption key, "
11945 "but this isn't an encrypted call. bad things will happen.\n"
11946 );
11947 break;
11948 }
11949
11950 IAX_DEBUGDIGEST("Receiving", ies.challenge);
11951
11952 ast_aes_set_decrypt_key((unsigned char *) ies.challenge, &iaxs[fr->callno]->dcx);
11953 break;
11954 case IAX_COMMAND_DPREP:
11955 complete_dpreply(iaxs[fr->callno], &ies);
11956 break;
11957 case IAX_COMMAND_UNSUPPORT:
11958 ast_log(LOG_NOTICE, "Peer did not understand our iax command '%d'\n", ies.iax_unknown);
11959 break;
11960 case IAX_COMMAND_FWDOWNL:
11961 /* Firmware download */
11962 if (!ast_test_flag64(&globalflags, IAX_ALLOWFWDOWNLOAD)) {
11963 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, NULL, 0, -1);
11964 break;
11965 }
11966 memset(&ied0, 0, sizeof(ied0));
11967 res = iax_firmware_append(&ied0, ies.devicetype, ies.fwdesc);
11968 if (res < 0)
11969 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied0.buf, ied0.pos, -1);
11970 else if (res > 0)
11971 send_command_final(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11972 else
11973 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_FWDATA, 0, ied0.buf, ied0.pos, -1);
11974 break;
11975 case IAX_COMMAND_CALLTOKEN:
11976 {
11977 struct iax_frame *cur;
11978 /* find last sent frame */
11979 if ((cur = AST_LIST_LAST(&frame_queue[fr->callno])) && ies.calltoken && ies.calltokendata) {
11980 resend_with_token(fr->callno, cur, (char *) ies.calltokendata);
11981 }
11982 break;
11983 }
11984 default:
11985 ast_debug(1, "Unknown IAX command %d on %d/%d\n", f.subclass.integer, fr->callno, iaxs[fr->callno]->peercallno);
11986 memset(&ied0, 0, sizeof(ied0));
11987 iax_ie_append_byte(&ied0, IAX_IE_IAX_UNKNOWN, f.subclass.integer);
11988 send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_UNSUPPORT, 0, ied0.buf, ied0.pos, -1);
11989 }
11990 /* Free remote variables (if any) */
11991 if (ies.vars) {
11992 ast_variables_destroy(ies.vars);
11993 ast_debug(1, "I can haz IAX vars, but they is no good :-(\n");
11994 ies.vars = NULL;
11995 }
11996
11997 /* Don't actually pass these frames along */
11998 if ((f.subclass.integer != IAX_COMMAND_ACK) &&
11999 (f.subclass.integer != IAX_COMMAND_TXCNT) &&
12000 (f.subclass.integer != IAX_COMMAND_TXACC) &&
12001 (f.subclass.integer != IAX_COMMAND_INVAL) &&
12002 (f.subclass.integer != IAX_COMMAND_VNAK)) {
12003 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno) {
12004 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
12005 }
12006 }
12007 ast_mutex_unlock(&iaxsl[fr->callno]);
12008 return 1;
12009 }
12010 /* Unless this is an ACK or INVAL frame, ack it */
12011 if (iaxs[fr->callno] && iaxs[fr->callno]->aseqno != iaxs[fr->callno]->iseqno)
12012 send_command_immediate(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_ACK, fr->ts, NULL, 0,fr->iseqno);
12013 } else if (minivid) {
12014 f.frametype = AST_FRAME_VIDEO;
12015 if (iaxs[fr->callno]->videoformat > 0) {
12016 if (ntohs(vh->ts) & 0x8000LL) {
12017 f.subclass.frame_ending = 1;
12018 }
12019 f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->videoformat);
12020 if (!f.subclass.format) {
12021 ast_variables_destroy(ies.vars);
12022 ast_mutex_unlock(&iaxsl[fr->callno]);
12023 return 1;
12024 }
12025 } else {
12026 ast_log(LOG_WARNING, "Received mini frame before first full video frame\n");
12027 iax2_vnak(fr->callno);
12028 ast_variables_destroy(ies.vars);
12029 ast_mutex_unlock(&iaxsl[fr->callno]);
12030 return 1;
12031 }
12032 f.datalen = res - sizeof(*vh);
12033 if (f.datalen < 0) {
12034 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12035 ast_variables_destroy(ies.vars);
12036 ast_mutex_unlock(&iaxsl[fr->callno]);
12037 return 1;
12038 }
12039 if (f.datalen)
12040 f.data.ptr = thread->buf + sizeof(*vh);
12041 else
12042 f.data.ptr = NULL;
12043#ifdef IAXTESTS
12044 if (test_resync) {
12045 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
12046 } else
12047#endif /* IAXTESTS */
12048 fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | (ntohs(vh->ts) & 0x7fff);
12049 } else {
12050 /* A mini frame */
12051 f.frametype = AST_FRAME_VOICE;
12052 if (iaxs[fr->callno]->voiceformat > 0) {
12053 f.subclass.format = ast_format_compatibility_bitfield2format(iaxs[fr->callno]->voiceformat);
12054 if (!f.subclass.format) {
12055 ast_variables_destroy(ies.vars);
12056 ast_mutex_unlock(&iaxsl[fr->callno]);
12057 return 1;
12058 }
12059 } else {
12060 ast_debug(1, "Received mini frame before first full voice frame\n");
12061 iax2_vnak(fr->callno);
12062 ast_variables_destroy(ies.vars);
12063 ast_mutex_unlock(&iaxsl[fr->callno]);
12064 return 1;
12065 }
12066 f.datalen = res - sizeof(struct ast_iax2_mini_hdr);
12067 if (f.datalen < 0) {
12068 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12069 ast_variables_destroy(ies.vars);
12070 ast_mutex_unlock(&iaxsl[fr->callno]);
12071 return 1;
12072 }
12073 if (f.datalen)
12074 f.data.ptr = thread->buf + sizeof(*mh);
12075 else
12076 f.data.ptr = NULL;
12077#ifdef IAXTESTS
12078 if (test_resync) {
12079 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
12080 } else
12081#endif /* IAXTESTS */
12082 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
12083 /* FIXME? Surely right here would be the right place to undo timestamp wraparound? */
12084 }
12085
12086 /* Don't pass any packets until we're started */
12087 if (!iaxs[fr->callno]
12088 || !ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
12089 ast_variables_destroy(ies.vars);
12090 ast_mutex_unlock(&iaxsl[fr->callno]);
12091 return 1;
12092 }
12093
12094 if (f.frametype == AST_FRAME_CONTROL) {
12095 if (!iax2_is_control_frame_allowed(f.subclass.integer)) {
12096 /* Control frame not allowed to come from the wire. */
12097 ast_debug(2, "Callno %d: Blocked receiving control frame %d.\n",
12098 fr->callno, f.subclass.integer);
12099 ast_variables_destroy(ies.vars);
12100 ast_mutex_unlock(&iaxsl[fr->callno]);
12101 return 1;
12102 }
12103 if (f.subclass.integer == AST_CONTROL_CONNECTED_LINE
12104 || f.subclass.integer == AST_CONTROL_REDIRECTING) {
12105 if (iaxs[fr->callno]
12106 && !ast_test_flag64(iaxs[fr->callno], IAX_RECVCONNECTEDLINE)) {
12107 /* We are not configured to allow receiving these updates. */
12108 ast_debug(2, "Callno %d: Config blocked receiving control frame %d.\n",
12109 fr->callno, f.subclass.integer);
12110 ast_variables_destroy(ies.vars);
12111 ast_mutex_unlock(&iaxsl[fr->callno]);
12112 return 1;
12113 }
12114 }
12115
12116 iax2_lock_owner(fr->callno);
12117 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
12118 if (f.subclass.integer == AST_CONTROL_BUSY) {
12119 ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_BUSY);
12120 } else if (f.subclass.integer == AST_CONTROL_CONGESTION) {
12121 ast_channel_hangupcause_set(iaxs[fr->callno]->owner, AST_CAUSE_CONGESTION);
12122 }
12123 ast_channel_unlock(iaxs[fr->callno]->owner);
12124 }
12125 }
12126
12127 if (f.frametype == AST_FRAME_CONTROL
12128 && f.subclass.integer == AST_CONTROL_CONNECTED_LINE
12129 && iaxs[fr->callno]) {
12130 struct ast_party_connected_line connected;
12131
12132 /*
12133 * Process a received connected line update.
12134 *
12135 * Initialize defaults.
12136 */
12137 ast_party_connected_line_init(&connected);
12138 connected.id.number.presentation = iaxs[fr->callno]->calling_pres;
12139 connected.id.name.presentation = iaxs[fr->callno]->calling_pres;
12140
12141 if (!ast_connected_line_parse_data(f.data.ptr, f.datalen, &connected)) {
12142 ast_string_field_set(iaxs[fr->callno], cid_num, connected.id.number.str);
12143 ast_string_field_set(iaxs[fr->callno], cid_name, connected.id.name.str);
12144 iaxs[fr->callno]->calling_pres = ast_party_id_presentation(&connected.id);
12145
12146 iax2_lock_owner(fr->callno);
12147 if (iaxs[fr->callno] && iaxs[fr->callno]->owner) {
12148 ast_set_callerid(iaxs[fr->callno]->owner,
12149 S_COR(connected.id.number.valid, connected.id.number.str, ""),
12150 S_COR(connected.id.name.valid, connected.id.name.str, ""),
12151 NULL);
12152 ast_channel_caller(iaxs[fr->callno]->owner)->id.number.presentation = connected.id.number.presentation;
12153 ast_channel_caller(iaxs[fr->callno]->owner)->id.name.presentation = connected.id.name.presentation;
12154 ast_channel_unlock(iaxs[fr->callno]->owner);
12155 }
12156 }
12157 ast_party_connected_line_free(&connected);
12158 }
12159
12160 /* Common things */
12161 f.src = "IAX2";
12162 f.mallocd = 0;
12163 f.offset = 0;
12164 f.len = 0;
12165 if (f.datalen && (f.frametype == AST_FRAME_VOICE)) {
12166 f.samples = ast_codec_samples_count(&f);
12167 /* We need to byteswap incoming slinear samples from network byte order */
12168 if (ast_format_cmp(f.subclass.format, ast_format_slin) == AST_FORMAT_CMP_EQUAL)
12169 ast_frame_byteswap_be(&f);
12170 } else
12171 f.samples = 0;
12172
12173 if (f.datalen < 0) {
12174 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
12175 ast_variables_destroy(ies.vars);
12176 ast_mutex_unlock(&iaxsl[fr->callno]);
12177 return 1;
12178 }
12179
12180 iax_frame_wrap(fr, &f);
12181
12182 /* If this is our most recent packet, use it as our basis for timestamping */
12183 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
12184 /*iaxs[fr->callno]->last = fr->ts; (do it afterwards cos schedule/forward_delivery needs the last ts too)*/
12185 fr->outoforder = 0;
12186 } else {
12187 if (iaxdebug && iaxs[fr->callno]) {
12188 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);
12189 }
12190 fr->outoforder = 1;
12191 }
12192 fr->cacheable = ((f.frametype == AST_FRAME_VOICE) || (f.frametype == AST_FRAME_VIDEO));
12193 if (iaxs[fr->callno]) {
12194 duped_fr = iaxfrdup2(fr);
12195 if (duped_fr) {
12196 schedule_delivery(duped_fr, updatehistory, 0, &fr->ts);
12197 }
12198 }
12199 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts) {
12200 iaxs[fr->callno]->last = fr->ts;
12201#if 1
12202 if (iaxdebug)
12203 ast_debug(8, "For call=%d, set last=%u\n", fr->callno, fr->ts);
12204#endif
12205 }
12206
12207 /* Always run again */
12208 ast_variables_destroy(ies.vars);
12209 ast_mutex_unlock(&iaxsl[fr->callno]);
12210 return 1;
12211}

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, ast_iax2_mini_hdr::callno, ast_iax2_video_hdr::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, ast_channel::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(), 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, ast_iax2_mini_hdr::ts, ast_iax2_video_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(), chan_iax2_pvt::voiceformat, and ast_iax2_video_hdr::zeros.

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 10046 of file chan_iax2.c.

10048{
10049 unsigned char metatype;
10050 struct ast_iax2_meta_trunk_mini *mtm;
10051 struct ast_iax2_meta_trunk_hdr *mth;
10052 struct ast_iax2_meta_trunk_entry *mte;
10053 struct iax2_trunk_peer *tpeer;
10054 unsigned int ts;
10055 void *ptr;
10056 struct timeval rxtrunktime;
10057 struct ast_frame f = { 0, };
10058
10059 if (packet_len < sizeof(*meta)) {
10060 ast_log(LOG_WARNING, "Rejecting packet from '%s' that is flagged as a meta frame but is too short\n",
10061 ast_sockaddr_stringify(addr));
10062 return 1;
10063 }
10064
10065 if (meta->metacmd != IAX_META_TRUNK)
10066 return 1;
10067
10068 if (packet_len < (sizeof(*meta) + sizeof(*mth))) {
10069 ast_log(LOG_WARNING, "midget meta trunk packet received (%d of %d min)\n", packet_len,
10070 (int) (sizeof(*meta) + sizeof(*mth)));
10071 return 1;
10072 }
10073 mth = (struct ast_iax2_meta_trunk_hdr *)(meta->data);
10074 ts = ntohl(mth->ts);
10075 metatype = meta->cmddata;
10076 packet_len -= (sizeof(*meta) + sizeof(*mth));
10077 ptr = mth->data;
10078 tpeer = find_tpeer(addr, sockfd);
10079 if (!tpeer) {
10080 ast_log(LOG_WARNING, "Unable to accept trunked packet from '%s': No matching peer\n",
10081 ast_sockaddr_stringify(addr));
10082 return 1;
10083 }
10084 tpeer->trunkact = ast_tvnow();
10085 if (!ts || ast_tvzero(tpeer->rxtrunktime))
10086 tpeer->rxtrunktime = tpeer->trunkact;
10087 rxtrunktime = tpeer->rxtrunktime;
10088 ast_mutex_unlock(&tpeer->lock);
10089 while (packet_len >= sizeof(*mte)) {
10090 /* Process channels */
10091 unsigned short callno, trunked_ts, len;
10092
10093 if (metatype == IAX_META_TRUNK_MINI) {
10094 mtm = (struct ast_iax2_meta_trunk_mini *) ptr;
10095 ptr += sizeof(*mtm);
10096 packet_len -= sizeof(*mtm);
10097 len = ntohs(mtm->len);
10098 callno = ntohs(mtm->mini.callno);
10099 trunked_ts = ntohs(mtm->mini.ts);
10100 } else if (metatype == IAX_META_TRUNK_SUPERMINI) {
10101 mte = (struct ast_iax2_meta_trunk_entry *)ptr;
10102 ptr += sizeof(*mte);
10103 packet_len -= sizeof(*mte);
10104 len = ntohs(mte->len);
10105 callno = ntohs(mte->callno);
10106 trunked_ts = 0;
10107 } else {
10108 ast_log(LOG_WARNING, "Unknown meta trunk cmd from '%s': dropping\n", ast_sockaddr_stringify(addr));
10109 break;
10110 }
10111 /* Stop if we don't have enough data */
10112 if (len > packet_len)
10113 break;
10114 fr->callno = find_callno_locked(callno & ~IAX_FLAG_FULL, 0, addr, NEW_PREVENT, sockfd, 0);
10115 if (!fr->callno)
10116 continue;
10117
10118 /* If it's a valid call, deliver the contents. If not, we
10119 drop it, since we don't have a scallno to use for an INVAL */
10120 /* Process as a mini frame */
10121 memset(&f, 0, sizeof(f));
10122 f.frametype = AST_FRAME_VOICE;
10123 if (!iaxs[fr->callno]) {
10124 /* drop it */
10125 } else if (iaxs[fr->callno]->voiceformat == 0) {
10126 ast_log(LOG_WARNING, "Received trunked frame before first full voice frame\n");
10127 iax2_vnak(fr->callno);
10128 } else if ((f.subclass.format = ast_format_compatibility_bitfield2format(
10129 iaxs[fr->callno]->voiceformat))) {
10130 f.datalen = len;
10131 if (f.datalen >= 0) {
10132 if (f.datalen)
10133 f.data.ptr = ptr;
10134 else
10135 f.data.ptr = NULL;
10136 if (trunked_ts)
10137 fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
10138 else
10139 fr->ts = fix_peerts(&rxtrunktime, fr->callno, ts);
10140 /* Don't pass any packets until we're started */
10141 if (ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED)) {
10142 struct iax_frame *duped_fr;
10143
10144 /* Common things */
10145 f.src = "IAX2";
10146 f.mallocd = 0;
10147 f.offset = 0;
10148 if (f.datalen && (f.frametype == AST_FRAME_VOICE))
10149 f.samples = ast_codec_samples_count(&f);
10150 else
10151 f.samples = 0;
10152 fr->outoforder = 0;
10153 iax_frame_wrap(fr, &f);
10154 duped_fr = iaxfrdup2(fr);
10155 if (duped_fr)
10156 schedule_delivery(duped_fr, 1, 1, &fr->ts);
10157 if (iaxs[fr->callno] && iaxs[fr->callno]->last < fr->ts)
10158 iaxs[fr->callno]->last = fr->ts;
10159 }
10160 } else {
10161 ast_log(LOG_ERROR, "Dropping malformed frame (datalen %d?)\n", f.datalen);
10162 }
10163 }
10164 ast_mutex_unlock(&iaxsl[fr->callno]);
10165 ptr += len;
10166 packet_len -= len;
10167 }
10168
10169 return 1;
10170}

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_ERROR, LOG_WARNING, ast_frame::mallocd, 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 9968 of file chan_iax2.c.

9969{
9970 struct iax2_thread *thread;
9971 time_t t;
9972 static time_t last_errtime = 0;
9973 struct ast_iax2_full_hdr *fh;
9974
9975 if (!(thread = find_idle_thread())) {
9976 time(&t);
9977 if (t != last_errtime) {
9978 last_errtime = t;
9979 ast_debug(1, "Out of idle IAX2 threads for I/O, pausing!\n");
9980 }
9981 usleep(1);
9982 return 1;
9983 }
9984
9985 thread->iofd = fd;
9986 thread->buf_len = ast_recvfrom(fd, thread->readbuf, sizeof(thread->readbuf), 0, &thread->ioaddr);
9987 thread->buf_size = sizeof(thread->readbuf);
9988 thread->buf = thread->readbuf;
9989 if (thread->buf_len < 0) {
9990 if (errno != ECONNREFUSED && errno != EAGAIN)
9991 ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
9992 handle_error();
9993 thread->iostate = IAX_IOSTATE_IDLE;
9994 signal_condition(&thread->lock, &thread->cond);
9995 return 1;
9996 }
9997 if (test_losspct && ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_losspct)) { /* simulate random loss condition */
9998 thread->iostate = IAX_IOSTATE_IDLE;
9999 signal_condition(&thread->lock, &thread->cond);
10000 return 1;
10001 }
10002
10003 /* Determine if this frame is a full frame; if so, and any thread is currently
10004 processing a full frame for the same callno from this peer, then drop this
10005 frame (and the peer will retransmit it) */
10006 fh = (struct ast_iax2_full_hdr *) thread->buf;
10007 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
10008 struct iax2_thread *cur = NULL;
10009 uint16_t callno = ntohs(fh->scallno) & ~IAX_FLAG_FULL;
10010
10011 AST_LIST_LOCK(&active_list);
10012 AST_LIST_TRAVERSE(&active_list, cur, list) {
10013 if ((cur->ffinfo.callno == callno) &&
10014 !ast_sockaddr_cmp_addr(&cur->ffinfo.addr, &thread->ioaddr))
10015 break;
10016 }
10017 if (cur) {
10018 /* we found another thread processing a full frame for this call,
10019 so queue it up for processing later. */
10020 defer_full_frame(thread, cur);
10021 AST_LIST_UNLOCK(&active_list);
10022 thread->iostate = IAX_IOSTATE_IDLE;
10023 signal_condition(&thread->lock, &thread->cond);
10024 return 1;
10025 } else {
10026 /* this thread is going to process this frame, so mark it */
10027 thread->ffinfo.callno = callno;
10028 ast_sockaddr_copy(&thread->ffinfo.addr, &thread->ioaddr);
10029 thread->ffinfo.type = fh->type;
10030 thread->ffinfo.csub = fh->csub;
10031 AST_LIST_INSERT_HEAD(&active_list, thread, list);
10032 }
10033 AST_LIST_UNLOCK(&active_list);
10034 }
10035
10036 /* Mark as ready and send on its way */
10037 thread->iostate = IAX_IOSTATE_READY;
10038#ifdef DEBUG_SCHED_MULTITHREAD
10039 ast_copy_string(thread->curfunc, "socket_process", sizeof(thread->curfunc));
10040#endif
10041 signal_condition(&thread->lock, &thread->cond);
10042
10043 return 1;
10044}

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, 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 9776 of file chan_iax2.c.

9777{
9778 pthread_t newthread;
9779 struct dpreq_data *dpr;
9780
9781 if (!(dpr = ast_calloc(1, sizeof(*dpr))))
9782 return;
9783
9784 dpr->callno = callno;
9785 ast_copy_string(dpr->context, context, sizeof(dpr->context));
9786 ast_copy_string(dpr->callednum, callednum, sizeof(dpr->callednum));
9787 if (callerid)
9788 dpr->callerid = ast_strdup(callerid);
9789 if (ast_pthread_create_detached(&newthread, NULL, dp_lookup_thread, dpr)) {
9790 ast_log(LOG_WARNING, "Unable to start lookup thread!\n");
9791 }
9792}

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, 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 12845 of file chan_iax2.c.

12846{
12847 struct iax2_thread *thread;
12848 int threadcount = 0;
12849 int x;
12850 for (x = 0; x < iaxthreadcount; x++) {
12851 thread = ast_calloc(1, sizeof(*thread));
12852 if (thread) {
12853 thread->type = IAX_THREAD_TYPE_POOL;
12854 thread->threadnum = ++threadcount;
12855 ast_mutex_init(&thread->lock);
12856 ast_cond_init(&thread->cond, NULL);
12857 ast_mutex_init(&thread->init_lock);
12858 ast_cond_init(&thread->init_cond, NULL);
12859
12860 ast_mutex_lock(&thread->init_lock);
12861
12862 if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
12863 ast_log(LOG_WARNING, "Failed to create new thread!\n");
12864 ast_mutex_destroy(&thread->lock);
12865 ast_cond_destroy(&thread->cond);
12866 ast_mutex_unlock(&thread->init_lock);
12867 ast_mutex_destroy(&thread->init_lock);
12868 ast_cond_destroy(&thread->init_cond);
12869 ast_free(thread);
12870 thread = NULL;
12871 continue;
12872 }
12873 /* Wait for the thread to be ready */
12874 ast_cond_wait(&thread->init_cond, &thread->init_lock);
12875
12876 /* Done with init_lock */
12877 ast_mutex_unlock(&thread->init_lock);
12878
12879 AST_LIST_LOCK(&idle_list);
12880 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
12881 AST_LIST_UNLOCK(&idle_list);
12882 }
12883 }
12884 if (ast_pthread_create_background(&netthreadid, NULL, network_thread, NULL)) {
12885 ast_log(LOG_ERROR, "Failed to create new thread!\n");
12886 return -1;
12887 }
12888 ast_verb(2, "%d helper threads started\n", threadcount);
12889 return 0;
12890}

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 9472 of file chan_iax2.c.

9473{
9474 iax2_destroy_helper(iaxs[callno]);
9475}

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 2504 of file chan_iax2.c.

2505{
2506 if (!pvt->peercallno) {
2507 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2508 return;
2509 }
2510
2511 ao2_link(iax_peercallno_pvts, pvt);
2512}

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 2485 of file chan_iax2.c.

2486{
2487 if (!pvt->transfercallno) {
2488 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2489 return;
2490 }
2491
2492 ao2_link(iax_transfercallno_pvts, pvt);
2493}

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 9655 of file chan_iax2.c.

9656{
9657 int res, processed = 0, totalcalls = 0;
9658 struct iax2_trunk_peer *tpeer = NULL, *drop = NULL;
9659 struct timeval now = ast_tvnow();
9660
9661 if (iaxtrunkdebug) {
9662 ast_verbose("Beginning trunk processing. Trunk queue ceiling is %d bytes per host\n", trunkmaxsize);
9663 }
9664
9665 if (timer) {
9666 if (ast_timer_ack(timer, 1) < 0) {
9667 ast_log(LOG_ERROR, "Timer failed acknowledge\n");
9668 return 0;
9669 }
9670 }
9671
9672 /* For each peer that supports trunking... */
9673 AST_LIST_LOCK(&tpeers);
9674 AST_LIST_TRAVERSE_SAFE_BEGIN(&tpeers, tpeer, list) {
9675 processed++;
9676 res = 0;
9677 ast_mutex_lock(&tpeer->lock);
9678 /* We can drop a single tpeer per pass. That makes all this logic
9679 substantially easier */
9680 if (!drop && iax2_trunk_expired(tpeer, &now)) {
9681 /* Take it out of the list, but don't free it yet, because it
9682 could be in use */
9683 AST_LIST_REMOVE_CURRENT(list);
9684 drop = tpeer;
9685 } else {
9686 res = send_trunk(tpeer, &now);
9687 trunk_timed++;
9688 if (iaxtrunkdebug) {
9689 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",
9690 ast_sockaddr_stringify(&tpeer->addr),
9691 res,
9692 (res != 1) ? "s" : "",
9693 tpeer->trunkdatalen,
9694 tpeer->trunkdataalloc);
9695 }
9696 }
9697 totalcalls += res;
9698 res = 0;
9699 ast_mutex_unlock(&tpeer->lock);
9700 }
9701 AST_LIST_TRAVERSE_SAFE_END;
9702 AST_LIST_UNLOCK(&tpeers);
9703
9704 if (drop) {
9705 ast_mutex_lock(&drop->lock);
9706 /* Once we have this lock, we're sure nobody else is using it or could use it once we release it,
9707 because by the time they could get tpeerlock, we've already grabbed it */
9708 ast_debug(1, "Dropping unused iax2 trunk peer '%s'\n", ast_sockaddr_stringify(&drop->addr));
9709 if (drop->trunkdata) {
9710 ast_free(drop->trunkdata);
9711 drop->trunkdata = NULL;
9712 }
9713 ast_mutex_unlock(&drop->lock);
9714 ast_mutex_destroy(&drop->lock);
9715 ast_free(drop);
9716 }
9717
9718 if (iaxtrunkdebug) {
9719 ast_verbose("Ending trunk processing with %d peers and %d call chunks processed\n", processed, totalcalls);
9720 }
9721 iaxtrunkdebug = 0;
9722
9723 return 1;
9724}

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 14888 of file chan_iax2.c.

14889{
14890 struct chan_iax2_pvt *pvt = obj, *pvt2 = arg;
14891
14892 /* The frames_received field is used to hold whether we're matching
14893 * against a full frame or not ... */
14894
14895 return match(&pvt2->transfer, pvt2->transfercallno, pvt2->callno, pvt,
14896 pvt2->frames_received) ? CMP_MATCH | CMP_STOP : 0;
14897}

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 14881 of file chan_iax2.c.

14882{
14883 const struct chan_iax2_pvt *pvt = obj;
14884
14885 return pvt->transfercallno;
14886}

References chan_iax2_pvt::transfercallno.

Referenced by load_objects().

◆ transmit_frame()

static int transmit_frame ( void *  data)
static

Definition at line 4393 of file chan_iax2.c.

4394{
4395 struct iax_frame *fr = data;
4396
4397 ast_mutex_lock(&iaxsl[fr->callno]);
4398
4399 fr->sentyet = 1;
4400
4401 if (iaxs[fr->callno]) {
4402 send_packet(fr);
4403 }
4404
4405 if (fr->retries < 0) {
4406 ast_mutex_unlock(&iaxsl[fr->callno]);
4407 /* No retransmit requested */
4408 iax_frame_free(fr);
4409 } else {
4410 /* We need reliable delivery. Schedule a retransmission */
4411 AST_LIST_INSERT_TAIL(&frame_queue[fr->callno], fr, list);
4412 fr->retries++;
4413 fr->retrans = iax2_sched_add(sched, fr->retrytime, attempt_transmit, fr);
4414 ast_mutex_unlock(&iaxsl[fr->callno]);
4415 }
4416
4417 return 0;
4418}

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 3475 of file chan_iax2.c.

3476{
3477 int res;
3478 res = ast_sendto(sockfd, f->data, f->datalen, 0, addr);
3479
3480 if (res < 0) {
3481 ast_debug(1, "Received error: %s\n", strerror(errno));
3482 handle_error();
3483 } else
3484 res = 0;
3485 return res;
3486}

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 8763 of file chan_iax2.c.

8764{
8765 int newcall = 0;
8766 struct iax_ie_data ied;
8767 struct ast_sockaddr new = { {0,} };
8768
8769 memset(&ied, 0, sizeof(ied));
8770 if (!ast_sockaddr_isnull(&ies->apparent_addr)) {
8771 ast_sockaddr_copy(&new, &ies->apparent_addr);
8772 }
8773 if (ies->callno) {
8774 newcall = ies->callno;
8775 }
8776 if (!newcall || ast_sockaddr_isnull(&new)) {
8777 ast_log(LOG_WARNING, "Invalid transfer request\n");
8778 return -1;
8779 }
8780 pvt->transfercallno = newcall;
8781 ast_sockaddr_copy(&pvt->transfer, &new);
8782 pvt->transferid = ies->transferid;
8783 /* only store by transfercallno if this is a new transfer,
8784 * just in case we get a duplicate TXREQ */
8785 if (pvt->transferring == TRANSFER_NONE) {
8786 store_by_transfercallno(pvt);
8787 }
8788 pvt->transferring = TRANSFER_BEGIN;
8789
8790 if (ies->transferid) {
8791 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, ies->transferid);
8792 }
8793 send_command_transfer(pvt, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos);
8794 return 0;
8795}

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 1919 of file chan_iax2.c.

1920{
1921 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1922 if (csub & IAX_FLAG_SC_LOG) {
1923 /* special case for 'compressed' -1 */
1924 if (csub == 0xff)
1925 return -1;
1926 else
1927 return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1928 }
1929 else
1930 return csub;
1931}

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 9074 of file chan_iax2.c.

9075{
9076 if (peer->expire > -1) {
9077 if (!AST_SCHED_DEL(sched, peer->expire)) {
9078 peer->expire = -1;
9079 peer_unref(peer);
9080 }
9081 }
9082
9083 if (peer->pokeexpire > -1) {
9084 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
9085 peer->pokeexpire = -1;
9086 peer_unref(peer);
9087 }
9088 }
9089
9090 ao2_unlink(peers, peer);
9091}

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 14846 of file chan_iax2.c.

14847{
14848 ast_custom_function_unregister(&iaxpeer_function);
14849 ast_custom_function_unregister(&iaxvar_function);
14850 return __unload_module();
14851}

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 4159 of file chan_iax2.c.

4160{
4161 /* Video mini frames only encode the lower 15 bits of the session
4162 * timestamp, but other frame types (e.g. audio) encode 16 bits. */
4163 const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
4164 const int lower_mask = (1 << ts_shift) - 1;
4165 const int upper_mask = ~lower_mask;
4166 const int last_upper = iaxs[fr->callno]->last & upper_mask;
4167
4168 if ( (fr->ts & upper_mask) == last_upper ) {
4169 const int x = fr->ts - iaxs[fr->callno]->last;
4170 const int threshold = (ts_shift == 15) ? 25000 : 50000;
4171
4172 if (x < -threshold) {
4173 /* Sudden big jump backwards in timestamp:
4174 What likely happened here is that miniframe timestamp has circled but we haven't
4175 gotten the update from the main packet. We'll just pretend that we did, and
4176 update the timestamp appropriately. */
4177 fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
4178 if (iaxdebug)
4179 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
4180 } else if (x > threshold) {
4181 /* Sudden apparent big jump forwards in timestamp:
4182 What's likely happened is this is an old miniframe belonging to the previous
4183 top 15 or 16-bit timestamp that has turned up out of order.
4184 Adjust the timestamp appropriately. */
4185 fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
4186 if (iaxdebug)
4187 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
4188 }
4189 }
4190}

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 4194 of file chan_iax2.c.

4195{
4196 int when;
4197
4198 when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
4199
4200 when = jb_next(pvt->jb) - when;
4201
4202 if (when <= 0) {
4203 /* XXX should really just empty until when > 0.. */
4204 when = 1;
4205 }
4206
4207 pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb,
4208 CALLNO_TO_PTR(pvt->callno));
4209}

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 3607 of file chan_iax2.c.

3608{
3609 /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
3610 struct ast_iax2_full_hdr *fh = f->data;
3611 struct ast_frame af;
3612
3613 /* if frame is encrypted. decrypt before updating it. */
3614 if (f->encmethods) {
3615 decode_frame(&f->mydcx, fh, &af, &f->datalen);
3616 }
3617 /* Mark this as a retransmission */
3618 fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
3619 /* Update iseqno */
3620 f->iseqno = iaxs[f->callno]->iseqno;
3621 fh->iseqno = f->iseqno;
3622
3623 /* Now re-encrypt the frame */
3624 if (f->encmethods) {
3625 /* since this is a retransmit frame, create a new random padding
3626 * before re-encrypting. */
3627 build_rand_pad(f->semirand, sizeof(f->semirand));
3628 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
3629 }
3630 return 0;
3631}

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 9197 of file chan_iax2.c.

9198{
9199
9200 /* Called from IAX thread only, with proper iaxsl lock */
9201 struct iax_ie_data ied = {
9202 .pos = 0,
9203 };
9204 struct iax2_peer *p;
9205 int msgcount;
9206 char data[80];
9207 uint16_t version;
9208 const char *peer_name;
9209 int res = -1;
9210 char *str_addr;
9211
9212 peer_name = ast_strdupa(iaxs[callno]->peer);
9213
9214 /* SLD: Another find_peer call during registration - this time when we are really updating our registration */
9215 ast_mutex_unlock(&iaxsl[callno]);
9216 if (!(p = find_peer(peer_name, 1))) {
9217 ast_mutex_lock(&iaxsl[callno]);
9218 ast_log(LOG_WARNING, "No such peer '%s'\n", peer_name);
9219 return -1;
9220 }
9221 ast_mutex_lock(&iaxsl[callno]);
9222 if (!iaxs[callno])
9223 goto return_unref;
9224
9225 if (ast_test_flag64((&globalflags), IAX_RTUPDATE) && (ast_test_flag64(p, IAX_TEMPONLY|IAX_RTCACHEFRIENDS))) {
9226 if (!ast_sockaddr_isnull(addr)) {
9227 time_t nowtime;
9228 time(&nowtime);
9229 realtime_update_peer(peer_name, addr, nowtime);
9230 } else {
9231 realtime_update_peer(peer_name, addr, 0);
9232 }
9233 }
9234
9235 /* treat an unspecified refresh interval as the minimum */
9236 if (!refresh) {
9237 refresh = min_reg_expire;
9238 }
9239 if (refresh > max_reg_expire) {
9240 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
9241 p->name, max_reg_expire, refresh);
9242 p->expiry = max_reg_expire;
9243 } else if (refresh < min_reg_expire) {
9244 ast_log(LOG_NOTICE, "Restricting registration for peer '%s' to %d seconds (requested %d)\n",
9245 p->name, min_reg_expire, refresh);
9246 p->expiry = min_reg_expire;
9247 } else {
9248 p->expiry = refresh;
9249 }
9250
9251 if (ast_sockaddr_cmp(&p->addr, addr)) {
9252 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
9253
9254 if (iax2_regfunk) {
9255 iax2_regfunk(p->name, 1);
9256 }
9257
9258 /* modify entry in peercnts table as _not_ registered */
9259 peercnt_modify((unsigned char) 0, 0, &p->addr);
9260
9261 /* Stash the IP address from which they registered */
9262 ast_sockaddr_copy(&p->addr, addr);
9263
9264 str_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
9265
9266 snprintf(data, sizeof(data), "%s:%d", ast_sockaddr_stringify(addr), p->expiry);
9267
9268 if (!ast_test_flag64(p, IAX_TEMPONLY) && !ast_sockaddr_isnull(addr)) {
9269 ast_db_put("IAX/Registry", p->name, data);
9270 ast_verb(3, "Registered IAX2 '%s' (%s) at %s\n",
9271 p->name,
9272 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED",
9273 ast_sockaddr_stringify(addr));
9274 ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_ONLINE);
9275 blob = ast_json_pack("{s: s, s: s, s: i}",
9276 "peer_status", "Registered",
9277 "address", str_addr,
9278 "port", ast_sockaddr_port(addr));
9279 register_peer_exten(p, 1);
9280 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9281 } else if (!ast_test_flag64(p, IAX_TEMPONLY)) {
9282 ast_verb(3, "Unregistered IAX2 '%s' (%s)\n",
9283 p->name,
9284 ast_test_flag(&iaxs[callno]->state, IAX_STATE_AUTHENTICATED) ? "AUTHENTICATED" : "UNAUTHENTICATED");
9285 ast_endpoint_set_state(p->endpoint, AST_ENDPOINT_OFFLINE);
9286 blob = ast_json_pack("{s: s}",
9287 "peer_status", "Unregistered");
9288 register_peer_exten(p, 0);
9289 ast_db_del("IAX/Registry", p->name);
9290 ast_devstate_changed(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, "IAX2/%s", p->name); /* Activate notification */
9291 }
9292
9293 ast_endpoint_blob_publish(p->endpoint, ast_endpoint_state_type(), blob);
9294
9295 /* Update the host */
9296 /* Verify that the host is really there */
9297 iax2_poke_peer(p, callno);
9298 }
9299
9300 /* modify entry in peercnts table as registered */
9301 if (p->maxcallno) {
9302 peercnt_modify((unsigned char) 1, p->maxcallno, &p->addr);
9303 }
9304
9305 /* Make sure our call still exists, an INVAL at the right point may make it go away */
9306 if (!iaxs[callno]) {
9307 res = -1;
9308 goto return_unref;
9309 }
9310
9311 /* Store socket fd */
9312 p->sockfd = fd;
9313 /* Setup the expiry */
9314 if (p->expire > -1) {
9315 if (!AST_SCHED_DEL(sched, p->expire)) {
9316 p->expire = -1;
9317 peer_unref(p);
9318 }
9319 }
9320
9321 if (p->expiry && !ast_sockaddr_isnull(addr)) {
9322 p->expire = iax2_sched_add(sched, (p->expiry + 10) * 1000, expire_registry, peer_ref(p));
9323 if (p->expire == -1)
9324 peer_unref(p);
9325 }
9326 iax_ie_append_str(&ied, IAX_IE_USERNAME, p->name);
9327 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(p->zonetag));
9328 if (!ast_sockaddr_isnull(addr)) {
9329 struct ast_sockaddr peer_addr;
9330
9331 ast_sockaddr_copy(&peer_addr, &p->addr);
9332
9333 iax_ie_append_short(&ied, IAX_IE_REFRESH, p->expiry);
9334 iax_ie_append_addr(&ied, IAX_IE_APPARENT_ADDR, &peer_addr);
9335 if (!ast_strlen_zero(p->mailbox)) {
9336 int new, old;
9337 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
9338
9339 msg = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), p->mailbox);
9340 if (msg) {
9341 struct ast_mwi_state *mwi_state = stasis_message_data(msg);
9342 new = mwi_state->new_msgs;
9343 old = mwi_state->old_msgs;
9344 } else { /* Fall back on checking the mailbox directly */
9345 ast_app_inboxcount(p->mailbox, &new, &old);
9346 }
9347
9348 if (new > 255) {
9349 new = 255;
9350 }
9351 if (old > 255) {
9352 old = 255;
9353 }
9354 msgcount = (old << 8) | new;
9355
9356 iax_ie_append_short(&ied, IAX_IE_MSGCOUNT, msgcount);
9357 }
9358 if (ast_test_flag64(p, IAX_HASCALLERID)) {
9359 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, p->cid_num);
9360 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, p->cid_name);
9361 }
9362 }
9363 if (iax_firmware_get_version(devtype, &version)) {
9364 iax_ie_append_short(&ied, IAX_IE_FIRMWAREVER, version);
9365 }
9366
9367 res = 0;
9368
9369return_unref:
9370 peer_unref(p);
9371
9372 return res ? res : send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_REGACK, 0, ied.buf, ied.pos, -1);
9373}

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 2082 of file chan_iax2.c.

2083{
2084 struct iax2_user *user = obj, *user2 = arg;
2085 const char *name = arg;
2086
2087 return !strcmp(user->name, flags & OBJ_KEY ? name : user2->name) ?
2088 CMP_MATCH | CMP_STOP : 0;
2089}

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 13625 of file chan_iax2.c.

13626{
13627 struct iax2_user *user = obj;
13628
13629 ast_set_flag64(user, IAX_DELME);
13630
13631 return 0;
13632}

References ast_set_flag64, and IAX_DELME.

Referenced by delete_users().

◆ user_destructor()

static void user_destructor ( void *  obj)
static

Definition at line 13340 of file chan_iax2.c.

13341{
13342 struct iax2_user *user = obj;
13343
13344 ast_free_acl_list(user->acl);
13345 free_context(user->contexts);
13346 if(user->vars) {
13347 ast_variables_destroy(user->vars);
13348 user->vars = NULL;
13349 }
13350 ast_string_field_free_memory(user);
13351}

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 2071 of file chan_iax2.c.

2072{
2073 const struct iax2_user *user = obj;
2074 const char *name = obj;
2075
2076 return ast_str_hash(flags & OBJ_KEY ? name : user->name);
2077}

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 2125 of file chan_iax2.c.

2126{
2127 ao2_ref(user, -1);
2128 return NULL;
2129}

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 9573 of file chan_iax2.c.

9574{
9575 struct iax_frame *f;
9576
9577 AST_LIST_TRAVERSE(&frame_queue[callno], f, list) {
9578 /* Send a copy immediately */
9579 if (((unsigned char) (f->oseqno - last) < 128) &&
9580 (f->retries >= 0)) {
9581 send_packet(f);
9582 }
9583 }
9584}

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 5478 of file chan_iax2.c.

5479{
5480 unsigned short callno = pvt->callno;
5481
5482 if (!pvt->peercallno) {
5483 /* We don't know the remote side's call number, yet. :( */
5484 int count = 10;
5485 while (count-- && pvt && !pvt->peercallno) {
5486 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
5487 pvt = iaxs[callno];
5488 }
5489 if (!pvt || !pvt->peercallno) {
5490 return -1;
5491 }
5492 }
5493
5494 return 0;
5495}

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 = ASTERISK_GPL_KEY , .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 15138 of file chan_iax2.c.

◆ accountcode

char accountcode[AST_MAX_ACCOUNT_CODE]
static

Definition at line 510 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 365 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 = AST_LIST_HEAD_INIT_VALUE
static

◆ adsi

int adsi = 0
static

Definition at line 514 of file chan_iax2.c.

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

◆ amaflags

int amaflags = 0
static

Definition at line 513 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 15138 of file chan_iax2.c.

◆ auth_method_labels

const char* auth_method_labels[]
static

Name of effective auth method.

Definition at line 436 of file chan_iax2.c.

436 {
437 [0] = "none",
438 [IAX_AUTH_PLAINTEXT] = "plaintext",
439 [IAX_AUTH_MD5] = "MD5",
440 [IAX_AUTH_RSA] = "RSA",
441};

Referenced by acf_channel_read(), and socket_process_helper().

◆ authdebug

int authdebug = 0
static

Definition at line 382 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 383 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 1047 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 1004 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 = AST_MUTEX_INIT_VALUE
static

Definition at line 1001 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 1007 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 1050 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 14717 of file chan_iax2.c.

14717 {
14718 AST_CLI_DEFINE(handle_cli_iax2_provision, "Provision an IAX device"),
14719 AST_CLI_DEFINE(handle_cli_iax2_prune_realtime, "Prune a cached realtime lookup"),
14720 AST_CLI_DEFINE(handle_cli_iax2_reload, "Reload IAX configuration"),
14721 AST_CLI_DEFINE(handle_cli_iax2_set_mtu, "Set the IAX systemwide trunking MTU"),
14722 AST_CLI_DEFINE(handle_cli_iax2_set_debug, "Enable/Disable IAX debugging"),
14723 AST_CLI_DEFINE(handle_cli_iax2_set_debug_trunk, "Enable/Disable IAX trunk debugging"),
14724 AST_CLI_DEFINE(handle_cli_iax2_set_debug_jb, "Enable/Disable IAX jitterbuffer debugging"),
14725 AST_CLI_DEFINE(handle_cli_iax2_show_cache, "Display IAX cached dialplan"),
14726 AST_CLI_DEFINE(handle_cli_iax2_show_channels, "List active IAX channels"),
14727 AST_CLI_DEFINE(handle_cli_iax2_show_firmware, "List available IAX firmware"),
14728 AST_CLI_DEFINE(handle_cli_iax2_show_netstats, "List active IAX channel netstats"),
14729 AST_CLI_DEFINE(handle_cli_iax2_show_peer, "Show details on specific IAX peer"),
14730 AST_CLI_DEFINE(handle_cli_iax2_show_peers, "List defined IAX peers"),
14731 AST_CLI_DEFINE(handle_cli_iax2_show_registry, "Display IAX registration status"),
14732 AST_CLI_DEFINE(handle_cli_iax2_show_stats, "Display IAX statistics"),
14733 AST_CLI_DEFINE(handle_cli_iax2_show_threads, "Display IAX helper thread info"),
14734 AST_CLI_DEFINE(handle_cli_iax2_show_users, "List defined IAX users"),
14735 AST_CLI_DEFINE(handle_cli_iax2_test_losspct, "Set IAX2 incoming frame loss percentage"),
14736 AST_CLI_DEFINE(handle_cli_iax2_unregister, "Unregister (force expiration) an IAX2 peer from the registry"),
14737 AST_CLI_DEFINE(handle_cli_iax2_show_callno_limits, "Show current entries in IP call number limit table"),
14738#ifdef IAXTESTS
14739 AST_CLI_DEFINE(handle_cli_iax2_test_jitter, "Simulates jitter for testing"),
14740 AST_CLI_DEFINE(handle_cli_iax2_test_late, "Test the receipt of a late frame"),
14741 AST_CLI_DEFINE(handle_cli_iax2_test_resync, "Test a resync in received timestamps"),
14742#endif /* IAXTESTS */
14743};

Referenced by __unload_module(), and load_module().

◆ cos

unsigned int cos

Definition at line 393 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 1263 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 1052 of file chan_iax2.c.

Referenced by set_config().

◆ DEFAULT_MAXCALLNO_LIMIT_NONVAL

uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192
static

Definition at line 1054 of file chan_iax2.c.

Referenced by set_config().

◆ default_parkinglot

char default_parkinglot[AST_MAX_CONTEXT]
static

Definition at line 359 of file chan_iax2.c.

Referenced by __find_callno(), and set_config().

◆ defaultsockfd

int defaultsockfd = -1
static

Definition at line 405 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 515 of file chan_iax2.c.

Referenced by auth_fail(), set_config(), set_config_destroy(), and socket_process_helper().

◆ dpcache

struct dpcache dpcache = AST_LIST_HEAD_INIT_VALUE
static

◆ dynamic_list

struct dynamic_list dynamic_list = AST_LIST_HEAD_INIT_VALUE
static

◆ first

struct iax_frame* first

Definition at line 1018 of file chan_iax2.c.

◆ [struct]

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 354 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 1056 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 1059 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 566 of file chan_iax2.c.

Referenced by realtime_peer(), and set_config().

◆ globalflags

struct ast_flags64 globalflags = { 0 }
static

Definition at line 519 of file chan_iax2.c.

519{ 0 };

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 517 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 496 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 516 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 407 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 14707 of file chan_iax2.c.

14708{
14709 .name = "IAX2",
14710 .description = "IAX Remote Dialplan Switch",
14711 .exists = iax2_exists,
14712 .canmatch = iax2_canmatch,
14713 .exec = iax2_exec,
14714 .matchmore = iax2_matchmore,
14715};

Referenced by __unload_module(), and load_module().

◆ iax2_tech

struct ast_channel_tech iax2_tech
static

Definition at line 1379 of file chan_iax2.c.

1379 {
1380 .type = "IAX2",
1381 .description = tdesc,
1382 .properties = AST_CHAN_TP_WANTSJITTER,
1383 .requester = iax2_request,
1384 .devicestate = iax2_devicestate,
1385 .send_digit_begin = iax2_digit_begin,
1386 .send_digit_end = iax2_digit_end,
1387 .send_text = iax2_sendtext,
1388 .send_image = iax2_sendimage,
1389 .send_html = iax2_sendhtml,
1390 .call = iax2_call,
1391 .hangup = iax2_hangup,
1392 .answer = iax2_answer,
1393 .read = iax2_read,
1394 .write = iax2_write,
1395 .write_video = iax2_write,
1396 .indicate = iax2_indicate,
1397 .setoption = iax2_setoption,
1398 .queryoption = iax2_queryoption,
1399 .transfer = iax2_transfer,
1400 .fixup = iax2_fixup,
1401 .func_channel_read = acf_channel_read,
1402};

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 1608 of file chan_iax2.c.

1608 {
1609 .type = "IAX2_VARIABLE",
1610 .duplicate = iax2_dup_variable_datastore,
1611 .destroy = iax2_free_variable_datastore,
1612};

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 1240 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 1256 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 761 of file chan_iax2.c.

Referenced by iax2_process_thread(), and iax2_process_thread_cleanup().

◆ iaxcompat

int iaxcompat = 0
static

Definition at line 384 of file chan_iax2.c.

Referenced by set_config(), and socket_process_helper().

◆ iaxdebug

int iaxdebug = 0
static

Definition at line 498 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 387 of file chan_iax2.c.

Referenced by complete_dpreply(), dp_lookup(), and find_cache().

◆ iaxdefaulttimeout

int iaxdefaulttimeout = 5
static

Definition at line 389 of file chan_iax2.c.

Referenced by find_cache().

◆ iaxdynamicthreadcount

int iaxdynamicthreadcount = 0
static

Definition at line 759 of file chan_iax2.c.

Referenced by find_idle_thread(), and iax2_process_thread().

◆ iaxdynamicthreadnum

int iaxdynamicthreadnum = 0
static

Definition at line 760 of file chan_iax2.c.

Referenced by find_idle_thread().

◆ iaxmaxthreadcount

int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT
static

Definition at line 758 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 14624 of file chan_iax2.c.

14624 {
14625 .name = "IAXPEER",
14626 .read = function_iaxpeer,
14627};

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 1211 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 1249 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 757 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 500 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 10251 of file chan_iax2.c.

10251 {
10252 .name = "IAXVAR",
10253 .read = acf_iaxvar_read,
10254 .write = acf_iaxvar_write,
10255};

Referenced by load_module(), and unload_module().

◆ idle_list

struct idle_list idle_list = AST_LIST_HEAD_INIT_VALUE
static

◆ io

struct io_context* io
static

Definition at line 493 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 375 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

◆ lagrq_time

int lagrq_time = 10
static

Definition at line 371 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 361 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_dr(), ast_say_enumeration_full_en(), ast_say_enumeration_full_he(), ast_say_enumeration_full_is(), ast_say_enumeration_full_ps(), 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_dr(), 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_ps(), 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(), tds_load_module(), and xmldoc_get_node().

◆ last

struct iax_frame* last

Definition at line 1018 of file chan_iax2.c.

Referenced by vnak_retransmit().

◆ last_authmethod

int last_authmethod = 0
static

Definition at line 385 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 1024 of file chan_iax2.c.

Referenced by handle_call_token(), and set_config().

◆ max_reg_expire

int max_reg_expire
static

Definition at line 397 of file chan_iax2.c.

Referenced by set_config(), and update_registry().

◆ max_retries

int max_retries = 4
static

Definition at line 369 of file chan_iax2.c.

Referenced by __attempt_transmit(), and load_module().

◆ maxauthreq

int maxauthreq = 3
static

Definition at line 368 of file chan_iax2.c.

Referenced by build_user(), and set_config().

◆ maxjitterbuffer

int maxjitterbuffer =1000
static

Definition at line 372 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

◆ maxjitterinterps

int maxjitterinterps =10
static

Definition at line 374 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

◆ min_reg_expire

int min_reg_expire
static

Definition at line 396 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 511 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 512 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 403 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 521 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 366 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 364 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 404 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 12489 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 1044 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 1038 of file chan_iax2.c.

◆ ping_time

int ping_time = 21
static

Definition at line 370 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 345 of file chan_iax2.c.

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

◆ [struct]

struct { ... } qos

Referenced by peer_set_srcaddr(), set_config(), and set_qos().

◆ randomcalltokendata

int randomcalltokendata
static

Definition at line 1022 of file chan_iax2.c.

Referenced by handle_call_token(), and load_module().

◆ regcontext

char regcontext[AST_MAX_CONTEXT] = ""
static

Definition at line 362 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 = AST_LIST_HEAD_INIT_VALUE
static

◆ resyncthreshold

int resyncthreshold =1000
static

Definition at line 373 of file chan_iax2.c.

Referenced by new_iax(), and set_config().

◆ sched

struct ast_sched_context* sched
static

Definition at line 494 of file chan_iax2.c.

◆ srvlookup

int srvlookup = 0
static

Definition at line 399 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 347 of file chan_iax2.c.

◆ test_losspct

int test_losspct = 0
static

Definition at line 502 of file chan_iax2.c.

Referenced by handle_cli_iax2_test_losspct(), and socket_read().

◆ timer

struct ast_timer* timer
static

Definition at line 401 of file chan_iax2.c.

Referenced by __ast_channel_alloc_ap(), __ast_read(), __unload_module(), ack_ticks(), ast_bridge_features_init(), ast_deactivate_generator(), ast_settimeout_full(), 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(), 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 392 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 1061 of file chan_iax2.c.

Referenced by get_unused_callno(), handle_cli_iax2_show_callno_limits(), and replace_callno().

◆ tpeers

struct tpeers tpeers = AST_LIST_HEAD_INIT_VALUE
static

◆ transmit_processor

struct ast_taskprocessor* transmit_processor
static

Definition at line 1020 of file chan_iax2.c.

Referenced by __unload_module(), iax2_transmit(), and load_objects().

◆ trunk_maxmtu

int trunk_maxmtu
static

Definition at line 355 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 355 of file chan_iax2.c.

Referenced by handle_cli_iax2_show_stats(), and reload_config().

◆ trunk_timed

int trunk_timed
static

Definition at line 355 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 355 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 379 of file chan_iax2.c.

Referenced by load_module(), send_trunk(), and set_config().

◆ trunkmaxsize

int trunkmaxsize = MAX_TRUNKDATA
static

Definition at line 380 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 1041 of file chan_iax2.c.

Generated on Wed Jun 24 2026 10:42:40 for Asterisk - The Open Source Telephony Project by doxygen 1.9.8