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