channels/chan_iax2.c

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