Sat Oct 11 06:49:55 2008

Asterisk developer's documentation

---

chan_iax2.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2005, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Implementation of Inter-Asterisk eXchange Version 2
 *
 * \par See also
 * \arg \ref Config_iax
 *
 * \ingroup channel_drivers
 */

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.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 <sys/signal.h>
#include <signal.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <unistd.h>
#include <netdb.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <regex.h>
#ifdef IAX_TRUNKING
#include <sys/ioctl.h>
#ifdef __linux__
#include <linux/zaptel.h>
#else
#include <zaptel.h>
#endif /* __linux__ */
#endif

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 133360 $")

#include "asterisk/lock.h"
#include "asterisk/frame.h" 
#include "asterisk/channel.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/config.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/translate.h"
#include "asterisk/md5.h"
#include "asterisk/cdr.h"
#include "asterisk/crypto.h"
#include "asterisk/acl.h"
#include "asterisk/manager.h"
#include "asterisk/callerid.h"
#include "asterisk/app.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/aes.h"
#include "asterisk/dnsmgr.h"
#include "asterisk/devicestate.h"
#include "asterisk/netsock.h"
#include "asterisk/astobj2.h"

#include "iax2.h"
#include "iax2-parser.h"
#include "iax2-provision.h"

/* Define NEWJB to use the new channel independent jitterbuffer,
 * otherwise, use the old jitterbuffer */
#define NEWJB

#ifdef NEWJB
#include "../jitterbuf.h"
#endif

#ifndef IPTOS_MINCOST
#define IPTOS_MINCOST 0x02
#endif

#ifdef SO_NO_CHECK
static int nochecksums = 0;
#endif

/*
 * Uncomment to try experimental IAX bridge optimization,
 * designed to reduce latency when IAX calls cannot
 * be trasnferred -- obsolete
 */

/* #define BRIDGE_OPTIMIZATION  */


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

#define DEFAULT_RETRY_TIME 1000
#define MEMORY_SIZE 100
#define DEFAULT_DROP 3
/* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
   but keeps the division between trunked and non-trunked better. */
#define TRUNK_CALL_START   0x4000

#define DEBUG_SUPPORT

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

/* Sample over last 100 units to determine historic jitter */
#define GAMMA (0.01)

static struct ast_codec_pref prefs;

static const char desc[] = "Inter Asterisk eXchange (Ver 2)";
static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
static const char channeltype[] = "IAX2";

static char context[80] = "default";

static char language[MAX_LANGUAGE] = "";
static char regcontext[AST_MAX_CONTEXT] = "";

static int maxauthreq = 0;
static int max_retries = 4;
static int ping_time = 20;
static int lagrq_time = 10;
static int maxtrunkcall = TRUNK_CALL_START;
static int maxnontrunkcall = 1;
static int maxjitterbuffer=1000;
#ifdef NEWJB
static int resyncthreshold=1000;
static int maxjitterinterps=10;
#endif
static int jittershrinkrate=2;
static int trunkfreq = 20;
static int authdebug = 1;
static int autokill = 0;
static int iaxcompat = 0;

static int iaxdefaultdpcache=10 * 60;  /* Cache dialplan entries for 10 minutes by default */

static int iaxdefaulttimeout = 5;      /* Default to wait no more than 5 seconds for a reply to come back */

static int tos = 0;

static int min_reg_expire;
static int max_reg_expire;

static int timingfd = -1;           /* Timing file descriptor */

static struct ast_netsock_list *netsock;
static struct ast_netsock_list *outsock;     /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
static int defaultsockfd = -1;

static int usecnt;
AST_MUTEX_DEFINE_STATIC(usecnt_lock);

int (*iax2_regfunk)(char *username, int onoff) = NULL;

/* Ethernet, etc */
#define IAX_CAPABILITY_FULLBANDWIDTH   0xFFFF
/* T1, maybe ISDN */
#define IAX_CAPABILITY_MEDBANDWIDTH    (IAX_CAPABILITY_FULLBANDWIDTH &  \
                     ~AST_FORMAT_SLINEAR &   \
                     ~AST_FORMAT_ULAW &   \
                     ~AST_FORMAT_ALAW) 
/* A modem */
#define IAX_CAPABILITY_LOWBANDWIDTH    (IAX_CAPABILITY_MEDBANDWIDTH &   \
                     ~AST_FORMAT_G726 &   \
                     ~AST_FORMAT_ADPCM)

