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