channels/chan_iax2.c

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