#define IAX_CAPABILITY_LOWFREE      (IAX_CAPABILITY_LOWBANDWIDTH &      \
                      ~AST_FORMAT_G723_1)


#define DEFAULT_MAXMS      2000     /* Must be faster than 2 seconds by default */
#define DEFAULT_FREQ_OK    60 * 1000   /* How often to check for the host to be up */
#define DEFAULT_FREQ_NOTOK 10 * 1000   /* How often to check, if the host is down... */

static   struct io_context *io;
static   struct sched_context *sched;

static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;

static int iax2_dropcount = DEFAULT_DROP;

static int iaxdebug = 0;

static int iaxtrunkdebug = 0;

static int test_losspct = 0;
#ifdef IAXTESTS
static int test_late = 0;
static int test_resync = 0;
static int test_jit = 0;
static int test_jitpct = 0;
#endif /* IAXTESTS */

static char accountcode[AST_MAX_ACCOUNT_CODE];
static int amaflags = 0;
static int delayreject = 0;
static int iax2_encryption = 0;

static struct ast_flags globalflags = { 0 };

static pthread_t netthreadid = AST_PTHREADT_NULL;

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

struct iax2_context {
   char context[AST_MAX_CONTEXT];
   struct iax2_context *next;
};

enum {
   IAX_HASCALLERID =    (1 << 0),   /*!< CallerID has been specified */
   IAX_DELME =    (1 << 1),   /*!< Needs to be deleted */
   IAX_TEMPONLY =    (1 << 2),   /*!< Temporary (realtime) */
   IAX_TRUNK =    (1 << 3),   /*!< Treat as a trunk */
   IAX_NOTRANSFER =  (1 << 4),   /*!< Don't native bridge */
   IAX_USEJITTERBUF =   (1 << 5),   /*!< Use jitter buffer */
   IAX_DYNAMIC =     (1 << 6),   /*!< dynamic peer */
   IAX_SENDANI =     (1 << 7),   /*!< Send ANI along with CallerID */
   IAX_MESSAGEDETAIL =  (1 << 8),   /*!< Show exact numbers */
   IAX_ALREADYGONE = (1 << 9),   /*!< Already disconnected */
   IAX_PROVISION =      (1 << 10),  /*!< This is a provisioning request */
   IAX_QUELCH =      (1 << 11),  /*!< Whether or not we quelch audio */
   IAX_ENCRYPTED =      (1 << 12),  /*!< Whether we should assume encrypted tx/rx */
   IAX_KEYPOPULATED =   (1 << 13),  /*!< Whether we have a key populated */
   IAX_CODEC_USER_FIRST =  (1 << 14),  /*!< are we willing to let the other guy choose the codec? */
   IAX_CODEC_NOPREFS =     (1 << 15),  /*!< Force old behaviour by turning off prefs */
   IAX_CODEC_NOCAP =    (1 << 16),  /*!< only consider requested format and ignore capabilities*/
   IAX_RTCACHEFRIENDS =    (1 << 17),  /*!< let realtime stay till your reload */
   IAX_RTUPDATE =       (1 << 18),  /*!< Send a realtime update */
   IAX_RTAUTOCLEAR =    (1 << 19),  /*!< erase me on expire */ 
   IAX_FORCEJITTERBUF = (1 << 20),  /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */ 
   IAX_RTIGNOREREGEXPIRE = (1 << 21),  /*!< When using realtime, ignore registration expiration */
   IAX_TRUNKTIMESTAMPS =   (1 << 22),  /*!< Send trunk timestamps */
   IAX_MAXAUTHREQ =        (1 << 23),      /*!< Maximum outstanding AUTHREQ restriction is in place */
   IAX_DELAYPBXSTART =  (1 << 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*/
   IAX_ALLOWFWDOWNLOAD = (1 << 26), /*!< Allow the FWDOWNL command? */
} iax2_flags;

static int global_rtautoclear = 120;

static int reload_config(void);
static int iax2_reload(int fd, int argc, char *argv[]);


struct iax2_user {
   char name[80];
   char secret[80];
   char dbsecret[80];
   int authmethods;
   int encmethods;
   char accountcode[AST_MAX_ACCOUNT_CODE];
   char inkeys[80];           /*!< Key(s) this user can use to authenticate to us */
   char language[MAX_LANGUAGE];
   int amaflags;
   unsigned int flags;
   int capability;
   int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
   int curauthreq; /*!< Current number of outstanding AUTHREQs */
   char cid_num[AST_MAX_EXTENSION];
   char cid_name[AST_MAX_EXTENSION];
   struct ast_codec_pref prefs;
   struct ast_ha *ha;
   struct iax2_context *contexts;
   struct iax2_user *next;
   struct ast_variable *vars;
};

struct iax2_peer {
   char name[80];
   char username[80];      
   char secret[80];
   char dbsecret[80];
   char outkey[80];           /*!< What key we use to talk to this peer */
   char context[AST_MAX_CONTEXT];         /*!< For transfers only */
   char regexten[AST_MAX_EXTENSION];      /*!< Extension to register (if regcontext is used) */
   char peercontext[AST_MAX_EXTENSION];      /*!< Context to pass to peer */
   char mailbox[AST_MAX_EXTENSION];    /*!< Mailbox */
   struct ast_codec_pref prefs;
   struct ast_dnsmgr_entry *dnsmgr;    /*!< DNS refresh manager */
   struct sockaddr_in addr;
   int formats;
   int sockfd;             /*!< Socket to use for transmission */
   struct in_addr mask;
   unsigned int flags;

