channels/chan_iax2.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Implementation of Inter-Asterisk eXchange Version 2
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  *
  25  * \par See also
  26  * \arg \ref Config_iax
  27  *
  28  * \ingroup channel_drivers
  29  *
  30  * \todo Implement musicclass settings for IAX2 devices
  31  */
  32
  33 /*** MODULEINFO
  34         <use>crypto</use>
  35  ***/
  36
  37 #include "asterisk.h"
  38
  39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  40
  41 #include <sys/mman.h>
  42 #include <dirent.h>
  43 #include <sys/socket.h>
  44 #include <netinet/in.h>
  45 #include <arpa/inet.h>
  46 #include <netinet/in_systm.h>
  47 #include <netinet/ip.h>
  48 #include <sys/time.h>
  49 #include <sys/signal.h>
  50 #include <signal.h>
  51 #include <strings.h>
  52 #include <netdb.h>
  53 #include <fcntl.h>
  54 #include <sys/stat.h>
  55 #include <regex.h>
  56
  57 #include "asterisk/paths.h"     /* need ast_config_AST_DATA_DIR for firmware */
  58
  59 #include "asterisk/lock.h"
  60 #include "asterisk/frame.h"
  61 #include "asterisk/channel.h"
  62 #include "asterisk/module.h"
  63 #include "asterisk/pbx.h"
  64 #include "asterisk/sched.h"
  65 #include "asterisk/io.h"
  66 #include "asterisk/config.h"
  67 #include "asterisk/cli.h"
  68 #include "asterisk/translate.h"
  69 #include "asterisk/md5.h"
  70 #include "asterisk/cdr.h"
  71 #include "asterisk/crypto.h"
  72 #include "asterisk/acl.h"
  73 #include "asterisk/manager.h"
  74 #include "asterisk/callerid.h"
  75 #include "asterisk/app.h"
  76 #include "asterisk/astdb.h"
  77 #include "asterisk/musiconhold.h"
  78 #include "asterisk/features.h"
  79 #include "asterisk/utils.h"
  80 #include "asterisk/causes.h"
  81 #include "asterisk/localtime.h"
  82 #include "asterisk/aes.h"
  83 #include "asterisk/dnsmgr.h"
  84 #include "asterisk/devicestate.h"
  85 #include "asterisk/netsock.h"
  86 #include "asterisk/stringfields.h"
  87 #include "asterisk/linkedlists.h"
  88 #include "asterisk/event.h"
  89 #include "asterisk/astobj2.h"
  90 #include "asterisk/timing.h"
  91
  92 #include "iax2.h"
  93 #include "iax2-parser.h"
  94 #include "iax2-provision.h"
  95 #include "jitterbuf.h"
  96
  97 /*** DOCUMENTATION
  98         <application name="IAX2Provision" language="en_US">
  99                 <synopsis>
 100                         Provision a calling IAXy with a given template.
 101                 </synopsis>
 102                 <syntax>
 103                         <parameter name="template">
 104                                 <para>If not specified, defaults to <literal>default</literal>.</para>
 105                         </parameter>
 106                 </syntax>
 107                 <description>
 108                         <para>Provisions the calling IAXy (assuming the calling entity is in fact an IAXy) with the
 109                         given <replaceable>template</replaceable>. Returns <literal>-1</literal> on error
 110                         or <literal>0</literal> on success.</para>
 111                 </description>
 112         </application>
 113         <function name="IAXPEER" language="en_US">
 114                 <synopsis>
 115                         Gets IAX peer information.
 116                 </synopsis>
 117                 <syntax>
 118                         <parameter name="peername" required="true">
 119                                 <enumlist>
 120                                         <enum name="CURRENTCHANNEL">
 121                                                 <para>If <replaceable>peername</replaceable> is specified to this value, return the IP address of the
 122                                                 endpoint of the current channel</para>
 123                                         </enum>
 124                                 </enumlist>
 125                         </parameter>
 126                         <parameter name="item">
 127                                 <para>If <replaceable>peername</replaceable> is specified, valid items are:</para>
 128                                 <enumlist>
 129                                         <enum name="ip">
 130                                                 <para>(default) The IP address.</para>
 131                                         </enum>
 132                                         <enum name="status">
 133                                                 <para>The peer's status (if <literal>qualify=yes</literal>)</para>
 134                                         </enum>
 135                                         <enum name="mailbox">
 136                                                 <para>The configured mailbox.</para>
 137                                         </enum>
 138                                         <enum name="context">
 139                                                 <para>The configured context.</para>
 140                                         </enum>
 141                                         <enum name="expire">
 142                                                 <para>The epoch time of the next expire.</para>
 143                                         </enum>
 144                                         <enum name="dynamic">
 145                                                 <para>Is it dynamic? (yes/no).</para>
 146                                         </enum>
 147                                         <enum name="callerid_name">
 148                                                 <para>The configured Caller ID name.</para>
 149                                         </enum>
 150                                         <enum name="callerid_num">
 151                                                 <para>The configured Caller ID number.</para>
 152                                         </enum>
 153                                         <enum name="codecs">
 154                                                 <para>The configured codecs.</para>
 155                                         </enum>
 156                                         <enum name="codec[x]">
 157                                                 <para>Preferred codec index number <replaceable>x</replaceable> (beginning
 158                                                 with <literal>0</literal>)</para>
 159                                         </enum>
 160                                 </enumlist>
 161                         </parameter>
 162                 </syntax>
 163                 <description />
 164                 <see-also>
 165                         <ref type="function">SIPPEER</ref>
 166                 </see-also>
 167         </function>
 168         <function name="IAXVAR" language="en_US">
 169                 <synopsis>
 170                         Sets or retrieves a remote variable.
 171                 </synopsis>
 172                 <syntax>
 173                         <parameter name="varname" required="true" />
 174                 </syntax>
 175                 <description />
 176         </function>
 177  ***/
 178
 179 /* Define SCHED_MULTITHREADED to run the scheduler in a special
 180    multithreaded mode. */
 181 #define SCHED_MULTITHREADED
 182
 183 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
 184    thread is actually doing. */
 185 #define DEBUG_SCHED_MULTITHREAD
 186
 187
 188 #ifdef SO_NO_CHECK
 189 static int nochecksums = 0;
 190 #endif
 191
 192 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
 193 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
 194
 195 #define DEFAULT_THREAD_COUNT 10
 196 #define DEFAULT_MAX_THREAD_COUNT 100
 197 #define DEFAULT_RETRY_TIME 1000
 198 #define MEMORY_SIZE 100
 199 #define DEFAULT_DROP 3
 200
 201 #define DEBUG_SUPPORT
 202
 203 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
 204
 205 /* Sample over last 100 units to determine historic jitter */
 206 #define GAMMA (0.01)
 207
 208 static struct ast_codec_pref prefs;
 209
 210 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
 211
 212
 213 /*! \brief Maximum transmission unit for the UDP packet in the trunk not to be
 214     fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240 */
 215 #define MAX_TRUNK_MTU 1240
 216
 217 static int global_max_trunk_mtu;        /*!< Maximum MTU, 0 if not used */
 218 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ;    /*!< Trunk MTU statistics */
 219
 220 #define DEFAULT_CONTEXT "default"
 221
 222 static char default_parkinglot[AST_MAX_CONTEXT];
 223
 224 static char language[MAX_LANGUAGE] = "";
 225 static char regcontext[AST_MAX_CONTEXT] = "";
 226
 227 static int maxauthreq = 3;
 228 static int max_retries = 4;
 229 static int ping_time = 21;
 230 static int lagrq_time = 10;
 231 static int maxjitterbuffer=1000;
 232 static int resyncthreshold=1000;
 233 static int maxjitterinterps=10;
 234 static int jittertargetextra = 40; /* number of milliseconds the new jitter buffer adds on to its size */
 235
 236 #define MAX_TRUNKDATA           640 * 200       /*!< 40ms, uncompressed linear * 200 channels */
 237
 238 static int trunkfreq = 20;
 239 static int trunkmaxsize = MAX_TRUNKDATA;
 240
 241 static int authdebug = 1;
 242 static int autokill = 0;
 243 static int iaxcompat = 0;
 244 static int last_authmethod = 0;
 245
 246 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
 247
 248 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
 249
 250 static struct {
 251         unsigned int tos;
 252         unsigned int cos;
 253 } qos = { 0, 0 };
 254
 255 static int min_reg_expire;
 256 static int max_reg_expire;
 257
 258 static int srvlookup = 0;
 259
 260 static int timingfd = -1;                               /* Timing file descriptor */
 261
 262 static struct ast_netsock_list *netsock;
 263 static struct ast_netsock_list *outsock;                /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
 264 static int defaultsockfd = -1;
 265
 266 int (*iax2_regfunk)(const char *username, int onoff) = NULL;
 267
 268 /* Ethernet, etc */
 269 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
 270 /* T1, maybe ISDN */
 271 #define IAX_CAPABILITY_MEDBANDWIDTH     (IAX_CAPABILITY_FULLBANDWIDTH &         \
 272                                          ~AST_FORMAT_SLINEAR &                  \
 273                                          ~AST_FORMAT_ULAW &                     \
 274                                          ~AST_FORMAT_ALAW &                     \
 275                                          ~AST_FORMAT_G722)
 276 /* A modem */
 277 #define IAX_CAPABILITY_LOWBANDWIDTH     (IAX_CAPABILITY_MEDBANDWIDTH &          \
 278                                          ~AST_FORMAT_G726 &                     \
 279                                          ~AST_FORMAT_G726_AAL2 &                \
 280                                          ~AST_FORMAT_ADPCM)
 281
 282 #define IAX_CAPABILITY_LOWFREE          (IAX_CAPABILITY_LOWBANDWIDTH &          \
 283                                          ~AST_FORMAT_G723_1)
 284
 285
 286 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
 287 #define DEFAULT_FREQ_OK         60 * 1000       /* How often to check for the host to be up */
 288 #define DEFAULT_FREQ_NOTOK      10 * 1000       /* How often to check, if the host is down... */
 289
 290 /* if a pvt has encryption setup done and is running on the call */
 291 #define IAX_CALLENCRYPTED(pvt) \
 292         (ast_test_flag(pvt, IAX_ENCRYPTED) && ast_test_flag(pvt, IAX_KEYPOPULATED))
 293
 294 #define IAX_DEBUGDIGEST(msg, key) do { \
 295                 int idx; \
 296                 char digest[33] = ""; \
 297                 \
 298                 if (!iaxdebug) \
 299                         break; \
 300                 \
 301                 for (idx = 0; idx < 16; idx++) \
 302                         sprintf(digest + (idx << 1), "%2.2x", (unsigned char) key[idx]); \
 303                 \
 304                 ast_log(LOG_NOTICE, msg " IAX_COMMAND_RTKEY to rotate key to '%s'\n", digest); \
 305         } while(0)
 306
 307 static  struct io_context *io;
 308 static  struct ast_sched_thread *sched;
 309
 310 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
 311
 312 static int iaxdebug = 0;
 313
 314 static int iaxtrunkdebug = 0;
 315
 316 static int test_losspct = 0;
 317 #ifdef IAXTESTS
 318 static int test_late = 0;
 319 static int test_resync = 0;
 320 static int test_jit = 0;
 321 static int test_jitpct = 0;
 322 #endif /* IAXTESTS */
 323
 324 static char accountcode[AST_MAX_ACCOUNT_CODE];
 325 static char mohinterpret[MAX_MUSICCLASS];
 326 static char mohsuggest[MAX_MUSICCLASS];
 327 static int amaflags = 0;
 328 static int adsi = 0;
 329 static int delayreject = 0;
 330 static int iax2_encryption = 0;
 331
 332 static struct ast_flags globalflags = { 0 };
 333
 334 static pthread_t netthreadid = AST_PTHREADT_NULL;
 335
 336 enum iax2_state {
 337         IAX_STATE_STARTED =             (1 << 0),
 338         IAX_STATE_AUTHENTICATED =       (1 << 1),
 339         IAX_STATE_TBD =                 (1 << 2),
 340         IAX_STATE_UNCHANGED =           (1 << 3),
 341 };
 342
 343 struct iax2_context {
 344         char context[AST_MAX_CONTEXT];
 345         struct iax2_context *next;
 346 };
 347
 348 enum iax2_flags {
 349         IAX_HASCALLERID =       (1 << 0),       /*!< CallerID has been specified */
 350         IAX_DELME =             (1 << 1),       /*!< Needs to be deleted */
 351         IAX_TEMPONLY =          (1 << 2),       /*!< Temporary (realtime) */
 352         IAX_TRUNK =             (1 << 3),       /*!< Treat as a trunk */
 353         IAX_NOTRANSFER =        (1 << 4),       /*!< Don't native bridge */
 354         IAX_USEJITTERBUF =      (1 << 5),       /*!< Use jitter buffer */
 355         IAX_DYNAMIC =           (1 << 6),       /*!< dynamic peer */
 356         IAX_SENDANI =           (1 << 7),       /*!< Send ANI along with CallerID */
 357         /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
 358         IAX_ALREADYGONE =       (1 << 9),       /*!< Already disconnected */
 359         IAX_PROVISION =         (1 << 10),      /*!< This is a provisioning request */
 360         IAX_QUELCH =            (1 << 11),      /*!< Whether or not we quelch audio */
 361         IAX_ENCRYPTED =         (1 << 12),      /*!< Whether we should assume encrypted tx/rx */
 362         IAX_KEYPOPULATED =      (1 << 13),      /*!< Whether we have a key populated */
 363         IAX_CODEC_USER_FIRST =  (1 << 14),      /*!< are we willing to let the other guy choose the codec? */
 364         IAX_CODEC_NOPREFS =     (1 << 15),      /*!< Force old behaviour by turning off prefs */
 365         IAX_CODEC_NOCAP =       (1 << 16),      /*!< only consider requested format and ignore capabilities*/
 366         IAX_RTCACHEFRIENDS =    (1 << 17),      /*!< let realtime stay till your reload */
 367         IAX_RTUPDATE =          (1 << 18),      /*!< Send a realtime update */
 368         IAX_RTAUTOCLEAR =       (1 << 19),      /*!< erase me on expire */
 369         IAX_FORCEJITTERBUF =    (1 << 20),      /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */
 370         IAX_RTIGNOREREGEXPIRE = (1 << 21),      /*!< When using realtime, ignore registration expiration */
 371         IAX_TRUNKTIMESTAMPS =   (1 << 22),      /*!< Send trunk timestamps */
 372         IAX_TRANSFERMEDIA =     (1 << 23),      /*!< When doing IAX2 transfers, transfer media only */
 373         IAX_MAXAUTHREQ =        (1 << 24),      /*!< Maximum outstanding AUTHREQ restriction is in place */
 374         IAX_DELAYPBXSTART =     (1 << 25),      /*!< Don't start a PBX on the channel until the peer sends us a
 375                                                      response, so that we've achieved a three-way handshake with
 376                                                      them before sending voice or anything else*/
 377         IAX_ALLOWFWDOWNLOAD =   (1 << 26),      /*!< Allow the FWDOWNL command? */
 378         IAX_IMMEDIATE =         (1 << 27),      /*!< Allow immediate off-hook to extension s */
 379         IAX_FORCE_ENCRYPT =     (1 << 28),      /*!< Forces call encryption, if encryption not possible hangup */
 380 };
 381
 382 static int global_rtautoclear = 120;
 383
 384 static int reload_config(void);
 385
 386 struct iax2_user {
 387         AST_DECLARE_STRING_FIELDS(
 388                 AST_STRING_FIELD(name);
 389                 AST_STRING_FIELD(secret);
 390                 AST_STRING_FIELD(dbsecret);
 391                 AST_STRING_FIELD(accountcode);
 392                 AST_STRING_FIELD(mohinterpret);
 393                 AST_STRING_FIELD(mohsuggest);
 394                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this user can use to authenticate to us */
 395                 AST_STRING_FIELD(language);
 396                 AST_STRING_FIELD(cid_num);
 397                 AST_STRING_FIELD(cid_name);
 398                 AST_STRING_FIELD(parkinglot);           /*!< Default parkinglot for device */
 399         );
 400
 401         int authmethods;
 402         int encmethods;
 403         int amaflags;
 404         int adsi;
 405         unsigned int flags;
 406         int capability;
 407         int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
 408         int curauthreq; /*!< Current number of outstanding AUTHREQs */
 409         struct ast_codec_pref prefs;
 410         struct ast_ha *ha;
 411         struct iax2_context *contexts;
 412         struct ast_variable *vars;
 413 };
 414
 415 struct iax2_peer {
 416         AST_DECLARE_STRING_FIELDS(
 417                 AST_STRING_FIELD(name);
 418                 AST_STRING_FIELD(username);
 419                 AST_STRING_FIELD(secret);
 420                 AST_STRING_FIELD(dbsecret);
 421                 AST_STRING_FIELD(outkey);           /*!< What key we use to talk to this peer */
 422
 423                 AST_STRING_FIELD(regexten);     /*!< Extension to register (if regcontext is used) */
 424                 AST_STRING_FIELD(context);      /*!< For transfers only */
 425                 AST_STRING_FIELD(peercontext);  /*!< Context to pass to peer */
 426                 AST_STRING_FIELD(mailbox);          /*!< Mailbox */
 427                 AST_STRING_FIELD(mohinterpret);
 428                 AST_STRING_FIELD(mohsuggest);
 429                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this peer can use to authenticate to us */
 430                 /* Suggested caller id if registering */
 431                 AST_STRING_FIELD(cid_num);              /*!< Default context (for transfer really) */
 432                 AST_STRING_FIELD(cid_name);             /*!< Default context (for transfer really) */
 433                 AST_STRING_FIELD(zonetag);              /*!< Time Zone */
 434                 AST_STRING_FIELD(parkinglot);   /*!< Default parkinglot for device */
 435         );
 436         struct ast_codec_pref prefs;
 437         struct ast_dnsmgr_entry *dnsmgr;                /*!< DNS refresh manager */
 438         struct sockaddr_in addr;
 439         int formats;
 440         int sockfd;                                     /*!< Socket to use for transmission */
 441         struct in_addr mask;
 442         int adsi;
 443         unsigned int flags;
 444
 445         /* Dynamic Registration fields */
 446         struct sockaddr_in defaddr;                     /*!< Default address if there is one */
 447         int authmethods;                                /*!< Authentication methods (IAX_AUTH_*) */
 448         int encmethods;                                 /*!< Encryption methods (IAX_ENCRYPT_*) */
 449
 450         int expire;                                     /*!< Schedule entry for expiry */
 451         int expiry;                                     /*!< How soon to expire */
 452         int capability;                                 /*!< Capability */
 453
 454         /* Qualification */
 455         int callno;                                     /*!< Call number of POKE request */
 456         int pokeexpire;                                 /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
 457         int lastms;                                     /*!< How long last response took (in ms), or -1 for no response */
 458         int maxms;                                      /*!< Max ms we will accept for the host to be up, 0 to not monitor */
 459
 460         int pokefreqok;                                 /*!< How often to check if the host is up */
 461         int pokefreqnotok;                              /*!< How often to check when the host has been determined to be down */
 462         int historicms;                                 /*!< How long recent average responses took */
 463         int smoothing;                                  /*!< Sample over how many units to determine historic ms */
 464
 465         struct ast_event_sub *mwi_event_sub;
 466
 467         struct ast_ha *ha;
 468 };
 469
 470 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
 471
 472 struct iax2_trunk_peer {
 473         ast_mutex_t lock;
 474         int sockfd;
 475         struct sockaddr_in addr;
 476         struct timeval txtrunktime;             /*!< Transmit trunktime */
 477         struct timeval rxtrunktime;             /*!< Receive trunktime */
 478         struct timeval lasttxtime;              /*!< Last transmitted trunktime */
 479         struct timeval trunkact;                /*!< Last trunk activity */
 480         unsigned int lastsent;                  /*!< Last sent time */
 481         /* Trunk data and length */
 482         unsigned char *trunkdata;
 483         unsigned int trunkdatalen;
 484         unsigned int trunkdataalloc;
 485         int trunkmaxmtu;
 486         int trunkerror;
 487         int calls;
 488         AST_LIST_ENTRY(iax2_trunk_peer) list;
 489 };
 490
 491 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
 492
 493 struct iax_firmware {
 494         AST_LIST_ENTRY(iax_firmware) list;
 495         int fd;
 496         int mmaplen;
 497         int dead;
 498         struct ast_iax2_firmware_header *fwh;
 499         unsigned char *buf;
 500 };
 501
 502 enum iax_reg_state {
 503         REG_STATE_UNREGISTERED = 0,
 504         REG_STATE_REGSENT,
 505         REG_STATE_AUTHSENT,
 506         REG_STATE_REGISTERED,
 507         REG_STATE_REJECTED,
 508         REG_STATE_TIMEOUT,
 509         REG_STATE_NOAUTH
 510 };
 511
 512 enum iax_transfer_state {
 513         TRANSFER_NONE = 0,
 514         TRANSFER_BEGIN,
 515         TRANSFER_READY,
 516         TRANSFER_RELEASED,
 517         TRANSFER_PASSTHROUGH,
 518         TRANSFER_MBEGIN,
 519         TRANSFER_MREADY,
 520         TRANSFER_MRELEASED,
 521         TRANSFER_MPASSTHROUGH,
 522         TRANSFER_MEDIA,
 523         TRANSFER_MEDIAPASS
 524 };
 525
 526 struct iax2_registry {
 527         struct sockaddr_in addr;                /*!< Who we connect to for registration purposes */
 528         char username[80];
 529         char secret[80];                        /*!< Password or key name in []'s */
 530         int expire;                             /*!< Sched ID of expiration */
 531         int refresh;                            /*!< How often to refresh */
 532         enum iax_reg_state regstate;
 533         int messages;                           /*!< Message count, low 8 bits = new, high 8 bits = old */
 534         int callno;                             /*!< Associated call number if applicable */
 535         struct sockaddr_in us;                  /*!< Who the server thinks we are */
 536         struct ast_dnsmgr_entry *dnsmgr;        /*!< DNS refresh manager */
 537         AST_LIST_ENTRY(iax2_registry) entry;
 538 };
 539
 540 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
 541
 542 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
 543 #define MIN_RETRY_TIME          100
 544 #define MAX_RETRY_TIME          10000
 545
 546 #define MAX_JITTER_BUFFER       50
 547 #define MIN_JITTER_BUFFER       10
 548
 549 #define DEFAULT_TRUNKDATA       640 * 10        /*!< 40ms, uncompressed linear * 10 channels */
 550
 551 #define MAX_TIMESTAMP_SKEW      160             /*!< maximum difference between actual and predicted ts for sending */
 552
 553 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
 554 #define TS_GAP_FOR_JB_RESYNC    5000
 555
 556 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
 557 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
 558 static int iaxdynamicthreadcount = 0;
 559 static int iaxdynamicthreadnum = 0;
 560 static int iaxactivethreadcount = 0;
 561
 562 struct iax_rr {
 563         int jitter;
 564         int losspct;
 565         int losscnt;
 566         int packets;
 567         int delay;
 568         int dropped;
 569         int ooo;
 570 };
 571
 572 struct iax2_pvt_ref;
 573
 574 struct chan_iax2_pvt {
 575         /*! Socket to send/receive on for this call */
 576         int sockfd;
 577         /*! Last received voice format */
 578         int voiceformat;
 579         /*! Last received video format */
 580         int videoformat;
 581         /*! Last sent voice format */
 582         int svoiceformat;
 583         /*! Last sent video format */
 584         int svideoformat;
 585         /*! What we are capable of sending */
 586         int capability;
 587         /*! Last received timestamp */
 588         unsigned int last;
 589         /*! Last sent timestamp - never send the same timestamp twice in a single call */
 590         unsigned int lastsent;
 591         /*! Timestamp of the last video frame sent */
 592         unsigned int lastvsent;
 593         /*! Next outgoing timestamp if everything is good */
 594         unsigned int nextpred;
 595         /*! True if the last voice we transmitted was not silence/CNG */
 596         unsigned int notsilenttx:1;
 597         /*! Ping time */
 598         unsigned int pingtime;
 599         /*! Max time for initial response */
 600         int maxtime;
 601         /*! Peer Address */
 602         struct sockaddr_in addr;
 603         /*! Actual used codec preferences */
 604         struct ast_codec_pref prefs;
 605         /*! Requested codec preferences */
 606         struct ast_codec_pref rprefs;
 607         /*! Our call number */
 608         unsigned short callno;
 609         /*! Peer callno */
 610         unsigned short peercallno;
 611         /*! Negotiated format, this is only used to remember what format was
 612             chosen for an unauthenticated call so that the channel can get
 613             created later using the right format */
 614         int chosenformat;
 615         /*! Peer selected format */
 616         int peerformat;
 617         /*! Peer capability */
 618         int peercapability;
 619         /*! timeval that we base our transmission on */
 620         struct timeval offset;
 621         /*! timeval that we base our delivery on */
 622         struct timeval rxcore;
 623         /*! The jitterbuffer */
 624         jitterbuf *jb;
 625         /*! active jb read scheduler id */
 626         int jbid;
 627         /*! LAG */
 628         int lag;
 629         /*! Error, as discovered by the manager */
 630         int error;
 631         /*! Owner if we have one */
 632         struct ast_channel *owner;
 633         /*! What's our state? */
 634         struct ast_flags state;
 635         /*! Expiry (optional) */
 636         int expiry;
 637         /*! Next outgoing sequence number */
 638         unsigned char oseqno;
 639         /*! Next sequence number they have not yet acknowledged */
 640         unsigned char rseqno;
 641         /*! Next incoming sequence number */
 642         unsigned char iseqno;
 643         /*! Last incoming sequence number we have acknowledged */
 644         unsigned char aseqno;
 645
 646         AST_DECLARE_STRING_FIELDS(
 647                 /*! Peer name */
 648                 AST_STRING_FIELD(peer);
 649                 /*! Default Context */
 650                 AST_STRING_FIELD(context);
 651                 /*! Caller ID if available */
 652                 AST_STRING_FIELD(cid_num);
 653                 AST_STRING_FIELD(cid_name);
 654                 /*! Hidden Caller ID (i.e. ANI) if appropriate */
 655                 AST_STRING_FIELD(ani);
 656                 /*! DNID */
 657                 AST_STRING_FIELD(dnid);
 658                 /*! RDNIS */
 659                 AST_STRING_FIELD(rdnis);
 660                 /*! Requested Extension */
 661                 AST_STRING_FIELD(exten);
 662                 /*! Expected Username */
 663                 AST_STRING_FIELD(username);
 664                 /*! Expected Secret */
 665                 AST_STRING_FIELD(secret);
 666                 /*! MD5 challenge */
 667                 AST_STRING_FIELD(challenge);
 668                 /*! Public keys permitted keys for incoming authentication */
 669                 AST_STRING_FIELD(inkeys);
 670                 /*! Private key for outgoing authentication */
 671                 AST_STRING_FIELD(outkey);
 672                 /*! Preferred language */
 673                 AST_STRING_FIELD(language);
 674                 /*! Hostname/peername for naming purposes */
 675                 AST_STRING_FIELD(host);
 676
 677                 AST_STRING_FIELD(dproot);
 678                 AST_STRING_FIELD(accountcode);
 679                 AST_STRING_FIELD(mohinterpret);
 680                 AST_STRING_FIELD(mohsuggest);
 681                 /*! received OSP token */
 682                 AST_STRING_FIELD(osptoken);
 683                 /*! Default parkinglot */
 684                 AST_STRING_FIELD(parkinglot);
 685         );
 686
 687         /*! permitted authentication methods */
 688         int authmethods;
 689         /*! permitted encryption methods */
 690         int encmethods;
 691         /*! Encryption AES-128 Key */
 692         ast_aes_encrypt_key ecx;
 693         /*! Decryption AES-128 Key corresponding to ecx */
 694         ast_aes_decrypt_key mydcx;
 695         /*! Decryption AES-128 Key used to decrypt peer frames */
 696         ast_aes_decrypt_key dcx;
 697         /*! scheduler id associated with iax_key_rotate
 698          * for encrypted calls*/
 699         int keyrotateid;
 700         /*! 32 bytes of semi-random data */
 701         unsigned char semirand[32];
 702         /*! Associated registry */
 703         struct iax2_registry *reg;
 704         /*! Associated peer for poking */
 705         struct iax2_peer *peerpoke;
 706         /*! IAX_ flags */
 707         unsigned int flags;
 708         int adsi;
 709
 710         /*! Transferring status */
 711         enum iax_transfer_state transferring;
 712         /*! Transfer identifier */
 713         int transferid;
 714         /*! Who we are IAX transferring to */
 715         struct sockaddr_in transfer;
 716         /*! What's the new call number for the transfer */
 717         unsigned short transfercallno;
 718         /*! Transfer encrypt AES-128 Key */
 719         ast_aes_encrypt_key tdcx;
 720
 721         /*! Status of knowledge of peer ADSI capability */
 722         int peeradsicpe;
 723
 724         /*! Who we are bridged to */
 725         unsigned short bridgecallno;
 726
 727         int pingid;                     /*!< Transmit PING request */
 728         int lagid;                      /*!< Retransmit lag request */
 729         int autoid;                     /*!< Auto hangup for Dialplan requestor */
 730         int authid;                     /*!< Authentication rejection ID */
 731         int authfail;                   /*!< Reason to report failure */
 732         int initid;                     /*!< Initial peer auto-congest ID (based on qualified peers) */
 733         int calling_ton;
 734         int calling_tns;
 735         int calling_pres;
 736         int amaflags;
 737         AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
 738         /*! variables inherited from the user definition */
 739         struct ast_variable *vars;
 740         /*! variables transmitted in a NEW packet */
 741         struct ast_variable *iaxvars;
 742         /*! last received remote rr */
 743         struct iax_rr remote_rr;
 744         /*! Current base time: (just for stats) */
 745         int min;
 746         /*! Dropped frame count: (just for stats) */
 747         int frames_dropped;
 748         /*! received frame count: (just for stats) */
 749         int frames_received;
 750 };
 751
 752 /*!
 753  * \brief a list of frames that may need to be retransmitted
 754  *
 755  * \note The contents of this list do not need to be explicitly destroyed
 756  * on module unload.  This is because all active calls are destroyed, and
 757  * all frames in this queue will get destroyed as a part of that process.
 758  */
 759 static AST_LIST_HEAD_STATIC(frame_queue, iax_frame);
 760
 761 /*!
 762  * This module will get much higher performance when doing a lot of
 763  * user and peer lookups if the number of buckets is increased from 1.
 764  * However, to maintain old behavior for Asterisk 1.4, these are set to
 765  * 1 by default.  When using multiple buckets, search order through these
 766  * containers is considered random, so you will not be able to depend on
 767  * the order the entires are specified in iax.conf for matching order. */
 768 #ifdef LOW_MEMORY
 769 #define MAX_PEER_BUCKETS 17
 770 #else
 771 #define MAX_PEER_BUCKETS 563
 772 #endif
 773 static struct ao2_container *peers;
 774
 775 #define MAX_USER_BUCKETS MAX_PEER_BUCKETS
 776 static struct ao2_container *users;
 777
 778 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
 779
 780 enum {
 781         /*! Extension exists */
 782         CACHE_FLAG_EXISTS      = (1 << 0),
 783         /*! Extension is nonexistent */
 784         CACHE_FLAG_NONEXISTENT = (1 << 1),
 785         /*! Extension can exist */
 786         CACHE_FLAG_CANEXIST    = (1 << 2),
 787         /*! Waiting to hear back response */
 788         CACHE_FLAG_PENDING     = (1 << 3),
 789         /*! Timed out */
 790         CACHE_FLAG_TIMEOUT     = (1 << 4),
 791         /*! Request transmitted */
 792         CACHE_FLAG_TRANSMITTED = (1 << 5),
 793         /*! Timeout */
 794         CACHE_FLAG_UNKNOWN     = (1 << 6),
 795         /*! Matchmore */
 796         CACHE_FLAG_MATCHMORE   = (1 << 7),
 797 };
 798
 799 struct iax2_dpcache {
 800         char peercontext[AST_MAX_CONTEXT];
 801         char exten[AST_MAX_EXTENSION];
 802         struct timeval orig;
 803         struct timeval expiry;
 804         int flags;
 805         unsigned short callno;
 806         int waiters[256];
 807         AST_LIST_ENTRY(iax2_dpcache) cache_list;
 808         AST_LIST_ENTRY(iax2_dpcache) peer_list;
 809 };
 810
 811 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
 812
 813 static void reg_source_db(struct iax2_peer *p);
 814 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
 815
 816 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
 817 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, int flags);
 818 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
 819
 820 enum iax2_thread_iostate {
 821         IAX_IOSTATE_IDLE,
 822         IAX_IOSTATE_READY,
 823         IAX_IOSTATE_PROCESSING,
 824         IAX_IOSTATE_SCHEDREADY,
 825 };
 826
 827 enum iax2_thread_type {
 828         IAX_THREAD_TYPE_POOL,
 829         IAX_THREAD_TYPE_DYNAMIC,
 830 };
 831
 832 struct iax2_pkt_buf {
 833         AST_LIST_ENTRY(iax2_pkt_buf) entry;
 834         size_t len;
 835         unsigned char buf[1];
 836 };
 837
 838 struct iax2_thread {
 839         AST_LIST_ENTRY(iax2_thread) list;
 840         enum iax2_thread_type type;
 841         enum iax2_thread_iostate iostate;
 842 #ifdef SCHED_MULTITHREADED
 843         void (*schedfunc)(const void *);
 844         const void *scheddata;
 845 #endif
 846 #ifdef DEBUG_SCHED_MULTITHREAD
 847         char curfunc[80];
 848 #endif
 849         int actions;
 850         pthread_t threadid;
 851         int threadnum;
 852         struct sockaddr_in iosin;
 853         unsigned char readbuf[4096];
 854         unsigned char *buf;
 855         ssize_t buf_len;
 856         size_t buf_size;
 857         int iofd;
 858         time_t checktime;
 859         ast_mutex_t lock;
 860         ast_cond_t cond;
 861         ast_mutex_t init_lock;
 862         ast_cond_t init_cond;
 863         /*! if this thread is processing a full frame,
 864           some information about that frame will be stored
 865           here, so we can avoid dispatching any more full
 866           frames for that callno to other threads */
 867         struct {
 868                 unsigned short callno;
 869                 struct sockaddr_in sin;
 870                 unsigned char type;
 871                 unsigned char csub;
 872         } ffinfo;
 873         /*! Queued up full frames for processing.  If more full frames arrive for
 874          *  a call which this thread is already processing a full frame for, they
 875          *  are queued up here. */
 876         AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
 877 };
 878
 879 /* Thread lists */
 880 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
 881 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
 882 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
 883
 884 static void *iax2_process_thread(void *data);
 885 static void iax2_destroy(int callno);
 886
 887 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
 888 {
 889         ast_mutex_lock(lock);
 890         ast_cond_signal(cond);
 891         ast_mutex_unlock(lock);
 892 }
 893
 894 /*!
 895  * \brief an array of iax2 pvt structures
 896  *
 897  * The container for active chan_iax2_pvt structures is implemented as an
 898  * array for extremely quick direct access to the correct pvt structure
 899  * based on the local call number.  The local call number is used as the
 900  * index into the array where the associated pvt structure is stored.
 901  */
 902 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
 903
 904 /*!
 905  * \brief Another container of iax2_pvt structures
 906  *
 907  * Active IAX2 pvt structs are also stored in this container, if they are a part
 908  * of an active call where we know the remote side's call number.  The reason
 909  * for this is that incoming media frames do not contain our call number.  So,
 910  * instead of having to iterate the entire iaxs array, we use this container to
 911  * look up calls where the remote side is using a given call number.
 912  */
 913 static struct ao2_container *iax_peercallno_pvts;
 914
 915 /*!
 916  * \brief chan_iax2_pvt structure locks
 917  *
 918  * These locks are used when accessing a pvt structure in the iaxs array.
 919  * The index used here is the same as used in the iaxs array.  It is the
 920  * local call number for the associated pvt struct.
 921  */
 922 static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)];
 923
 924 /*!
 925  * \brief The last time a call number was used
 926  *
 927  * It is important to know the last time that a call number was used locally so
 928  * that it is not used again too soon.  The reason for this is the same as the
 929  * reason that the TCP protocol state machine requires a "TIME WAIT" state.
 930  *
 931  * For example, say that a call is up.  Then, the remote side sends a HANGUP,
 932  * which we respond to with an ACK.  However, there is no way to know whether
 933  * the ACK made it there successfully.  If it were to get lost, the remote
 934  * side may retransmit the HANGUP.  If in the meantime, this call number has
 935  * been reused locally, given the right set of circumstances, this retransmitted
 936  * HANGUP could potentially improperly hang up the new session.  So, to avoid
 937  * this potential issue, we must wait a specified timeout period before reusing
 938  * a local call number.
 939  *
 940  * The specified time that we must wait before reusing a local call number is
 941  * defined as MIN_REUSE_TIME, with a default of 60 seconds.
 942  */
 943 static struct timeval lastused[ARRAY_LEN(iaxs)];
 944
 945 /*!
 946  *  * \brief Another container of iax2_pvt structures
 947  *
 948  *  Active IAX2 pvt stucts used during transfering a call are stored here.
 949  */
 950 static struct ao2_container *iax_transfercallno_pvts;
 951
 952 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
 953    but keeps the division between trunked and non-trunked better. */
 954 #define TRUNK_CALL_START        ARRAY_LEN(iaxs) / 2
 955
 956 /* Debug routines... */
 957 static struct sockaddr_in debugaddr;
 958
 959 static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen)
 960 {
 961         if (iaxdebug ||
 962             (sin && debugaddr.sin_addr.s_addr &&
 963              (!ntohs(debugaddr.sin_port) ||
 964               debugaddr.sin_port == sin->sin_port) &&
 965              debugaddr.sin_addr.s_addr == sin->sin_addr.s_addr)) {
 966                 if (iaxdebug) {
 967                         iax_showframe(f, fhi, rx, sin, datalen);
 968                 } else {
 969                         iaxdebug = 1;
 970                         iax_showframe(f, fhi, rx, sin, datalen);
 971                         iaxdebug = 0;
 972                 }
 973         }
 974 }
 975
 976 static void iax_debug_output(const char *data)
 977 {
 978         if (iaxdebug)
 979                 ast_verbose("%s", data);
 980 }
 981
 982 static void iax_error_output(const char *data)
 983 {
 984         ast_log(LOG_WARNING, "%s", data);
 985 }
 986
 987 static void __attribute__((format(printf, 1, 2))) jb_error_output(const char *fmt, ...)
 988 {
 989         va_list args;
 990         char buf[1024];
 991
 992         va_start(args, fmt);
 993         vsnprintf(buf, sizeof(buf), fmt, args);
 994         va_end(args);
 995
 996         ast_log(LOG_ERROR, "%s", buf);
 997 }
 998
 999 static void __attribute__((format(printf, 1, 2))) jb_warning_output(const char *fmt, ...)
