Sat Nov 1 06:28:25 2008

Asterisk developer's documentation

---

chan_iax2.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, 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
 *
 * \author Mark Spencer <markster@digium.com>
 *
 * \par See also
 * \arg \ref Config_iax
 *
 * \ingroup channel_drivers
 */

/*** MODULEINFO
   <use>dahdi</use>
        <depend>res_features</depend>
 ***/

#include "asterisk.h"

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

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

#if defined(HAVE_ZAPTEL) || defined (HAVE_DAHDI)
#include <sys/ioctl.h>
#include "asterisk/dahdi_compat.h"
#endif

#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/stringfields.h"
#include "asterisk/linkedlists.h"
#include "asterisk/astobj2.h"

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

/* Define SCHED_MULTITHREADED to run the scheduler in a special
   multithreaded mode. */
#define SCHED_MULTITHREADED

/* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
   thread is actually doing. */
#define DEBUG_SCHED_MULTITHREAD

#ifndef IPTOS_MINCOST
#define IPTOS_MINCOST 0x02
#endif

#ifdef SO_NO_CHECK
static int nochecksums = 0;
#endif


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

#define DEFAULT_THREAD_COUNT 10
#define DEFAULT_MAX_THREAD_COUNT 100
#define DEFAULT_RETRY_TIME 1000
#define MEMORY_SIZE 100
#define DEFAULT_DROP 3

#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 tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";

static char context[80] = "default";

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

static int maxauthreq = 3;
static int max_retries = 4;
static int ping_time = 21;
static int lagrq_time = 10;
static int maxjitterbuffer=1000;
static int resyncthreshold=1000;
static int maxjitterinterps=10;
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 unsigned 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;

int (*iax2_regfunk)(const 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 &        \
                ~AST_FORMAT_G722) 
/* A modem */
#define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH &      \
                ~AST_FORMAT_G726 &        \
                ~AST_FORMAT_G726_AAL2 &      \
                ~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 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 char mohinterpret[MAX_MUSICCLASS];
static char mohsuggest[MAX_MUSICCLASS];
static int amaflags = 0;
static int adsi = 0;
static int delayreject = 0;
static int iax2_encryption = 0;

static struct ast_flags globalflags = { 0 };

static pthread_t netthreadid = AST_PTHREADT_NULL;
static pthread_t schedthreadid = AST_PTHREADT_NULL;
AST_MUTEX_DEFINE_STATIC(sched_lock);
static ast_cond_t sched_cond;

enum {
   IAX_STATE_STARTED =     (1 << 0),
   IAX_STATE_AUTHENTICATED =  (1 << 1),
   IAX_STATE_TBD =      (1 << 2),
   IAX_STATE_UNCHANGED =      (1 << 3),
} 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 */
        /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
   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_TRANSFERMEDIA =  (1 << 23),      /*!< When doing IAX2 transfers, transfer media only */
   IAX_MAXAUTHREQ =        (1 << 24),      /*!< 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 {
   AST_DECLARE_STRING_FIELDS(
      AST_STRING_FIELD(name);
      AST_STRING_FIELD(secret);
      AST_STRING_FIELD(dbsecret);
      AST_STRING_FIELD(accountcode);
      AST_STRING_FIELD(mohinterpret);
      AST_STRING_FIELD(mohsuggest);
      AST_STRING_FIELD(inkeys);               /*!< Key(s) this user can use to authenticate to us */
      AST_STRING_FIELD(language);
      AST_STRING_FIELD(cid_num);
      AST_STRING_FIELD(cid_name);
   );
   
   int authmethods;
   int encmethods;
   int amaflags;
   int adsi;
   unsigned int flags;
   int capability;
   int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
   int curauthreq; /*!< Current number of outstanding AUTHREQs */
   struct ast_codec_pref prefs;
   struct ast_ha *ha;
   struct iax2_context *contexts;
   struct ast_variable *vars;
};

struct iax2_peer {
   AST_DECLARE_STRING_FIELDS(
      AST_STRING_FIELD(name);
      AST_STRING_FIELD(username);
      AST_STRING_FIELD(secret);
      AST_STRING_FIELD(dbsecret);
      AST_STRING_FIELD(outkey);      /*!< What key we use to talk to this peer */

      AST_STRING_FIELD(regexten);     /*!< Extension to register (if regcontext is used) */
      AST_STRING_FIELD(context);      /*!< For transfers only */
      AST_STRING_FIELD(peercontext);  /*!< Context to pass to peer */
      AST_STRING_FIELD(mailbox);     /*!< Mailbox */
      AST_STRING_FIELD(mohinterpret);
      AST_STRING_FIELD(mohsuggest);
      AST_STRING_FIELD(inkeys);     /*!< Key(s) this peer can use to authenticate to us */
      /* Suggested caller id if registering */
      AST_STRING_FIELD(cid_num);    /*!< Default context (for transfer really) */
      AST_STRING_FIELD(cid_name);      /*!< Default context (for transfer really) */
      AST_STRING_FIELD(zonetag);    /*!< Time Zone */
   );
   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;
   int adsi;
   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_*) */

   int expire;             /*!< Schedule entry for expiry */
   int expiry;             /*!< How soon to expire */
   int capability;               /*!< Capability */

   /* Qualification */
   int callno;             /*!< Call number of POKE request */
   int pokeexpire;               /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
   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;
};