   /* Dynamic Registration fields */
   struct sockaddr_in defaddr;         /*!< Default address if there is one */
   int authmethods;           /*!< Authentication methods (IAX_AUTH_*) */
   int encmethods;               /*!< Encryption methods (IAX_ENCRYPT_*) */
   char inkeys[80];           /*!< Key(s) this peer can use to authenticate to us */

   /* Suggested caller id if registering */
   char cid_num[AST_MAX_EXTENSION];
   char cid_name[AST_MAX_EXTENSION];
   
   int expire;             /*!< Schedule entry for expiry */
   int expiry;             /*!< How soon to expire */
   int capability;               /*!< Capability */
   char zonetag[80];          /*!< Time Zone */

   /* Qualification */
   int callno;             /*!< Call number of POKE request */
   int pokeexpire;               /*!< When to expire poke */
   int lastms;             /*!< How long last response took (in ms), or -1 for no response */
   int maxms;              /*!< Max ms we will accept for the host to be up, 0 to not monitor */

   int pokefreqok;               /*!< How often to check if the host is up */
   int pokefreqnotok;            /*!< How often to check when the host has been determined to be down */
   int historicms;               /*!< How long recent average responses took */
   int smoothing;             /*!< Sample over how many units to determine historic ms */
   
   struct ast_ha *ha;
   struct iax2_peer *next;
};

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

static struct iax2_trunk_peer {
   ast_mutex_t lock;
   int sockfd;
   struct sockaddr_in addr;
   struct timeval txtrunktime;      /*!< Transmit trunktime */
   struct timeval rxtrunktime;      /*!< Receive trunktime */
   struct timeval lasttxtime;    /*!< Last transmitted trunktime */
   struct timeval trunkact;      /*!< Last trunk activity */
   unsigned int lastsent;        /*!< Last sent time */
   /* Trunk data and length */
   unsigned char *trunkdata;
   unsigned int trunkdatalen;
   unsigned int trunkdataalloc;
   struct iax2_trunk_peer *next;
   int trunkerror;
   int calls;
} *tpeers = NULL;

AST_MUTEX_DEFINE_STATIC(tpeerlock);

struct iax_firmware {
   struct iax_firmware *next;
   int fd;
   int mmaplen;
   int dead;
   struct ast_iax2_firmware_header *fwh;
   unsigned char *buf;
};

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

struct iax2_registry {
   struct sockaddr_in addr;      /*!< Who we connect to for registration purposes */
   char username[80];
   char secret[80];        /*!< Password or key name in []'s */
   char random[80];
   int expire;          /*!< Sched ID of expiration */
   int refresh;            /*!< How often to refresh */
   enum iax_reg_state regstate;
   int messages;           /*!< Message count */
   int callno;          /*!< Associated call number if applicable */
   struct sockaddr_in us;        /*!< Who the server thinks we are */
   struct iax2_registry *next;
};

static struct iax2_registry *registrations;
AST_MUTEX_DEFINE_STATIC(reg_lock);

/* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
#define MIN_RETRY_TIME     100
#define MAX_RETRY_TIME     10000

#define MAX_JITTER_BUFFER  50
#define MIN_JITTER_BUFFER  10

#define DEFAULT_TRUNKDATA  640 * 10 /*!< 40ms, uncompressed linear * 10 channels */
#define MAX_TRUNKDATA      640 * 200   /*!< 40ms, uncompressed linear * 200 channels */

#define MAX_TIMESTAMP_SKEW 160      /*!< maximum difference between actual and predicted ts for sending */

/* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
#define TS_GAP_FOR_JB_RESYNC  5000

/* If we have more than this much excess real jitter buffer, shrink it. */
static int max_jitter_buffer = MAX_JITTER_BUFFER;
/* If we have less than this much excess real jitter buffer, enlarge it. */
static int min_jitter_buffer = MIN_JITTER_BUFFER;

struct iax_rr {
   int jitter;
   int losspct;
   int losscnt;
   int packets;
   int delay;
   int dropped;
   int ooo;
};

struct chan_iax2_pvt {
   /*! Socket to send/receive on for this call */
   int sockfd;
   /*! Last received voice format */
   int voiceformat;
   /*! Last received video format */
   int videoformat;
   /*! Last sent voice format */
   int svoiceformat;
   /*! Last sent video format */
   int svideoformat;
   /*! What we are capable of sending */
   int capability;
   /*! Last received timestamp */
   unsigned int last;
   /*! Last sent timestamp - never send the same timestamp twice in a single call */
   unsigned int lastsent;
   /*! Next outgoing timestamp if everything is good */
   unsigned int nextpred;
   /*! True if the last voice we transmitted was not silence/CNG */
   int notsilenttx;
   /*! Ping time */
   unsigned int pingtime;
   /*! Max time for initial response */
   int maxtime;
   /*! Peer Address */
   struct sockaddr_in addr;
   /*! Actual used codec preferences */
   struct ast_codec_pref prefs;
   /*! Requested codec preferences */
   struct ast_codec_pref rprefs;
   /*! Our call number */
   unsigned short callno;
   /*! Peer callno */
   unsigned short peercallno;
   /*! Negotiated format, this is only used to remember what format was
       chosen for an unauthenticated call so that the channel can get
       created later using the right format */
   int chosenformat;
   /*! Peer selected format */
   int peerformat;
   /*! Peer capability */
   int peercapability;
   /*! timeval that we base our transmission on */
   struct timeval offset;
   /*! timeval that we base our delivery on */
   struct timeval rxcore;
#ifdef NEWJB
   /*! The jitterbuffer */
        jitterbuf *jb;
   /*! active jb read scheduler id */
        int jbid;                       
#else
   /*! Historical delivery time */
   int history[MEMORY_SIZE];
   /*! Current base jitterbuffer */
   int jitterbuffer;
   /*! Current jitter measure */
   int jitter;
   /*! Historic jitter value */
   int historicjitter;
#endif
   /*! LAG */
   int lag;
   /*! Error, as discovered by the manager */
   int error;
   /*! Owner if we have one */
   struct ast_channel *owner;
   /*! What's our state? */
   struct ast_flags state;
   /*! Expiry (optional) */
   int expiry;
   /*! Next outgoing sequence number */
   unsigned char oseqno;
   /*! Next sequence number they have not yet acknowledged */
   unsigned char rseqno;
   /*! Next incoming sequence number */
   unsigned char iseqno;
   /*! Last incoming sequence number we have acknowledged */
   unsigned char aseqno;
   /*! Peer name */
   char peer[80];
   /*! Default Context */
   char context[80];
   /*! Caller ID if available */
   char cid_num[80];
   char cid_name[80];
   /*! Hidden Caller ID (i.e. ANI) if appropriate */
   char ani[80];
   /*! DNID */
   char dnid[80];
   /*! Requested Extension */
   char exten[AST_MAX_EXTENSION];
   /*! Expected Username */
   char username[80];
   /*! Expected Secret */
   char secret[80];
   /*! permitted authentication methods */
   int authmethods;
   /*! permitted encryption methods */
   int encmethods;
   /*! MD5 challenge */
   char challenge[10];
   /*! Public keys permitted keys for incoming authentication */
   char inkeys[80];
   /*! Private key for outgoing authentication */
   char outkey[80];
   /*! Encryption AES-128 Key */
   aes_encrypt_ctx ecx;
   /*! Decryption AES-128 Key */
   aes_decrypt_ctx dcx;
   /*! 32 bytes of semi-random data */
   unsigned char semirand[32];
   /*! Preferred language */
   char language[MAX_LANGUAGE];
   /*! Hostname/peername for naming purposes */
   char host[80];
   /*! Associated registry */
   struct iax2_registry *reg;
   /*! Associated peer for poking */
   struct iax2_peer *peerpoke;
   /*! IAX_ flags */
   unsigned int flags;