1000 {
1001         va_list args;
1002         char buf[1024];
1003
1004         va_start(args, fmt);
1005         vsnprintf(buf, sizeof(buf), fmt, args);
1006         va_end(args);
1007
1008         ast_log(LOG_WARNING, "%s", buf);
1009 }
1010
1011 static void __attribute__((format(printf, 1, 2))) jb_debug_output(const char *fmt, ...)
1012 {
1013         va_list args;
1014         char buf[1024];
1015
1016         va_start(args, fmt);
1017         vsnprintf(buf, sizeof(buf), fmt, args);
1018         va_end(args);
1019
1020         ast_verbose("%s", buf);
1021 }
1022
1023 static int maxtrunkcall = TRUNK_CALL_START;
1024 static int maxnontrunkcall = 1;
1025
1026 static 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);
1027 static int expire_registry(const void *data);
1028 static int iax2_answer(struct ast_channel *c);
1029 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
1030 static int iax2_devicestate(void *data);
1031 static int iax2_digit_begin(struct ast_channel *c, char digit);
1032 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
1033 static int iax2_do_register(struct iax2_registry *reg);
1034 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
1035 static int iax2_hangup(struct ast_channel *c);
1036 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
1037 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
1038 static int iax2_provision(struct sockaddr_in *end, int sockfd, char *dest, const char *template, int force);
1039 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1040 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
1041 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
1042 static int iax2_sendtext(struct ast_channel *c, const char *text);
1043 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
1044 static int iax2_transfer(struct ast_channel *c, const char *dest);
1045 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
1046 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
1047 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1048 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1049 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1050 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
1051 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
1052 static struct ast_channel *iax2_request(const char *type, int format, void *data, int *cause);
1053 static struct ast_frame *iax2_read(struct ast_channel *c);
1054 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1055 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1056 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
1057 static void *iax2_dup_variable_datastore(void *);
1058 static void prune_peers(void);
1059 static void prune_users(void);
1060 static void iax2_free_variable_datastore(void *);
1061
1062 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
1063 static int acf_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value);
1064 static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen);
1065 static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen);
1066 static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt);
1067
1068 static const struct ast_channel_tech iax2_tech = {
1069         .type = "IAX2",
1070         .description = tdesc,
1071         .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
1072         .properties = AST_CHAN_TP_WANTSJITTER,
1073         .requester = iax2_request,
1074         .devicestate = iax2_devicestate,
1075         .send_digit_begin = iax2_digit_begin,
1076         .send_digit_end = iax2_digit_end,
1077         .send_text = iax2_sendtext,
1078         .send_image = iax2_sendimage,
1079         .send_html = iax2_sendhtml,
1080         .call = iax2_call,
1081         .hangup = iax2_hangup,
1082         .answer = iax2_answer,
1083         .read = iax2_read,
1084         .write = iax2_write,
1085         .write_video = iax2_write,
1086         .indicate = iax2_indicate,
1087         .setoption = iax2_setoption,
1088         .bridge = iax2_bridge,
1089         .transfer = iax2_transfer,
1090         .fixup = iax2_fixup,
1091         .func_channel_read = acf_channel_read,
1092         .func_channel_write = acf_channel_write,
1093 };
1094
1095 static void mwi_event_cb(const struct ast_event *event, void *userdata)
1096 {
1097         /* The MWI subscriptions exist just so the core knows we care about those
1098          * mailboxes.  However, we just grab the events out of the cache when it
1099          * is time to send MWI, since it is only sent with a REGACK. */
1100 }
1101
1102 /*! \brief Send manager event at call setup to link between Asterisk channel name
1103         and IAX2 call identifiers */
1104 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt)
1105 {
1106         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
1107                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
1108                 pvt->owner ? pvt->owner->name : "",
1109                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
1110 }
1111
1112
1113 static struct ast_datastore_info iax2_variable_datastore_info = {
1114         .type = "IAX2_VARIABLE",
1115         .duplicate = iax2_dup_variable_datastore,
1116         .destroy = iax2_free_variable_datastore,
1117 };
1118
1119 static void *iax2_dup_variable_datastore(void *old)
1120 {
1121         AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1122         struct ast_var_t *oldvar, *newvar;
1123
1124         newlist = ast_calloc(sizeof(*newlist), 1);
1125         if (!newlist) {
1126                 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1127                 return NULL;
1128         }
1129
1130         AST_LIST_HEAD_INIT(newlist);
1131         AST_LIST_LOCK(oldlist);
1132         AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1133                 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1134                 if (newvar)
1135                         AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1136                 else
1137                         ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1138         }
1139         AST_LIST_UNLOCK(oldlist);
1140         return newlist;
1141 }
1142
1143 static void iax2_free_variable_datastore(void *old)
1144 {
1145         AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1146         struct ast_var_t *oldvar;
1147
1148         AST_LIST_LOCK(oldlist);
1149         while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1150                 ast_free(oldvar);
1151         }
1152         AST_LIST_UNLOCK(oldlist);
1153         AST_LIST_HEAD_DESTROY(oldlist);
1154         ast_free(oldlist);
1155 }
1156
1157
1158 /* WARNING: insert_idle_thread should only ever be called within the
1159  * context of an iax2_process_thread() thread.
1160  */
1161 static void insert_idle_thread(struct iax2_thread *thread)
1162 {
1163         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1164                 AST_LIST_LOCK(&dynamic_list);
1165                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1166                 AST_LIST_UNLOCK(&dynamic_list);
1167         } else {
1168                 AST_LIST_LOCK(&idle_list);
1169                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1170                 AST_LIST_UNLOCK(&idle_list);
1171         }
1172
1173         return;
1174 }
1175
1176 static struct iax2_thread *find_idle_thread(void)
1177 {
1178         struct iax2_thread *thread = NULL;
1179
1180         /* Pop the head of the idle list off */
1181         AST_LIST_LOCK(&idle_list);
1182         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1183         AST_LIST_UNLOCK(&idle_list);
1184
1185         /* If we popped a thread off the idle list, just return it */
1186         if (thread) {
1187                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1188                 return thread;
1189         }
1190
1191         /* Pop the head of the dynamic list off */
1192         AST_LIST_LOCK(&dynamic_list);
1193         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1194         AST_LIST_UNLOCK(&dynamic_list);
1195
1196         /* If we popped a thread off the dynamic list, just return it */
1197         if (thread) {
1198                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1199                 return thread;
1200         }
1201
1202         /* If we can't create a new dynamic thread for any reason, return no thread at all */
1203         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1204                 return NULL;
1205
1206         /* Set default values */
1207         ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1208         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1209         thread->type = IAX_THREAD_TYPE_DYNAMIC;
1210
1211         /* Initialize lock and condition */
1212         ast_mutex_init(&thread->lock);
1213         ast_cond_init(&thread->cond, NULL);
1214         ast_mutex_init(&thread->init_lock);
1215         ast_cond_init(&thread->init_cond, NULL);
1216         ast_mutex_lock(&thread->init_lock);
1217
1218         /* Create thread and send it on it's way */
1219         if (ast_pthread_create_detached_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1220                 ast_cond_destroy(&thread->cond);
1221                 ast_mutex_destroy(&thread->lock);
1222                 ast_free(thread);
1223                 return NULL;
1224         }
1225
1226         /* this thread is not processing a full frame (since it is idle),
1227            so ensure that the field for the full frame call number is empty */
1228         memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1229
1230         /* Wait for the thread to be ready before returning it to the caller */
1231         ast_cond_wait(&thread->init_cond, &thread->init_lock);
1232
1233         /* Done with init_lock */
1234         ast_mutex_unlock(&thread->init_lock);
1235
1236         return thread;
1237 }
1238
1239 #ifdef SCHED_MULTITHREADED
1240 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1241 {
1242         struct iax2_thread *thread = NULL;
1243         static time_t lasterror;
1244         static time_t t;
1245
1246         thread = find_idle_thread();
1247
1248         if (thread != NULL) {
1249                 thread->schedfunc = func;
1250                 thread->scheddata = data;
1251                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1252 #ifdef DEBUG_SCHED_MULTITHREAD
1253                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1254 #endif
1255                 signal_condition(&thread->lock, &thread->cond);
1256                 return 0;
1257         }
1258         time(&t);
1259         if (t != lasterror)
1260                 ast_debug(1, "Out of idle IAX2 threads for scheduling!\n");
1261         lasterror = t;
1262
1263         return -1;
1264 }
1265 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1266 #endif
1267
1268 static int iax2_sched_replace(int id, struct ast_sched_thread *st, int when,
1269                 ast_sched_cb callback, const void *data)
1270 {
1271         ast_sched_thread_del(st, id);
1272
1273         return ast_sched_thread_add(st, when, callback, data);
1274 }
1275
1276 static int iax2_sched_add(struct ast_sched_thread *st, int when,
1277                 ast_sched_cb callback, const void *data)
1278 {
1279         return ast_sched_thread_add(st, when, callback, data);
1280 }
1281
1282 static int send_ping(const void *data);
1283
1284 static void __send_ping(const void *data)
1285 {
1286         int callno = (long) data;
1287
1288         ast_mutex_lock(&iaxsl[callno]);
1289
1290         if (iaxs[callno]) {
1291                 if (iaxs[callno]->peercallno) {
1292                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1293                         iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1294                 } else {
1295                         /* I am the schedule, so I'm allowed to do this */
1296                         iaxs[callno]->pingid = -1;
1297                 }
1298         } else if (option_debug > 0) {
1299                 ast_log(LOG_DEBUG, "I was supposed to send a PING with callno %d, but no such call exists (and I cannot remove pingid, either).\n", callno);
1300         }
1301
1302         ast_mutex_unlock(&iaxsl[callno]);
1303 }
1304
1305 static int send_ping(const void *data)
1306 {
1307 #ifdef SCHED_MULTITHREADED
1308         if (schedule_action(__send_ping, data))
1309 #endif
1310                 __send_ping(data);
1311
1312         return 0;
1313 }
1314
1315 static void encmethods_to_str(int e, struct ast_str *buf)
1316 {
1317         ast_str_set(&buf, 0, "(");
1318         if (e & IAX_ENCRYPT_AES128) {
1319                 ast_str_append(&buf, 0, "aes128");
1320         }
1321         if (e & IAX_ENCRYPT_KEYROTATE) {
1322                 ast_str_append(&buf, 0, ",keyrotate");
1323         }
1324         if (ast_str_strlen(buf) > 1) {
1325                 ast_str_append(&buf, 0, ")");
1326         } else {
1327                 ast_str_set(&buf, 0, "No");
1328         }
1329 }
1330
1331 static int get_encrypt_methods(const char *s)
1332 {
1333         int e;
1334         if (!strcasecmp(s, "aes128"))
1335                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1336         else if (ast_true(s))
1337                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1338         else
1339                 e = 0;
1340         return e;
1341 }
1342
1343 static int send_lagrq(const void *data);
1344
1345 static void __send_lagrq(const void *data)
1346 {
1347         int callno = (long) data;
1348
1349         ast_mutex_lock(&iaxsl[callno]);
1350
1351         if (iaxs[callno]) {
1352                 if (iaxs[callno]->peercallno) {
1353                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1354                         iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1355                 } else {
1356                         /* I am the schedule, so I'm allowed to do this */
1357                         iaxs[callno]->lagid = -1;
1358                 }
1359         } else {
1360                 ast_log(LOG_WARNING, "I was supposed to send a LAGRQ with callno %d, but no such call exists (and I cannot remove lagid, either).\n", callno);
1361         }
1362
1363         ast_mutex_unlock(&iaxsl[callno]);
1364 }
1365
1366 static int send_lagrq(const void *data)
1367 {
1368 #ifdef SCHED_MULTITHREADED
1369         if (schedule_action(__send_lagrq, data))
1370 #endif
1371                 __send_lagrq(data);
1372
1373         return 0;
1374 }
1375
1376 static unsigned char compress_subclass(int subclass)
1377 {
1378         int x;
1379         int power=-1;
1380         /* If it's 128 or smaller, just return it */
1381         if (subclass < IAX_FLAG_SC_LOG)
1382                 return subclass;
1383         /* Otherwise find its power */
1384         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1385                 if (subclass & (1 << x)) {
1386                         if (power > -1) {
1387                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1388                                 return 0;
1389                         } else
1390                                 power = x;
1391                 }
1392         }
1393         return power | IAX_FLAG_SC_LOG;
1394 }
1395
1396 static int uncompress_subclass(unsigned char csub)
1397 {
1398         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1399         if (csub & IAX_FLAG_SC_LOG) {
1400                 /* special case for 'compressed' -1 */
1401                 if (csub == 0xff)
1402                         return -1;
1403                 else
1404                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1405         }
1406         else
1407                 return csub;
1408 }
1409
1410 /*!
1411  * \note The only member of the peer passed here guaranteed to be set is the name field
1412  */
1413 static int peer_hash_cb(const void *obj, const int flags)
1414 {
1415         const struct iax2_peer *peer = obj;
1416
1417         return ast_str_hash(peer->name);
1418 }
1419
1420 /*!
1421  * \note The only member of the peer passed here guaranteed to be set is the name field
1422  */
1423 static int peer_cmp_cb(void *obj, void *arg, int flags)
1424 {
1425         struct iax2_peer *peer = obj, *peer2 = arg;
1426
1427         return !strcmp(peer->name, peer2->name) ? CMP_MATCH | CMP_STOP : 0;
1428 }
1429
1430 /*!
1431  * \note The only member of the user passed here guaranteed to be set is the name field
1432  */
1433 static int user_hash_cb(const void *obj, const int flags)
1434 {
1435         const struct iax2_user *user = obj;
1436
1437         return ast_str_hash(user->name);
1438 }
1439
1440 /*!
1441  * \note The only member of the user passed here guaranteed to be set is the name field
1442  */
1443 static int user_cmp_cb(void *obj, void *arg, int flags)
1444 {
1445         struct iax2_user *user = obj, *user2 = arg;
1446
1447         return !strcmp(user->name, user2->name) ? CMP_MATCH | CMP_STOP : 0;
1448 }
1449
1450 /*!
1451  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
1452  *       so do not call it with a pvt lock held.
1453  */
1454 static struct iax2_peer *find_peer(const char *name, int realtime)
1455 {
1456         struct iax2_peer *peer = NULL;
1457         struct iax2_peer tmp_peer = {
1458                 .name = name,
1459         };
1460
1461         peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
1462
1463         /* Now go for realtime if applicable */
1464         if(!peer && realtime)
1465                 peer = realtime_peer(name, NULL);
1466
1467         return peer;
1468 }
1469
1470 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
1471 {
1472         ao2_ref(peer, +1);
1473         return peer;
1474 }
1475
1476 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
1477 {
1478         ao2_ref(peer, -1);
1479         return NULL;
1480 }
1481
1482 static struct iax2_user *find_user(const char *name)
1483 {
1484         struct iax2_user tmp_user = {
1485                 .name = name,
1486         };
1487
1488         return ao2_find(users, &tmp_user, OBJ_POINTER);
1489 }
1490 static inline struct iax2_user *user_ref(struct iax2_user *user)
1491 {
1492         ao2_ref(user, +1);
1493         return user;
1494 }
1495
1496 static inline struct iax2_user *user_unref(struct iax2_user *user)
1497 {
1498         ao2_ref(user, -1);
1499         return NULL;
1500 }
1501
1502 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
1503 {
1504         struct iax2_peer *peer = NULL;
1505         int res = 0;
1506         struct ao2_iterator i;
1507
1508         i = ao2_iterator_init(peers, 0);
1509         while ((peer = ao2_iterator_next(&i))) {
1510                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1511                     (peer->addr.sin_port == sin.sin_port)) {
1512                         ast_copy_string(host, peer->name, len);
1513                         peer_unref(peer);
1514                         res = 1;
1515                         break;
1516                 }
1517                 peer_unref(peer);
1518         }
1519
1520         if (!peer) {
1521                 peer = realtime_peer(NULL, &sin);
1522                 if (peer) {
1523                         ast_copy_string(host, peer->name, len);
1524                         peer_unref(peer);
1525                         res = 1;
1526                 }
1527         }
1528
1529         return res;
1530 }
1531
1532 /*!\note Assumes the lock on the pvt is already held, when
1533  * iax2_destroy_helper() is called. */
1534 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1535 {
1536         /* Decrement AUTHREQ count if needed */
1537         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1538                 struct iax2_user *user;
1539                 struct iax2_user tmp_user = {
1540                         .name = pvt->username,
1541                 };
1542
1543                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
1544                 if (user) {
1545                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
1546                         user_unref(user);
1547                 }
1548
1549                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1550         }
1551         /* No more pings or lagrq's */
1552         AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->pingid, &iaxsl[pvt->callno]);
1553         AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->lagid, &iaxsl[pvt->callno]);
1554         ast_sched_thread_del(sched, pvt->autoid);
1555         ast_sched_thread_del(sched, pvt->authid);
1556         ast_sched_thread_del(sched, pvt->initid);
1557         ast_sched_thread_del(sched, pvt->jbid);
1558         ast_sched_thread_del(sched, pvt->keyrotateid);
1559 }
1560
1561 static void iax2_frame_free(struct iax_frame *fr)
1562 {
1563         ast_sched_thread_del(sched, fr->retrans);
1564         iax_frame_free(fr);
1565 }
1566
1567 static int scheduled_destroy(const void *vid)
1568 {
1569         short callno = PTR_TO_CALLNO(vid);
1570         ast_mutex_lock(&iaxsl[callno]);
1571         if (iaxs[callno]) {
1572                 if (option_debug) {
1573                         ast_log(LOG_DEBUG, "Really destroying %d now...\n", callno);
1574                 }
1575                 iax2_destroy(callno);
1576         }
1577         ast_mutex_unlock(&iaxsl[callno]);
1578         return 0;
1579 }
1580
1581 static void pvt_destructor(void *obj)
1582 {
1583         struct chan_iax2_pvt *pvt = obj;
1584         struct iax_frame *cur = NULL;
1585
1586         ast_mutex_lock(&iaxsl[pvt->callno]);
1587         iax2_destroy_helper(pvt);
1588         ast_mutex_unlock(&iaxsl[pvt->callno]);
1589
1590         /* Already gone */
1591         ast_set_flag(pvt, IAX_ALREADYGONE);
1592
1593         AST_LIST_LOCK(&frame_queue);
1594         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
1595                 /* Cancel any pending transmissions */
1596                 if (cur->callno == pvt->callno) {
1597                         cur->retries = -1;
1598                 }
1599         }
1600         AST_LIST_UNLOCK(&frame_queue);
1601
1602         if (pvt->reg) {
1603                 pvt->reg->callno = 0;
1604         }
1605
1606         if (!pvt->owner) {
1607                 jb_frame frame;
1608                 if (pvt->vars) {
1609                     ast_variables_destroy(pvt->vars);
1610                     pvt->vars = NULL;
1611                 }
1612
1613                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
1614                         iax2_frame_free(frame.data);
1615                 }
1616
1617                 jb_destroy(pvt->jb);
1618                 ast_string_field_free_memory(pvt);
1619         }
1620 }
1621
1622 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1623 {
1624         struct chan_iax2_pvt *tmp;
1625         jb_conf jbconf;
1626
1627         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
1628                 return NULL;
1629         }
1630
1631         if (ast_string_field_init(tmp, 32)) {
1632                 ao2_ref(tmp, -1);
1633                 tmp = NULL;
1634                 return NULL;
1635         }
1636
1637         tmp->prefs = prefs;
1638         tmp->pingid = -1;
1639         tmp->lagid = -1;
1640         tmp->autoid = -1;
1641         tmp->authid = -1;
1642         tmp->initid = -1;
1643         tmp->keyrotateid = -1;
1644
1645         ast_string_field_set(tmp,exten, "s");
1646         ast_string_field_set(tmp,host, host);
1647
1648         tmp->jb = jb_new();
1649         tmp->jbid = -1;
1650         jbconf.max_jitterbuf = maxjitterbuffer;
1651         jbconf.resync_threshold = resyncthreshold;
1652         jbconf.max_contig_interp = maxjitterinterps;
1653         jbconf.target_extra = jittertargetextra;
1654         jb_setconf(tmp->jb,&jbconf);
1655
1656         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1657
1658         return tmp;
1659 }
1660
1661 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1662 {
1663         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1664         if (new) {
1665                 size_t afdatalen = new->afdatalen;
1666                 memcpy(new, fr, sizeof(*new));
1667                 iax_frame_wrap(new, &fr->af);
1668                 new->afdatalen = afdatalen;
1669                 new->data = NULL;
1670                 new->datalen = 0;
1671                 new->direction = DIRECTION_INGRESS;
1672                 new->retrans = -1;
1673         }
1674         return new;
1675 }
1676
1677 #define NEW_PREVENT     0
1678 #define NEW_ALLOW       1
1679 #define NEW_FORCE       2
1680
1681 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
1682 {
1683         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1684                 (cur->addr.sin_port == sin->sin_port)) {
1685                 /* This is the main host */
1686                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
1687                          (check_dcallno ? dcallno == cur->callno : 1) ) {
1688                         /* That's us.  Be sure we keep track of the peer call number */
1689                         return 1;
1690                 }
1691         }
1692         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1693             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1694                 /* We're transferring */
1695                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1696                         return 1;
1697         }
1698         return 0;
1699 }
1700
1701 static void update_max_trunk(void)
1702 {
1703         int max = TRUNK_CALL_START;
1704         int x;
1705
1706         /* XXX Prolly don't need locks here XXX */
1707         for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
1708                 if (iaxs[x]) {
1709                         max = x + 1;
1710                 }
1711         }
1712
1713         maxtrunkcall = max;
1714         if (iaxdebug)
1715                 ast_debug(1, "New max trunk callno is %d\n", max);
1716 }
1717
1718 static void update_max_nontrunk(void)
1719 {
1720         int max = 1;
1721         int x;
1722         /* XXX Prolly don't need locks here XXX */
1723         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1724                 if (iaxs[x])
1725                         max = x + 1;
1726         }
1727         maxnontrunkcall = max;
1728         if (iaxdebug)
1729                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1730 }
1731
1732 static int make_trunk(unsigned short callno, int locked)
1733 {
1734         int x;
1735         int res= 0;
1736         struct timeval now = ast_tvnow();
1737         if (iaxs[callno]->oseqno) {
1738                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1739                 return -1;
1740         }
1741         if (callno & TRUNK_CALL_START) {
1742                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1743                 return -1;
1744         }
1745         for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
1746                 ast_mutex_lock(&iaxsl[x]);
1747                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1748                         /*!
1749                          * \note We delete these before switching the slot, because if
1750                          * they fire in the meantime, they will generate a warning.
1751                          */
1752                         ast_sched_thread_del(sched, iaxs[callno]->pingid);
1753                         ast_sched_thread_del(sched, iaxs[callno]->lagid);
1754                         iaxs[x] = iaxs[callno];
1755                         iaxs[x]->callno = x;
1756                         iaxs[callno] = NULL;
1757                         /* Update the two timers that should have been started */
1758                         iaxs[x]->pingid = iax2_sched_add(sched,
1759                                 ping_time * 1000, send_ping, (void *)(long)x);
1760                         iaxs[x]->lagid = iax2_sched_add(sched,
1761                                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
1762                         if (locked)
1763                                 ast_mutex_unlock(&iaxsl[callno]);
1764                         res = x;
1765                         if (!locked)
1766                                 ast_mutex_unlock(&iaxsl[x]);
1767                         break;
1768                 }
1769                 ast_mutex_unlock(&iaxsl[x]);
1770         }
1771         if (x >= ARRAY_LEN(iaxs) - 1) {
1772                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1773                 return -1;
1774         }
1775         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1776         /* We move this call from a non-trunked to a trunked call */
1777         update_max_trunk();
1778         update_max_nontrunk();
1779         return res;
1780 }
1781
1782 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
1783 {
1784         if (!pvt->transfercallno) {
1785                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
1786                 return;
1787         }
1788
1789         ao2_link(iax_transfercallno_pvts, pvt);
1790 }
1791
1792 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
1793 {
1794         if (!pvt->transfercallno) {
1795                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
1796                 return;
1797         }
1798
1799         ao2_unlink(iax_transfercallno_pvts, pvt);
1800 }
1801 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
1802 {
1803         if (!pvt->peercallno) {
1804                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
1805                 return;
1806         }
1807
1808         ao2_link(iax_peercallno_pvts, pvt);
1809 }
1810
1811 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
1812 {
1813         if (!pvt->peercallno) {
1814                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
1815                 return;
1816         }
1817
1818         ao2_unlink(iax_peercallno_pvts, pvt);
1819 }
1820
1821 /*
1822  * \note Calling this function while holding another pvt lock can cause a deadlock.
1823  */
1824 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
1825 {
1826         int res = 0;
1827         int x;
1828         struct timeval now;
1829         char host[80];
1830
1831         if (new <= NEW_ALLOW) {
1832                 if (callno) {
1833                         struct chan_iax2_pvt *pvt;
1834                         struct chan_iax2_pvt tmp_pvt = {
1835                                 .callno = dcallno,
1836                                 .peercallno = callno,
1837                                 .transfercallno = callno,
1838                                 /* hack!! */
1839                                 .frames_received = check_dcallno,
1840                         };
1841
1842                         memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
1843                         /* this works for finding normal call numbers not involving transfering */
1844                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
1845                                 if (return_locked) {
1846                                         ast_mutex_lock(&iaxsl[pvt->callno]);
1847                                 }
1848                                 res = pvt->callno;
1849                                 ao2_ref(pvt, -1);
1850                                 pvt = NULL;
1851                                 return res;
1852                         }
1853                         /* this searches for transfer call numbers that might not get caught otherwise */
1854                         memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
1855                         memcpy(&tmp_pvt.transfer, sin, sizeof(tmp_pvt.addr));
1856                         if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
1857                                 if (return_locked) {
1858                                         ast_mutex_lock(&iaxsl[pvt->callno]);
1859                                 }
1860                                 res = pvt->callno;
1861                                 ao2_ref(pvt, -1);
1862                                 pvt = NULL;
1863                                 return res;
1864                         }
1865                 }
1866                         /* This will occur on the first response to a message that we initiated,
1867                  * such as a PING. */
1868                 if (dcallno) {
1869                         ast_mutex_lock(&iaxsl[dcallno]);
1870                 }
1871                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
1872                         iaxs[dcallno]->peercallno = callno;
1873                         res = dcallno;
1874                         store_by_peercallno(iaxs[dcallno]);
1875                         if (!res || !return_locked) {
1876                                 ast_mutex_unlock(&iaxsl[dcallno]);
1877                         }
1878                         return res;
1879                 }
1880                 if (dcallno) {
1881                         ast_mutex_unlock(&iaxsl[dcallno]);
1882                 }
1883 #ifdef IAX_OLD_FIND
1884                 /* If we get here, we SHOULD NOT find a call structure for this
1885                    callno; if we do, it means that there is a call structure that
1886                    has a peer callno but did NOT get entered into the hash table,
1887                    which is bad.
1888
1889                    If we find a call structure using this old, slow method, output a log
1890                    message so we'll know about it. After a few months of leaving this in
1891                    place, if we don't hear about people seeing these messages, we can
1892                    remove this code for good.
1893                 */
1894
1895                 for (x = 1; !res && x < maxnontrunkcall; x++) {
1896                         ast_mutex_lock(&iaxsl[x]);
1897                         if (iaxs[x]) {
1898                                 /* Look for an exact match */
1899                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
1900                                         res = x;
1901                                 }
1902                         }
1903                         if (!res || !return_locked)
1904                                 ast_mutex_unlock(&iaxsl[x]);
1905                 }
1906                 for (x = TRUNK_CALL_START; !res && x < maxtrunkcall; x++) {
1907                         ast_mutex_lock(&iaxsl[x]);
1908                         if (iaxs[x]) {
1909                                 /* Look for an exact match */
1910                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
1911                                         res = x;
1912                                 }
1913                         }
1914                         if (!res || !return_locked)
1915                                 ast_mutex_unlock(&iaxsl[x]);
1916                 }
1917 #endif
1918         }
1919         if (!res && (new >= NEW_ALLOW)) {
1920                 int start, found = 0;
1921
1922                 /* It may seem odd that we look through the peer list for a name for
1923                  * this *incoming* call.  Well, it is weird.  However, users don't
1924                  * have an IP address/port number that we can match against.  So,
1925                  * this is just checking for a peer that has that IP/port and
1926                  * assuming that we have a user of the same name.  This isn't always
1927                  * correct, but it will be changed if needed after authentication. */
1928                 if (!iax2_getpeername(*sin, host, sizeof(host)))
1929                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1930
1931                 now = ast_tvnow();
1932                 start = 2 + (ast_random() % (TRUNK_CALL_START - 1));
1933                 for (x = start; 1; x++) {
1934                         if (x == TRUNK_CALL_START) {
1935                                 x = 1;
1936                                 continue;
1937                         }
1938
1939                         /* Find first unused call number that hasn't been used in a while */
1940                         ast_mutex_lock(&iaxsl[x]);
1941                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1942                                 found = 1;
1943                                 break;
1944                         }
1945                         ast_mutex_unlock(&iaxsl[x]);
1946
1947                         if (x == start - 1) {
1948                                 break;
1949                         }
1950                 }
1951                 /* We've still got lock held if we found a spot */
1952                 if (x == start - 1 && !found) {
1953                         ast_log(LOG_WARNING, "No more space\n");
1954                         return 0;
1955                 }
1956                 iaxs[x] = new_iax(sin, host);
1957                 update_max_nontrunk();
1958                 if (iaxs[x]) {
1959                         if (iaxdebug)
1960                                 ast_debug(1, "Creating new call structure %d\n", x);
1961                         iaxs[x]->sockfd = sockfd;
1962                         iaxs[x]->addr.sin_port = sin->sin_port;
1963                         iaxs[x]->addr.sin_family = sin->sin_family;
1964                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1965                         iaxs[x]->peercallno = callno;
1966                         iaxs[x]->callno = x;
1967                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1968                         iaxs[x]->expiry = min_reg_expire;
1969                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1970                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1971                         iaxs[x]->amaflags = amaflags;
1972                         ast_copy_flags(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_FORCE_ENCRYPT);
1973                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1974                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1975                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1976                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
1977
1978                         if (iaxs[x]->peercallno) {
1979                                 store_by_peercallno(iaxs[x]);
1980                         }
1981                 } else {
1982                         ast_log(LOG_WARNING, "Out of resources\n");
1983                         ast_mutex_unlock(&iaxsl[x]);
1984                         return 0;
1985                 }
1986                 if (!return_locked)
1987                         ast_mutex_unlock(&iaxsl[x]);
1988                 res = x;
1989         }
1990         return res;
1991 }
1992
1993 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1994
1995         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
1996 }
1997
1998 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1999
2000         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
2001 }
2002
2003 /*!
2004  * \brief Queue a frame to a call's owning asterisk channel
2005  *
2006  * \pre This function assumes that iaxsl[callno] is locked when called.
2007  *
2008  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2009  * was valid before calling it, it may no longer be valid after calling it.
2010  * This function may unlock and lock the mutex associated with this callno,
2011  * meaning that another thread may grab it and destroy the call.
2012  */
2013 static int iax2_queue_frame(int callno, struct ast_frame *f)
2014 {
2015         for (;;) {
2016                 if (iaxs[callno] && iaxs[callno]->owner) {
2017                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2018                                 /* Avoid deadlock by pausing and trying again */
2019                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2020                         } else {
2021                                 ast_queue_frame(iaxs[callno]->owner, f);
2022                                 ast_channel_unlock(iaxs[callno]->owner);
2023                                 break;
2024                         }
2025                 } else
2026                         break;
2027         }
2028         return 0;
2029 }
2030
2031 /*!
2032  * \brief Queue a hangup frame on the ast_channel owner
2033  *
2034  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
2035  * is active for the given call number.
2036  *
2037  * \pre Assumes lock for callno is already held.
2038  *
2039  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2040  * was valid before calling it, it may no longer be valid after calling it.
2041  * This function may unlock and lock the mutex associated with this callno,
2042  * meaning that another thread may grab it and destroy the call.
2043  */
2044 static int iax2_queue_hangup(int callno)
2045 {
2046         for (;;) {
2047                 if (iaxs[callno] && iaxs[callno]->owner) {
2048                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2049                                 /* Avoid deadlock by pausing and trying again */
2050                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2051                         } else {
2052                                 ast_queue_hangup(iaxs[callno]->owner);
2053                                 ast_channel_unlock(iaxs[callno]->owner);
2054                                 break;
2055                         }
2056                 } else
2057                         break;
2058         }
2059         return 0;
2060 }
2061
2062 /*!
2063  * \brief Queue a control frame on the ast_channel owner
2064  *
2065  * This function queues a control frame on the owner of the IAX2 pvt struct that
2066  * is active for the given call number.
2067  *
2068  * \pre Assumes lock for callno is already held.
2069  *
2070  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2071  * was valid before calling it, it may no longer be valid after calling it.
2072  * This function may unlock and lock the mutex associated with this callno,
2073  * meaning that another thread may grab it and destroy the call.
2074  */
2075 static int iax2_queue_control_data(int callno,
2076         enum ast_control_frame_type control, const void *data, size_t datalen)
2077 {
2078         for (;;) {
2079                 if (iaxs[callno] && iaxs[callno]->owner) {
2080                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2081                                 /* Avoid deadlock by pausing and trying again */
2082                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2083                         } else {
2084                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
2085                                 ast_channel_unlock(iaxs[callno]->owner);
2086                                 break;
2087                         }
2088                 } else
2089                         break;
2090         }
2091         return 0;
2092 }
2093 static void destroy_firmware(struct iax_firmware *cur)
2094 {
2095         /* Close firmware */
2096         if (cur->fwh) {
2097                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
2098         }
2099         close(cur->fd);
2100         ast_free(cur);
2101 }
2102
2103 static int try_firmware(char *s)
2104 {
2105         struct stat stbuf;
2106         struct iax_firmware *cur = NULL;
2107         int ifd, fd, res, len, chunk;
2108         struct ast_iax2_firmware_header *fwh, fwh2;
2109         struct MD5Context md5;
2110         unsigned char sum[16], buf[1024];
2111         char *s2, *last;
2112
2113         if (!(s2 = alloca(strlen(s) + 100))) {
2114                 ast_log(LOG_WARNING, "Alloca failed!\n");
2115                 return -1;
2116         }
2117
2118         last = strrchr(s, '/');
2119         if (last)
2120                 last++;
2121         else
2122                 last = s;
2123
2124         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
2125
2126         if ((res = stat(s, &stbuf) < 0)) {
2127                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
2128                 return -1;
2129         }
2130
2131         /* Make sure it's not a directory */
2132         if (S_ISDIR(stbuf.st_mode))
2133                 return -1;
2134         ifd = open(s, O_RDONLY);
2135         if (ifd < 0) {
2136                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
2137                 return -1;
2138         }
2139         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
2140         if (fd < 0) {
2141                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
2142                 close(ifd);
2143                 return -1;
2144         }
2145         /* Unlink our newly created file */
2146         unlink(s2);
2147
2148         /* Now copy the firmware into it */
2149         len = stbuf.st_size;
2150         while(len) {
2151                 chunk = len;
2152                 if (chunk > sizeof(buf))
2153                         chunk = sizeof(buf);
2154                 res = read(ifd, buf, chunk);
2155                 if (res != chunk) {
2156                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
2157                         close(ifd);
2158                         close(fd);
2159                         return -1;
2160                 }
2161                 res = write(fd, buf, chunk);
2162                 if (res != chunk) {
2163                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
2164                         close(ifd);
2165                         close(fd);
2166                         return -1;
2167                 }
2168                 len -= chunk;
2169         }
2170         close(ifd);
2171         /* Return to the beginning */
2172         lseek(fd, 0, SEEK_SET);
2173         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
2174                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
2175                 close(fd);
2176                 return -1;
2177         }
2178         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
2179                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
2180                 close(fd);
2181                 return -1;
2182         }
2183         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
2184                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
2185                 close(fd);
2186                 return -1;
2187         }
2188         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
2189                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
2190                 close(fd);
2191                 return -1;
2192         }
2193         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
2194         if (fwh == (void *) -1) {
2195                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
2196                 close(fd);
2197                 return -1;
2198         }
2199         MD5Init(&md5);
2200         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
2201         MD5Final(sum, &md5);
2202         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
2203                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
2204                 munmap((void*)fwh, stbuf.st_size);
2205                 close(fd);
2206                 return -1;
2207         }
2208
2209         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2210                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
2211                         /* Found a candidate */
2212                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
2213                                 /* The version we have on loaded is older, load this one instead */
2214                                 break;
2215                         /* This version is no newer than what we have.  Don't worry about it.
2216                            We'll consider it a proper load anyhow though */
2217                         munmap((void*)fwh, stbuf.st_size);
2218                         close(fd);
2219                         return 0;
2220                 }
2221         }
2222
2223         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
2224                 cur->fd = -1;
2225                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
2226         }
2227
2228         if (cur) {
2229                 if (cur->fwh)
2230                         munmap((void*)cur->fwh, cur->mmaplen);
2231                 if (cur->fd > -1)
2232                         close(cur->fd);
2233                 cur->fwh = fwh;
2234                 cur->fd = fd;
2235                 cur->mmaplen = stbuf.st_size;
2236                 cur->dead = 0;
2237         }
2238
2239         return 0;
2240 }
2241
2242 static int iax_check_version(char *dev)
2243 {
2244         int res = 0;
2245         struct iax_firmware *cur = NULL;
2246
2247         if (ast_strlen_zero(dev))
2248                 return 0;
2249
2250         AST_LIST_LOCK(&firmwares);
2251         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2252                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
2253                         res = ntohs(cur->fwh->version);
2254                         break;
2255                 }
2256         }
2257         AST_LIST_UNLOCK(&firmwares);
2258
2259         return res;
2260 }
2261
2262 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
2263 {
2264         int res = -1;
2265         unsigned int bs = desc & 0xff;
2266         unsigned int start = (desc >> 8) & 0xffffff;
2267         unsigned int bytes;
2268         struct iax_firmware *cur;
2269
2270         if (ast_strlen_zero((char *)dev) || !bs)
2271                 return -1;
2272
2273         start *= bs;
2274
2275         AST_LIST_LOCK(&firmwares);
2276         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2277                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
2278                         continue;
2279                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
2280                 if (start < ntohl(cur->fwh->datalen)) {
2281                         bytes = ntohl(cur->fwh->datalen) - start;
2282                         if (bytes > bs)
2283                                 bytes = bs;
2284                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
2285                 } else {
2286                         bytes = 0;
2287                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
2288                 }
2289                 if (bytes == bs)
2290                         res = 0;
2291                 else
2292                         res = 1;
2293                 break;
2294         }
2295         AST_LIST_UNLOCK(&firmwares);
2296
2297         return res;
2298 }
2299
2300
2301 static void reload_firmware(int unload)
2302 {
2303         struct iax_firmware *cur = NULL;
2304         DIR *fwd;
2305         struct dirent *de;
2306         char dir[256], fn[256];
2307
2308         AST_LIST_LOCK(&firmwares);
2309
2310         /* Mark all as dead */
2311         AST_LIST_TRAVERSE(&firmwares, cur, list)
2312                 cur->dead = 1;
2313
2314         /* Now that we have marked them dead... load new ones */
2315         if (!unload) {
2316                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
2317                 fwd = opendir(dir);
2318                 if (fwd) {
2319                         while((de = readdir(fwd))) {
2320                                 if (de->d_name[0] != '.') {
2321                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
2322                                         if (!try_firmware(fn)) {
2323                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
2324                                         }
2325                                 }
2326                         }
2327                         closedir(fwd);
2328                 } else
2329                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
2330         }
2331
2332         /* Clean up leftovers */
2333         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
2334                 if (!cur->dead)
2335                         continue;
2336                 AST_LIST_REMOVE_CURRENT(list);
2337                 destroy_firmware(cur);
2338         }
2339         AST_LIST_TRAVERSE_SAFE_END;
2340
2341         AST_LIST_UNLOCK(&firmwares);
2342 }
2343
2344 /*!
2345  * \note This function assumes that iaxsl[callno] is locked when called.
2346  *
2347  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2348  * was valid before calling it, it may no longer be valid after calling it.
2349  * This function calls iax2_queue_frame(), which may unlock and lock the mutex
2350  * associated with this callno, meaning that another thread may grab it and destroy the call.
2351  */
2352 static int __do_deliver(void *data)
2353 {
2354         /* Just deliver the packet by using queueing.  This is called by
2355           the IAX thread with the iaxsl lock held. */
2356         struct iax_frame *fr = data;
2357         fr->retrans = -1;
2358         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
2359         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
2360                 iax2_queue_frame(fr->callno, &fr->af);
2361         /* Free our iax frame */
2362         iax2_frame_free(fr);
2363         /* And don't run again */
2364         return 0;
2365 }
2366
2367 static int handle_error(void)
2368 {
2369         /* XXX Ideally we should figure out why an error occurred and then abort those
2370            rather than continuing to try.  Unfortunately, the published interface does
2371            not seem to work XXX */
2372 #if 0
2373         struct sockaddr_in *sin;
2374         int res;
2375         struct msghdr m;
2376         struct sock_extended_err e;
2377         m.msg_name = NULL;
2378         m.msg_namelen = 0;
2379         m.msg_iov = NULL;
2380         m.msg_control = &e;
2381         m.msg_controllen = sizeof(e);
2382         m.msg_flags = 0;
2383         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
2384         if (res < 0)
2385                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
2386         else {
2387                 if (m.msg_controllen) {
2388                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
2389                         if (sin)
2390                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
2391                         else
2392                                 ast_log(LOG_WARNING, "No address detected??\n");
2393                 } else {
2394                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
2395                 }
2396         }
2397 #endif
2398         return 0;
2399 }
2400
2401 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
2402 {
2403         int res;
2404         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
2405                                         sizeof(*sin));
2406         if (res < 0) {
2407                 ast_debug(1, "Received error: %s\n", strerror(errno));
2408                 handle_error();
2409         } else
2410                 res = 0;
2411         return res;
2412 }
2413
2414 static int send_packet(struct iax_frame *f)
2415 {
2416         int res;
2417         int callno = f->callno;
2418
2419         /* Don't send if there was an error, but return error instead */
2420         if (!callno || !iaxs[callno] || iaxs[callno]->error)
2421             return -1;
2422
2423         /* Called with iaxsl held */
2424         if (iaxdebug)
2425                 ast_debug(3, "Sending %d on %d/%d to %s:%d\n", f->ts, callno, iaxs[callno]->peercallno, ast_inet_ntoa(iaxs[callno]->addr.sin_addr), ntohs(iaxs[callno]->addr.sin_port));
2426
2427         if (f->transfer) {
2428                 if (iaxdebug)
2429                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
2430                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer, sizeof(iaxs[callno]->transfer));
2431         } else {
2432                 if (iaxdebug)
2433                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
2434                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr, sizeof(iaxs[callno]->addr));
2435         }
2436         if (res < 0) {
2437                 if (iaxdebug)
2438                         ast_debug(1, "Received error: %s\n", strerror(errno));
2439                 handle_error();
2440         } else
2441                 res = 0;
2442
2443         return res;
2444 }
2445
2446 /*!
2447  * \note Since this function calls iax2_queue_hangup(), the pvt struct
2448  *       for the given call number may disappear during its execution.
2449  */
2450 static int iax2_predestroy(int callno)
2451 {
2452         struct ast_channel *c = NULL;
2453         struct chan_iax2_pvt *pvt = iaxs[callno];
2454
2455         if (!pvt)
2456                 return -1;
2457
2458         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
2459                 iax2_destroy_helper(pvt);
2460                 ast_set_flag(pvt, IAX_ALREADYGONE);
2461         }
2462
2463         if ((c = pvt->owner)) {
2464                 c->tech_pvt = NULL;
2465                 iax2_queue_hangup(callno);
2466                 pvt->owner = NULL;
2467                 ast_module_unref(ast_module_info->self);
2468         }
2469
2470         return 0;
2471 }
2472
2473 static void iax2_destroy(int callno)
2474 {
2475         struct chan_iax2_pvt *pvt = NULL;
2476         struct ast_channel *owner = NULL;
2477
2478 retry:
2479         if ((pvt = iaxs[callno])) {
2480                 iax2_destroy_helper(pvt);
2481         }
2482
2483         lastused[callno] = ast_tvnow();
2484
2485         owner = pvt ? pvt->owner : NULL;
2486
2487         if (owner) {
2488                 if (ast_channel_trylock(owner)) {
2489                         ast_debug(3, "Avoiding IAX destroy deadlock\n");
2490                         DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2491                         goto retry;
2492                 }
2493         }
2494
2495         if (!owner) {
2496                 iaxs[callno] = NULL;
2497         }
2498
2499         if (pvt) {
2500                 if (!owner) {
2501                         pvt->owner = NULL;
2502                 } else {
2503                         /* If there's an owner, prod it to give up */
2504                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
2505                          * because we already hold the owner channel lock. */
2506                         ast_queue_hangup(owner);
2507                 }
2508
2509                 if (pvt->peercallno) {
2510                         remove_by_peercallno(pvt);
2511                 }
2512
2513                 if (pvt->transfercallno) {
2514                         remove_by_transfercallno(pvt);
2515                 }
2516
2517                 if (!owner) {
2518                         ao2_ref(pvt, -1);
2519                         pvt = NULL;
2520                 }
2521         }
2522
2523         if (owner) {
2524                 ast_channel_unlock(owner);
2525         }
2526
2527         if (callno & 0x4000) {
2528                 update_max_trunk();
2529         }
2530 }
2531
2532 static int update_packet(struct iax_frame *f)
2533 {
2534         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2535         struct ast_iax2_full_hdr *fh = f->data;
2536         struct ast_frame af;
2537
2538         /* if frame is encrypted. decrypt before updating it. */
2539         if (f->encmethods) {
2540                 decode_frame(&f->mydcx, fh, &af, &f->datalen);
2541         }
2542         /* Mark this as a retransmission */
2543         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2544         /* Update iseqno */
2545         f->iseqno = iaxs[f->callno]->iseqno;
2546         fh->iseqno = f->iseqno;
2547
2548         /* Now re-encrypt the frame */
2549         if (f->encmethods) {
2550                 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
2551         }
2552         return 0;
2553 }
2554
2555 static int attempt_transmit(const void *data);
2556 static void __attempt_transmit(const void *data)
2557 {
2558         /* Attempt to transmit the frame to the remote peer...
2559            Called without iaxsl held. */
2560         struct iax_frame *f = (struct iax_frame *)data;
2561         int freeme = 0;
2562         int callno = f->callno;
2563         /* Make sure this call is still active */
2564         if (callno)
2565                 ast_mutex_lock(&iaxsl[callno]);
2566         if (callno && iaxs[callno]) {
2567                 if ((f->retries < 0) /* Already ACK'd */ ||
2568                     (f->retries >= max_retries) /* Too many attempts */) {
2569                                 /* Record an error if we've transmitted too many times */
2570                                 if (f->retries >= max_retries) {
2571                                         if (f->transfer) {
2572                                                 /* Transfer timeout */
2573                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
2574                                         } else if (f->final) {
2575                                                 iax2_destroy(callno);
2576                                         } else {
2577                                                 if (iaxs[callno]->owner)
2578                                                         ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
2579                                                 iaxs[callno]->error = ETIMEDOUT;
2580                                                 if (iaxs[callno]->owner) {
2581                                                         struct ast_frame fr = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
2582                                                         /* Hangup the fd */
2583                                                         iax2_queue_frame(callno, &fr); /* XXX */
2584                                                         /* Remember, owner could disappear */
2585                                                         if (iaxs[callno] && iaxs[callno]->owner)
2586                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2587                                                 } else {
2588                                                         if (iaxs[callno]->reg) {
2589                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2590                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2591                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2592                                                         }
2593                                                         iax2_destroy(callno);
2594                                                 }
2595                                         }
2596
2597                                 }
2598                                 freeme = 1;
2599                 } else {
2600                         /* Update it if it needs it */
2601                         update_packet(f);
2602                         /* Attempt transmission */
2603                         send_packet(f);
2604                         f->retries++;
2605                         /* Try again later after 10 times as long */
2606                         f->retrytime *= 10;
2607                         if (f->retrytime > MAX_RETRY_TIME)
2608                                 f->retrytime = MAX_RETRY_TIME;
2609                         /* Transfer messages max out at one second */
2610                         if (f->transfer && (f->retrytime > 1000))
2611                                 f->retrytime = 1000;
2612                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
2613                 }
2614         } else {
2615                 /* Make sure it gets freed */
2616                 f->retries = -1;
2617                 freeme = 1;
2618         }
2619         if (callno)
2620                 ast_mutex_unlock(&iaxsl[callno]);
2621         /* Do not try again */
2622         if (freeme) {
2623                 /* Don't attempt delivery, just remove it from the queue */
2624                 AST_LIST_LOCK(&frame_queue);
2625                 AST_LIST_REMOVE(&frame_queue, f, list);
2626                 AST_LIST_UNLOCK(&frame_queue);
2627                 f->retrans = -1;
2628                 /* Free the IAX frame */
2629                 iax2_frame_free(f);
2630         }
2631 }
2632
2633 static int attempt_transmit(const void *data)
2634 {
2635 #ifdef SCHED_MULTITHREADED
2636         if (schedule_action(__attempt_transmit, data))
2637 #endif
2638                 __attempt_transmit(data);
2639         return 0;
2640 }
2641
2642 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2643 {
2644         struct iax2_peer *peer = NULL;
2645         struct iax2_user *user = NULL;
2646         static char *choices[] = { "all", NULL };
2647         char *cmplt;
2648
2649         switch (cmd) {
2650         case CLI_INIT:
2651                 e->command = "iax2 prune realtime";
2652                 e->usage =
2653                         "Usage: iax2 prune realtime [<peername>|all]\n"
2654                         "       Prunes object(s) from the cache\n";
2655                 return NULL;
2656         case CLI_GENERATE:
2657                 if (a->pos == 3) {
2658                         cmplt = ast_cli_complete(a->word, choices, a->n);
2659                         if (!cmplt)
2660                                 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
2661                         return cmplt;
2662                 }
2663                 return NULL;
2664         }
2665         if (a->argc != 4)
2666                 return CLI_SHOWUSAGE;
2667         if (!strcmp(a->argv[3], "all")) {
2668                 prune_users();
2669                 prune_peers();
2670                 ast_cli(a->fd, "Cache flushed successfully.\n");
2671                 return CLI_SUCCESS;
2672         }
2673         peer = find_peer(a->argv[3], 0);
2674         user = find_user(a->argv[3]);
2675         if (peer || user) {
2676                 if (peer) {
2677                         if (ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2678                                 ast_set_flag(peer, IAX_RTAUTOCLEAR);
2679                                 expire_registry(peer_ref(peer));
2680                                 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
2681                         } else {
2682                                 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
2683                         }
2684                         peer_unref(peer);
2685                 }
2686                 if (user) {
2687                         if (ast_test_flag(user, IAX_RTCACHEFRIENDS)) {
2688                                 ast_set_flag(user, IAX_RTAUTOCLEAR);
2689                                 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
2690                         } else {
2691                                 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
2692                         }
2693                         ao2_unlink(users,user);
2694                         user_unref(user);
2695                 }
2696         } else {
2697                 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
2698         }
2699
2700         return CLI_SUCCESS;
2701 }
2702
2703 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2704 {
2705         switch (cmd) {
2706         case CLI_INIT:
2707                 e->command = "iax2 test losspct";
2708                 e->usage =
2709                         "Usage: iax2 test losspct <percentage>\n"
2710                         "       For testing, throws away <percentage> percent of incoming packets\n";
2711                 return NULL;
2712         case CLI_GENERATE:
2713                 return NULL;
2714         }
2715         if (a->argc != 4)
2716                 return CLI_SHOWUSAGE;
2717
2718         test_losspct = atoi(a->argv[3]);
2719
2720         return CLI_SUCCESS;
2721 }
2722
2723 #ifdef IAXTESTS
2724 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2725 {
2726         switch (cmd) {
2727         case CLI_INIT:
2728                 e->command = "iax2 test late";
2729                 e->usage =
2730                         "Usage: iax2 test late <ms>\n"
2731                         "       For testing, count the next frame as <ms> ms late\n";
2732                 return NULL;
2733         case CLI_GENERATE:
2734                 return NULL;
2735         }
2736
2737         if (a->argc != 4)
2738                 return CLI_SHOWUSAGE;
2739
2740         test_late = atoi(a->argv[3]);
2741
2742         return CLI_SUCCESS;
2743 }
2744
2745 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2746 {
2747         switch (cmd) {
2748         case CLI_INIT:
2749                 e->command = "iax2 test resync";
2750                 e->usage =
2751                         "Usage: iax2 test resync <ms>\n"
2752                         "       For testing, adjust all future frames by <ms> ms\n";
2753                 return NULL;
2754         case CLI_GENERATE:
2755                 return NULL;
2756         }
2757
2758         if (a->argc != 4)
2759                 return CLI_SHOWUSAGE;
2760
2761         test_resync = atoi(a->argv[3]);
2762
2763         return CLI_SUCCESS;
2764 }
2765
2766 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2767 {
2768         switch (cmd) {
2769         case CLI_INIT:
2770                 e->command = "iax2 test jitter";
2771                 e->usage =
2772                         "Usage: iax2 test jitter <ms> <pct>\n"
2773                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
2774                         "       percentage of packets. If <pct> is not specified, adds\n"
2775                         "       jitter to all packets.\n";
2776                 return NULL;
2777         case CLI_GENERATE:
2778                 return NULL;
2779         }
2780
2781         if (a->argc < 4 || a->argc > 5)
2782                 return CLI_SHOWUSAGE;
2783
2784         test_jit = atoi(a->argv[3]);
2785         if (a->argc == 5)
2786                 test_jitpct = atoi(a->argv[4]);
2787
2788         return CLI_SUCCESS;
2789 }
2790 #endif /* IAXTESTS */
2791
2792 /*! \brief  peer_status: Report Peer status in character string */
2793 /*      returns 1 if peer is online, -1 if unmonitored */
2794 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2795 {
2796         int res = 0;
2797         if (peer->maxms) {
2798                 if (peer->lastms < 0) {
2799                         ast_copy_string(status, "UNREACHABLE", statuslen);
2800                 } else if (peer->lastms > peer->maxms) {
2801                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2802                         res = 1;
2803                 } else if (peer->lastms) {
2804                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2805                         res = 1;
2806                 } else {
2807                         ast_copy_string(status, "UNKNOWN", statuslen);
2808                 }
2809         } else {
2810                 ast_copy_string(status, "Unmonitored", statuslen);
2811                 res = -1;
2812         }
2813         return res;
2814 }
2815
2816 /*! \brief Show one peer in detail */
2817 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2818 {
2819         char status[30];
2820         char cbuf[256];
2821         struct iax2_peer *peer;
2822         char codec_buf[512];
2823         struct ast_str *encmethods = ast_str_alloca(256);
2824         int x = 0, codec = 0, load_realtime = 0;
2825
2826         switch (cmd) {
2827         case CLI_INIT:
2828                 e->command = "iax2 show peer";
2829                 e->usage =
2830                         "Usage: iax2 show peer <name>\n"
2831                         "       Display details on specific IAX peer\n";
2832                 return NULL;
2833         case CLI_GENERATE:
2834                 if (a->pos == 3)
2835                         return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
2836                 return NULL;
2837         }
2838
2839         if (a->argc < 4)
2840                 return CLI_SHOWUSAGE;
2841
2842         load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
2843
2844         peer = find_peer(a->argv[3], load_realtime);
2845         if (peer) {
2846                 encmethods_to_str(peer->encmethods, encmethods);
2847                 ast_cli(a->fd, "\n\n");
2848                 ast_cli(a->fd, "  * Name       : %s\n", peer->name);
2849                 ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
2850                 ast_cli(a->fd, "  Context      : %s\n", peer->context);
2851                 ast_cli(a->fd, "  Parking lot  : %s\n", peer->parkinglot);
2852                 ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
2853                 ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes" : "No");
2854                 ast_cli(a->fd, "  Trunk        : %s\n", ast_test_flag(peer, IAX_TRUNK) ? "Yes" : "No");
2855                 ast_cli(a->fd, "  Encryption   : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
2856                 ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2857                 ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
2858                 ast_cli(a->fd, "  ACL          : %s\n", (peer->ha ? "Yes" : "No"));
2859                 ast_cli(a->fd, "  Addr->IP     : %s Port %d\n",  peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
2860                 ast_cli(a->fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2861                 ast_cli(a->fd, "  Username     : %s\n", peer->username);
2862                 ast_cli(a->fd, "  Codecs       : ");
2863                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2864                 ast_cli(a->fd, "%s\n", codec_buf);
2865
2866                 ast_cli(a->fd, "  Codec Order  : (");
2867                 for(x = 0; x < 32 ; x++) {
2868                         codec = ast_codec_pref_index(&peer->prefs,x);
2869                         if(!codec)
2870                                 break;
2871                         ast_cli(a->fd, "%s", ast_getformatname(codec));
2872                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2873                                 ast_cli(a->fd, "|");
2874                 }
2875
2876                 if (!x)
2877                         ast_cli(a->fd, "none");
2878                 ast_cli(a->fd, ")\n");
2879
2880                 ast_cli(a->fd, "  Status       : ");
2881                 peer_status(peer, status, sizeof(status));
2882                 ast_cli(a->fd, "%s\n",status);
2883                 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");
2884                 ast_cli(a->fd, "\n");
2885                 peer_unref(peer);
2886         } else {
2887                 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
2888                 ast_cli(a->fd, "\n");
2889         }
2890
2891         return CLI_SUCCESS;
2892 }
2893
2894 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, int flags)
2895 {
2896         int which = 0;
2897         struct iax2_peer *peer;
2898         char *res = NULL;
2899         int wordlen = strlen(word);
2900         struct ao2_iterator i;
2901
2902         i = ao2_iterator_init(peers, 0);
2903         while ((peer = ao2_iterator_next(&i))) {
2904                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
2905                         && (!flags || ast_test_flag(peer, flags))) {
2906                         res = ast_strdup(peer->name);
2907                         peer_unref(peer);
2908                         break;
2909                 }
2910                 peer_unref(peer);
2911         }
2912
2913         return res;
2914 }
2915
2916 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2917 {
2918         struct iax_frame *cur;
2919         int cnt = 0, dead = 0, final = 0;
2920
2921         switch (cmd) {
2922         case CLI_INIT:
2923                 e->command = "iax2 show stats";
2924                 e->usage =
2925                         "Usage: iax2 show stats\n"
2926                         "       Display statistics on IAX channel driver.\n";
2927                 return NULL;
2928         case CLI_GENERATE:
2929                 return NULL;
2930         }
2931
2932         if (a->argc != 3)
2933                 return CLI_SHOWUSAGE;
2934
2935         AST_LIST_LOCK(&frame_queue);
2936         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2937                 if (cur->retries < 0)
2938                         dead++;
2939                 if (cur->final)
2940                         final++;
2941                 cnt++;
2942         }
2943         AST_LIST_UNLOCK(&frame_queue);
2944
2945         ast_cli(a->fd, "    IAX Statistics\n");
2946         ast_cli(a->fd, "---------------------\n");
2947         ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2948         ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2949                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2950         ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2951
2952         trunk_timed = trunk_untimed = 0;
2953         if (trunk_maxmtu > trunk_nmaxmtu)
2954                 trunk_nmaxmtu = trunk_maxmtu;
2955
2956         return CLI_SUCCESS;
2957 }
2958
2959 /*! \brief Set trunk MTU from CLI */
2960 static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2961 {
2962         int mtuv;
2963
2964         switch (cmd) {
2965         case CLI_INIT:
2966                 e->command = "iax2 set mtu";
2967                 e->usage =
2968                         "Usage: iax2 set mtu <value>\n"
2969                         "       Set the system-wide IAX IP mtu to <value> bytes net or\n"
2970                         "       zero to disable. Disabling means that the operating system\n"
2971                         "       must handle fragmentation of UDP packets when the IAX2 trunk\n"
2972                         "       packet exceeds the UDP payload size. This is substantially\n"
2973                         "       below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
2974                         "       greater for G.711 samples.\n";
2975                 return NULL;
2976         case CLI_GENERATE:
2977                 return NULL;
2978         }
2979
2980         if (a->argc != 4)
2981                 return CLI_SHOWUSAGE;
2982         if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
2983                 mtuv = MAX_TRUNK_MTU;
2984         else
2985                 mtuv = atoi(a->argv[3]);
2986
2987         if (mtuv == 0) {
2988                 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
2989                 global_max_trunk_mtu = 0;
2990                 return CLI_SUCCESS;
2991         }
2992         if (mtuv < 172 || mtuv > 4000) {
2993                 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n");
2994                 return CLI_SHOWUSAGE;
2995         }
2996         ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
2997         global_max_trunk_mtu = mtuv;
2998         return CLI_SUCCESS;
2999 }
3000
3001 static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3002 {
3003         struct iax2_dpcache *dp = NULL;
3004         char tmp[1024], *pc = NULL;
3005         int s, x, y;
3006         struct timeval now = ast_tvnow();
3007
3008         switch (cmd) {
3009         case CLI_INIT:
3010                 e->command = "iax2 show cache";
3011                 e->usage =
3012                         "Usage: iax2 show cache\n"
3013                         "       Display currently cached IAX Dialplan results.\n";
3014                 return NULL;
3015         case CLI_GENERATE:
3016                 return NULL;
3017         }
3018
3019         AST_LIST_LOCK(&dpcache);
3020
3021         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
3022
3023         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
3024                 s = dp->expiry.tv_sec - now.tv_sec;
3025                 tmp[0] = '\0';
3026                 if (dp->flags & CACHE_FLAG_EXISTS)
3027                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
3028                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
3029                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
3030                 if (dp->flags & CACHE_FLAG_CANEXIST)
3031                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
3032                 if (dp->flags & CACHE_FLAG_PENDING)
3033                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
3034                 if (dp->flags & CACHE_FLAG_TIMEOUT)
3035                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
3036                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
3037                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
3038                 if (dp->flags & CACHE_FLAG_MATCHMORE)
3039                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
3040                 if (dp->flags & CACHE_FLAG_UNKNOWN)
3041                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
3042                 /* Trim trailing pipe */
3043                 if (!ast_strlen_zero(tmp)) {
3044                         tmp[strlen(tmp) - 1] = '\0';
3045                 } else {
3046                         ast_copy_string(tmp, "(none)", sizeof(tmp));
3047                 }
3048                 y = 0;
3049                 pc = strchr(dp->peercontext, '@');
3050                 if (!pc) {
3051                         pc = dp->peercontext;
3052                 } else {
3053                         pc++;
3054                 }
3055                 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
3056                         if (dp->waiters[x] > -1)
3057                                 y++;
3058                 }
3059                 if (s > 0) {
3060                         ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
3061                 } else {
3062                         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
3063                 }
3064         }
3065
3066         AST_LIST_LOCK(&dpcache);
3067
3068         return CLI_SUCCESS;
3069 }
3070
3071 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
3072
3073 static void unwrap_timestamp(struct iax_frame *fr)
3074 {
3075         /* Video mini frames only encode the lower 15 bits of the session
3076          * timestamp, but other frame types (e.g. audio) encode 16 bits. */
3077         const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
3078         const int lower_mask = (1 << ts_shift) - 1;
3079         const int upper_mask = ~lower_mask;
3080         const int last_upper = iaxs[fr->callno]->last & upper_mask;
3081
3082         if ( (fr->ts & upper_mask) == last_upper ) {
3083                 const int x = fr->ts - iaxs[fr->callno]->last;
3084                 const int threshold = (ts_shift == 15) ? 25000 : 50000;
3085
3086                 if (x < -threshold) {
3087                         /* Sudden big jump backwards in timestamp:
3088                            What likely happened here is that miniframe timestamp has circled but we haven't
3089                            gotten the update from the main packet.  We'll just pretend that we did, and
3090                            update the timestamp appropriately. */
3091                         fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
3092                         if (iaxdebug)
3093                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
3094                 } else if (x > threshold) {
3095                         /* Sudden apparent big jump forwards in timestamp:
3096                            What's likely happened is this is an old miniframe belonging to the previous
3097                            top 15 or 16-bit timestamp that has turned up out of order.
3098                            Adjust the timestamp appropriately. */
3099                         fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
3100                         if (iaxdebug)
3101                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
3102                 }
3103         }
3104 }
3105
3106 static int get_from_jb(const void *p);
3107
3108 static void update_jbsched(struct chan_iax2_pvt *pvt)
3109 {
3110         int when;
3111
3112         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
3113
3114         when = jb_next(pvt->jb) - when;
3115
3116         if (when <= 0) {
3117                 /* XXX should really just empty until when > 0.. */
3118                 when = 1;
3119         }
3120
3121         pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb,
3122                 CALLNO_TO_PTR(pvt->callno));
3123 }
3124
3125 static void __get_from_jb(const void *p)
3126 {
3127         int callno = PTR_TO_CALLNO(p);
3128         struct chan_iax2_pvt *pvt = NULL;
3129         struct iax_frame *fr;
3130         jb_frame frame;
3131         int ret;
3132         long ms;
3133         long next;
3134         struct timeval now = ast_tvnow();
3135
3136         /* Make sure we have a valid private structure before going on */
3137         ast_mutex_lock(&iaxsl[callno]);
3138         pvt = iaxs[callno];
3139         if (!pvt) {
3140                 /* No go! */
3141                 ast_mutex_unlock(&iaxsl[callno]);
3142                 return;
3143         }
3144
3145         pvt->jbid = -1;
3146
3147         /* round up a millisecond since ast_sched_runq does; */
3148         /* prevents us from spinning while waiting for our now */
3149         /* to catch up with runq's now */
3150         now.tv_usec += 1000;
3151
3152         ms = ast_tvdiff_ms(now, pvt->rxcore);
3153
3154         if(ms >= (next = jb_next(pvt->jb))) {
3155                 ret = jb_get(pvt->jb,&frame,ms,ast_codec_interp_len(pvt->voiceformat));
3156                 switch(ret) {
3157                 case JB_OK:
3158                         fr = frame.data;
3159                     &nb