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