   /*! Transferring status */
   enum iax_transfer_state transferring;
   /*! Transfer identifier */
   int transferid;
   /*! Who we are IAX transfering to */
   struct sockaddr_in transfer;
   /*! What's the new call number for the transfer */
   unsigned short transfercallno;
   /*! Transfer decrypt AES-128 Key */
   aes_encrypt_ctx tdcx;

   /*! Status of knowledge of peer ADSI capability */
   int peeradsicpe;
   
   /*! Who we are bridged to */
   unsigned short bridgecallno;
   unsigned int bridgesfmt;
   struct ast_trans_pvt *bridgetrans;
   
   int pingid;       /*!< Transmit PING request */
   int lagid;        /*!< Retransmit lag request */
   int autoid;       /*!< Auto hangup for Dialplan requestor */
   int authid;       /*!< Authentication rejection ID */
   int authfail;        /*!< Reason to report failure */
   int initid;       /*!< Initial peer auto-congest ID (based on qualified peers) */
   int calling_ton;
   int calling_tns;
   int calling_pres;
   char dproot[AST_MAX_EXTENSION];
   char accountcode[AST_MAX_ACCOUNT_CODE];
   int amaflags;
   struct iax2_dpcache *dpentries;
   struct ast_variable *vars;
   /*! last received remote rr */
   struct iax_rr remote_rr;
   /*! Current base time: (just for stats) */
   int min;
   /*! Dropped frame count: (just for stats) */
   int frames_dropped;
   /*! received frame count: (just for stats) */
   int frames_received;
};

static struct ast_iax2_queue {
   struct iax_frame *head;
   struct iax_frame *tail;
   int count;
   ast_mutex_t lock;
} iaxq;

static struct ast_user_list {
   struct iax2_user *users;
   ast_mutex_t lock;
} userl;

static struct ast_peer_list {
   struct iax2_peer *peers;
   ast_mutex_t lock;
} peerl;

static struct ast_firmware_list {
   struct iax_firmware *wares;
   ast_mutex_t lock;
} waresl;

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

static struct iax2_dpcache {
   char peercontext[AST_MAX_CONTEXT];
   char exten[AST_MAX_EXTENSION];
   struct timeval orig;
   struct timeval expiry;
   int flags;
   unsigned short callno;
   int waiters[256];
   struct iax2_dpcache *next;
   struct iax2_dpcache *peer; /*!< For linking in peers */
} *dpcache;

AST_MUTEX_DEFINE_STATIC(dpcache_lock);

static void reg_source_db(struct iax2_peer *p);
static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);