#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,
   TRANSFER_MBEGIN,
   TRANSFER_MREADY,
   TRANSFER_MRELEASED,
   TRANSFER_MPASSTHROUGH,
   TRANSFER_MEDIA,
   TRANSFER_MEDIAPASS
};

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, low 8 bits = new, high 8 bits = old */
   int callno;          /*!< Associated call number if applicable */
   struct sockaddr_in us;        /*!< Who the server thinks we are */
   struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
   AST_LIST_ENTRY(iax2_registry) entry;
};

static AST_LIST_HEAD_STATIC(registrations, iax2_registry);

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

static int iaxthreadcount = DEFAULT_THREAD_COUNT;
static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
static int iaxdynamicthreadcount = 0;
static int iaxdynamicthreadnum = 0;
static int iaxactivethreadcount = 0;

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;
   /*! Timestamp of the last video frame sent */
   unsigned int lastvsent;
   /*! 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;
   /*! The jitterbuffer */
        jitterbuf *jb;
   /*! active jb read scheduler id */
        int jbid;                       
   /*! 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;

   AST_DECLARE_STRING_FIELDS(
      /*! Peer name */
      AST_STRING_FIELD(peer);
      /*! Default Context */
      AST_STRING_FIELD(context);
      /*! Caller ID if available */
      AST_STRING_FIELD(cid_num);
      AST_STRING_FIELD(cid_name);
      /*! Hidden Caller ID (i.e. ANI) if appropriate */
      AST_STRING_FIELD(ani);
      /*! DNID */
      AST_STRING_FIELD(dnid);
      /*! RDNIS */
      AST_STRING_FIELD(rdnis);
      /*! Requested Extension */
      AST_STRING_FIELD(exten);
      /*! Expected Username */
      AST_STRING_FIELD(username);
      /*! Expected Secret */
      AST_STRING_FIELD(secret);
      /*! MD5 challenge */
      AST_STRING_FIELD(challenge);
      /*! Public keys permitted keys for incoming authentication */
      AST_STRING_FIELD(inkeys);
      /*! Private key for outgoing authentication */
      AST_STRING_FIELD(outkey);
      /*! Preferred language */
      AST_STRING_FIELD(language);
      /*! Hostname/peername for naming purposes */
      AST_STRING_FIELD(host);

      AST_STRING_FIELD(dproot);
      AST_STRING_FIELD(accountcode);
      AST_STRING_FIELD(mohinterpret);
      AST_STRING_FIELD(mohsuggest);
   );
   
   /*! permitted authentication methods */
   int authmethods;
   /*! permitted encryption methods */
   int encmethods;
   /*! 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];
   /*! Associated registry */
   struct iax2_registry *reg;
   /*! Associated peer for poking */
   struct iax2_peer *peerpoke;
   /*! IAX_ flags */
   unsigned int flags;
   int adsi;

   /*! 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;
   
   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;
   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 {
   AST_LIST_HEAD(, iax_frame) queue;
   int count;
} iaxq;

/*!
 * 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 entires are specified in iax.conf for matching order. */
#ifdef LOW_MEMORY
#define MAX_PEER_BUCKETS 1
/* #define MAX_PEER_BUCKETS 17 */
#else
#define MAX_PEER_BUCKETS 1
/* #define MAX_PEER_BUCKETS 563 */
#endif
static struct ao2_container *peers;

#define MAX_USER_BUCKETS MAX_PEER_BUCKETS
static struct ao2_container *users;

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 int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);

#define IAX_IOSTATE_IDLE      0
#define IAX_IOSTATE_READY     1
#define IAX_IOSTATE_PROCESSING   2
#define IAX_IOSTATE_SCHEDREADY   3

#define IAX_TYPE_POOL    1
#define IAX_TYPE_DYNAMIC 2

struct iax2_pkt_buf {
   AST_LIST_ENTRY(iax2_pkt_buf) entry;
   size_t len;
   unsigned char buf[1];
};

struct iax2_thread {
   AST_LIST_ENTRY(iax2_thread) list;
   int type;
   int iostate;
#ifdef SCHED_MULTITHREADED
   void (*schedfunc)(const void *);
   const void *scheddata;
#endif
#ifdef DEBUG_SCHED_MULTITHREAD
   char curfunc[80];
#endif   
   int actions;
   pthread_t threadid;
   int threadnum;
   struct sockaddr_in iosin;
   unsigned char readbuf[4096]; 
   unsigned char *buf;
   ssize_t buf_len;
   size_t buf_size;
   int iofd;
   time_t checktime;
   ast_mutex_t lock;
   ast_cond_t cond;
   unsigned int ready_for_signal:1;
   /*! if this thread is processing a full frame,
     some information about that frame will be stored
     here, so we can avoid dispatching any more full
     frames for that callno to other threads */
   struct {
      unsigned short callno;
      struct sockaddr_in sin;
      unsigned char type;
      unsigned char csub;
   } ffinfo;
   /*! Queued up full frames for processing.  If more full frames arrive for
    *  a call which this thread is already processing a full frame for, they
    *  are queued up here. */
   AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
};

/* Thread lists */
static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);

static void *iax2_process_thread(void *data);

static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
{
   ast_mutex_lock(lock);
   ast_cond_signal(cond);
   ast_mutex_unlock(lock);
}

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

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

/* 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[ARRAY_LEN(iaxs)];
static struct timeval lastused[ARRAY_LEN(iaxs)];

/*!
 * \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;