static void destroy_peer(struct iax2_peer *peer);
static int ast_cli_netstats(int fd, int limit_fmt);

#ifdef __AST_DEBUG_MALLOC
static void FREE(void *ptr)
{
   free(ptr);
}
#else
#define FREE free
#endif

static void iax_debug_output(const char *data)
{
   if (iaxdebug)
      ast_verbose("%s", data);
}

static void iax_error_output(const char *data)
{
   ast_log(LOG_WARNING, "%s", data);
}

#ifdef NEWJB
static void jb_error_output(const char *fmt, ...)
{
   va_list args;
   char buf[1024];

   va_start(args, fmt);
   vsnprintf(buf, 1024, fmt, args);
   va_end(args);

   ast_log(LOG_ERROR, buf);
}

static void jb_warning_output(const char *fmt, ...)
{
   va_list args;
   char buf[1024];

   va_start(args, fmt);
   vsnprintf(buf, 1024, fmt, args);
   va_end(args);

   ast_log(LOG_WARNING, buf);
}

static void jb_debug_output(const char *fmt, ...)
{
   va_list args;
   char buf[1024];

   va_start(args, fmt);
   vsnprintf(buf, 1024, fmt, args);
   va_end(args);

   ast_verbose(buf);
}
#endif


/* XXX We probably should use a mutex when working with this XXX */
static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
static ast_mutex_t iaxsl[IAX_MAX_CALLS];
static struct timeval lastused[IAX_MAX_CALLS];

/*!
 * \brief 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.
 */
static struct ao2_container *iax_peercallno_pvts;

static int send_command(struct chan_iax2_pvt *,