channels/chan_iax2.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of Inter-Asterisk eXchange Version 2
   5  *
   6  * Copyright (C) 2003, Digium
   7  *
   8  * Mark Spencer <markster@digium.com>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <asterisk/lock.h>
  15 #include <asterisk/frame.h>
  16 #include <asterisk/channel.h>
  17 #include <asterisk/channel_pvt.h>
  18 #include <asterisk/logger.h>
  19 #include <asterisk/module.h>
  20 #include <asterisk/pbx.h>
  21 #include <asterisk/sched.h>
  22 #include <asterisk/io.h>
  23 #include <asterisk/config.h>
  24 #include <asterisk/options.h>
  25 #include <asterisk/cli.h>
  26 #include <asterisk/translate.h>
  27 #include <asterisk/md5.h>
  28 #include <asterisk/cdr.h>
  29 #include <asterisk/crypto.h>
  30 #include <asterisk/acl.h>
  31 #include <asterisk/manager.h>
  32 #include <asterisk/callerid.h>
  33 #include <asterisk/app.h>
  34 #include <asterisk/astdb.h>
  35 #include <asterisk/musiconhold.h>
  36 #include <asterisk/parking.h>
  37 #include <sys/mman.h>
  38 #include <arpa/inet.h>
  39 #include <dirent.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42 #include <netinet/in_systm.h>
  43 #include <netinet/ip.h>
  44 #include <sys/time.h>
  45 #include <sys/signal.h>
  46 #include <signal.h>
  47 #include <pthread.h>
  48 #include <stdlib.h>
  49 #include <stdio.h>
  50 #include <string.h>
  51 #include <errno.h>
  52 #include <unistd.h>
  53 #include <netdb.h>
  54 #include <fcntl.h>
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57 #ifdef IAX_TRUNKING
  58 #include <sys/ioctl.h>
  59 #include <linux/zaptel.h>
  60 #endif
  61 #ifdef MYSQL_FRIENDS
  62 #include <mysql/mysql.h>
  63 #endif
  64 #include "iax2.h"
  65 #include "iax2-parser.h"
  66 #include "../astconf.h"
  67
  68 #ifndef IPTOS_MINCOST
  69 #define IPTOS_MINCOST 0x02
  70 #endif
  71
  72 /*
  73  * Uncomment to try experimental IAX bridge optimization,
  74  * designed to reduce latency when IAX calls cannot
  75  * be trasnferred
  76  */
  77
  78 #define BRIDGE_OPTIMIZATION
  79
  80 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
  81 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
  82
  83 #define DEFAULT_RETRY_TIME 1000
  84 #define MEMORY_SIZE 100
  85 #define DEFAULT_DROP 3
  86 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
  87    but keeps the division between trunked and non-trunked better. */
  88 #define TRUNK_CALL_START        0x4000
  89
  90 #define DEBUG_SUPPORT
  91
  92 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
  93
  94 /* Sample over last 100 units to determine historic jitter */
  95 #define GAMMA (0.01)
  96
  97 #ifdef MYSQL_FRIENDS
  98 static ast_mutex_t mysqllock = AST_MUTEX_INITIALIZER;
  99 static MYSQL *mysql;
 100 static char mydbuser[80];
 101 static char mydbpass[80];
 102 static char mydbhost[80];
 103 static char mydbname[80];
 104 #endif
 105 static char *desc = "Inter Asterisk eXchange (Ver 2)";
 106 static char *tdesc = "Inter Asterisk eXchange Driver (Ver 2)";
 107 static char *type = "IAX2";
 108
 109 static char context[80] = "default";
 110
 111 static int max_retries = 4;
 112 static int ping_time = 20;
 113 static int lagrq_time = 10;
 114 static int maxtrunkcall = TRUNK_CALL_START;
 115 static int maxnontrunkcall = 1;
 116 static int maxjitterbuffer=3000;
 117 static int trunkfreq = 20;
 118 static int authdebug = 1;
 119 static int iaxcompat = 0;
 120
 121 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
 122
 123 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
 124
 125 static int netsocket = -1;
 126
 127 static int tos = 0;
 128
 129 static int expirey = IAX_DEFAULT_REG_EXPIRE;
 130
 131 static int timingfd = -1;                               /* Timing file descriptor */
 132
 133 static int usecnt;
 134 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
 135
 136 int (*iax2_regfunk)(char *username, int onoff) = NULL;
 137
 138 /* Ethernet, etc */
 139 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
 140 /* T1, maybe ISDN */
 141 #define IAX_CAPABILITY_MEDBANDWIDTH     (IAX_CAPABILITY_FULLBANDWIDTH & \
 142                                                                         ~AST_FORMAT_SLINEAR & \
 143                                                                         ~AST_FORMAT_ULAW & \
 144                                                                         ~AST_FORMAT_ALAW)
 145 /* A modem */
 146 #define IAX_CAPABILITY_LOWBANDWIDTH             (IAX_CAPABILITY_MEDBANDWIDTH & \
 147                                                                         ~AST_FORMAT_G726 & \
 148                                                                         ~AST_FORMAT_ADPCM)
 149
 150 #define IAX_CAPABILITY_LOWFREE          (IAX_CAPABILITY_LOWBANDWIDTH & \
 151                                                                          ~AST_FORMAT_G723_1)
 152
 153
 154 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
 155 #define DEFAULT_FREQ_OK         60 * 1000               /* How often to check for the host to be up */
 156 #define DEFAULT_FREQ_NOTOK      10 * 1000               /* How often to check, if the host is down... */
 157
 158 static  struct io_context *io;
 159 static  struct sched_context *sched;
 160
 161 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
 162
 163 static int iax2_dropcount = DEFAULT_DROP;
 164
 165 static int use_jitterbuffer = 0;
 166
 167 static int iaxdebug = 0;
 168
 169 static int iaxtrunkdebug = 0;
 170
 171 static char accountcode[20];
 172 static int amaflags = 0;
 173 static int notransfer = 0;
 174
 175 static pthread_t netthreadid = AST_PTHREADT_NULL;
 176
 177 #define IAX_STATE_STARTED               (1 << 0)
 178 #define IAX_STATE_AUTHENTICATED (1 << 1)
 179 #define IAX_STATE_TBD                   (1 << 2)
 180
 181 struct iax2_context {
 182         char context[AST_MAX_EXTENSION];
 183         struct iax2_context *next;
 184 };
 185
 186 struct iax2_user {
 187         char name[80];
 188         char secret[80];
 189         int authmethods;
 190         char accountcode[20];
 191         char inkeys[80];                                /* Key(s) this user can use to authenticate to us */
 192         int amaflags;
 193         int hascallerid;
 194         int delme;
 195         int temponly;
 196         int capability;
 197         int trunk;
 198         char callerid[AST_MAX_EXTENSION];
 199         struct ast_ha *ha;
 200         struct iax2_context *contexts;
 201         struct iax2_user *next;
 202         int notransfer;
 203 };
 204
 205 struct iax2_peer {
 206         char name[80];
 207         char username[80];
 208         char secret[80];
 209         char outkey[80];                /* What key we use to talk to this peer */
 210         char context[AST_MAX_EXTENSION];        /* Default context (for transfer really) */
 211         char mailbox[AST_MAX_EXTENSION];        /* Mailbox */
 212         struct sockaddr_in addr;
 213         int formats;
 214         struct in_addr mask;
 215
 216         /* Dynamic Registration fields */
 217         int dynamic;                                    /* If this is a dynamic peer */
 218         struct sockaddr_in defaddr;             /* Default address if there is one */
 219         int authmethods;                                /* Authentication methods (IAX_AUTH_*) */
 220         char inkeys[80];                                /* Key(s) this peer can use to authenticate to us */
 221
 222         int hascallerid;
 223         /* Suggested caller id if registering */
 224         char callerid[AST_MAX_EXTENSION];
 225         /* Whether or not to send ANI */
 226         int sendani;
 227         int expire;                                             /* Schedule entry for expirey */
 228         int expirey;                                    /* How soon to expire */
 229         int capability;                                 /* Capability */
 230         int delme;                                              /* I need to be deleted */
 231         int temponly;                                   /* I'm only a temp */
 232         int trunk;                                              /* Treat as an IAX trunking */
 233         struct timeval txtrunktime;             /* Transmit trunktime */
 234         struct timeval rxtrunktime;             /* Receive trunktime */
 235         struct timeval lasttxtime;              /* Last transmitted trunktime */
 236         unsigned int lastsent;                  /* Last sent time */
 237
 238         /* Qualification */
 239         int callno;                                     /* Call number of POKE request */
 240         int pokeexpire;                                 /* When to expire poke */
 241         int lastms;                                     /* How long last response took (in ms), or -1 for no response */
 242         int maxms;                                      /* Max ms we will accept for the host to be up, 0 to not monitor */
 243
 244         struct ast_ha *ha;
 245         struct iax2_peer *next;
 246         int notransfer;
 247 };
 248
 249 struct iax_firmware {
 250         struct iax_firmware *next;
 251         int fd;
 252         int mmaplen;
 253         int dead;
 254         struct ast_iax2_firmware_header *fwh;
 255         unsigned char *buf;
 256 };
 257
 258 #define REG_STATE_UNREGISTERED 0
 259 #define REG_STATE_REGSENT          1
 260 #define REG_STATE_AUTHSENT         2
 261 #define REG_STATE_REGISTERED   3
 262 #define REG_STATE_REJECTED         4
 263 #define REG_STATE_TIMEOUT          5
 264 #define REG_STATE_NOAUTH           6
 265
 266 #define TRANSFER_NONE                   0
 267 #define TRANSFER_BEGIN                  1
 268 #define TRANSFER_READY                  2
 269 #define TRANSFER_RELEASED               3
 270 #define TRANSFER_PASSTHROUGH    4
 271
 272 struct iax2_registry {
 273         struct sockaddr_in addr;                /* Who we connect to for registration purposes */
 274         char username[80];
 275         char secret[80];                        /* Password or key name in []'s */
 276         char random[80];
 277         int expire;                                             /* Sched ID of expiration */
 278         int refresh;                                    /* How often to refresh */
 279         int regstate;
 280         int messages;                                   /* Message count */
 281         int callno;                                             /* Associated call number if applicable */
 282         struct sockaddr_in us;                  /* Who the server thinks we are */
 283         struct iax2_registry *next;
 284 };
 285
 286 static struct iax2_registry *registrations;
 287
 288 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
 289 #define MIN_RETRY_TIME  100
 290 #define MAX_RETRY_TIME  10000
 291 #define MAX_JITTER_BUFFER 50
 292
 293 #define MAX_TRUNKDATA   640             /* 40ms, uncompressed linear */
 294
 295 /* If we have more than this much excess real jitter buffer, srhink it. */
 296 static int max_jitter_buffer = MAX_JITTER_BUFFER;
 297
 298 struct chan_iax2_pvt {
 299         /* Pipes for communication.  pipe[1] belongs to the
 300            network thread (write), and pipe[0] belongs to the individual
 301            channel (read) */
 302         /* Whether or not we Quelch audio */
 303         int quelch;
 304         /* Last received voice format */
 305         int voiceformat;
 306         /* Last received voice format */
 307         int videoformat;
 308         /* Last sent voice format */
 309         int svoiceformat;
 310         /* Last sent video format */
 311         int svideoformat;
 312         /* What we are capable of sending */
 313         int capability;
 314         /* Last received timestamp */
 315         unsigned int last;
 316         /* Last sent timestamp - never send the same timestamp twice in a single call */
 317         unsigned int lastsent;
 318         /* Ping time */
 319         unsigned int pingtime;
 320         /* Max time for initial response */
 321         int maxtime;
 322         /* Peer Address */
 323         struct sockaddr_in addr;
 324         /* Our call number */
 325         unsigned short callno;
 326         /* Peer callno */
 327         unsigned short peercallno;
 328         /* Peer selected format */
 329         int peerformat;
 330         /* Peer capability */
 331         int peercapability;
 332         /* timeval that we base our transmission on */
 333         struct timeval offset;
 334         /* timeval that we base our delivery on */
 335         struct timeval rxcore;
 336         /* Historical delivery time */
 337         int history[MEMORY_SIZE];
 338         /* Current base jitterbuffer */
 339         int jitterbuffer;
 340         /* Current jitter measure */
 341         int jitter;
 342         /* Historic jitter value */
 343         int historicjitter;
 344         /* LAG */
 345         int lag;
 346         /* Error, as discovered by the manager */
 347         int error;
 348         /* Owner if we have one */
 349         struct ast_channel *owner;
 350         /* What's our state? */
 351         int state;
 352         /* Expirey (optional) */
 353         int expirey;
 354         /* Next outgoing sequence number */
 355         unsigned char oseqno;
 356         /* Next sequence number they have not yet acknowledged */
 357         unsigned char rseqno;
 358         /* Next incoming sequence number */
 359         unsigned char iseqno;
 360         /* Last incoming sequence number we have acknowledged */
 361         unsigned char aseqno;
 362         /* Peer name */
 363         char peer[80];
 364         /* Default Context */
 365         char context[80];
 366         /* Caller ID if available */
 367         char callerid[80];
 368         /* Hidden Caller ID (i.e. ANI) if appropriate */
 369         char ani[80];
 370         /* Whether or not ani should be transmitted in addition to Caller*ID */
 371         int sendani;
 372         /* Whether to request autoanswer */
 373         int autoanswer;
 374         /* DNID */
 375         char dnid[80];
 376         /* Requested Extension */
 377         char exten[AST_MAX_EXTENSION];
 378         /* Expected Username */
 379         char username[80];
 380         /* Expected Secret */
 381         char secret[80];
 382         /* permitted authentication methods */
 383         int authmethods;
 384         /* MD5 challenge */
 385         char challenge[10];
 386         /* Public keys permitted keys for incoming authentication */
 387         char inkeys[80];
 388         /* Private key for outgoing authentication */
 389         char outkey[80];
 390         /* Preferred language */
 391         char language[80];
 392         /* Hostname/peername for naming purposes */
 393         char host[80];
 394         /* Associated registry */
 395         struct iax2_registry *reg;
 396         /* Associated peer for poking */
 397         struct iax2_peer *peerpoke;
 398
 399         /* Transferring status */
 400         int transferring;
 401         /* Transfer identifier */
 402         int transferid;
 403         /* Already disconnected */
 404         int alreadygone;
 405         /* Who we are IAX transfering to */
 406         struct sockaddr_in transfer;
 407         /* What's the new call number for the transfer */
 408         unsigned short transfercallno;
 409
 410         /* Status of knowledge of peer ADSI capability */
 411         int peeradsicpe;
 412
 413         /* Who we are bridged to */
 414         unsigned short bridgecallno;
 415         unsigned int bridgesfmt;
 416         struct ast_trans_pvt *bridgetrans;
 417
 418         int pingid;                     /* Transmit PING request */
 419         int lagid;                      /* Retransmit lag request */
 420         int autoid;                     /* Auto hangup for Dialplan requestor */
 421         int initid;                     /* Initial peer auto-congest ID (based on qualified peers) */
 422         char dproot[AST_MAX_EXTENSION];
 423         char accountcode[20];
 424         int amaflags;
 425         /* This is part of a trunk interface */
 426         int trunk;
 427         /* Trunk data and length */
 428         unsigned char trunkdata[MAX_TRUNKDATA];
 429         unsigned int trunkdatalen;
 430         int trunkerror;
 431         struct iax2_dpcache *dpentries;
 432         int notransfer;         /* do we want native bridging */
 433 };
 434
 435 static struct ast_iax2_queue {
 436         struct iax_frame *head;
 437         struct iax_frame *tail;
 438         int count;
 439         ast_mutex_t lock;
 440 } iaxq;
 441
 442 static struct ast_user_list {
 443         struct iax2_user *users;
 444         ast_mutex_t lock;
 445 } userl;
 446
 447 static struct ast_peer_list {
 448         struct iax2_peer *peers;
 449         ast_mutex_t lock;
 450 } peerl;
 451
 452 static struct ast_firmware_list {
 453         struct iax_firmware *wares;
 454         ast_mutex_t lock;
 455 } waresl;
 456
 457 /* Extension exists */
 458 #define CACHE_FLAG_EXISTS               (1 << 0)
 459 /* Extension is non-existant */
 460 #define CACHE_FLAG_NONEXISTANT  (1 << 1)
 461 /* Extension can exist */
 462 #define CACHE_FLAG_CANEXIST             (1 << 2)
 463 /* Waiting to hear back response */
 464 #define CACHE_FLAG_PENDING              (1 << 3)
 465 /* Timed out */
 466 #define CACHE_FLAG_TIMEOUT              (1 << 4)
 467 /* Request transmitted */
 468 #define CACHE_FLAG_TRANSMITTED  (1 << 5)
 469 /* Timeout */
 470 #define CACHE_FLAG_UNKNOWN              (1 << 6)
 471 /* Matchmore */
 472 #define CACHE_FLAG_MATCHMORE    (1 << 7)
 473
 474 static struct iax2_dpcache {
 475         char peercontext[AST_MAX_EXTENSION];
 476         char exten[AST_MAX_EXTENSION];
 477         struct timeval orig;
 478         struct timeval expirey;
 479         int flags;
 480         unsigned short callno;
 481         int waiters[256];
 482         struct iax2_dpcache *next;
 483         struct iax2_dpcache *peer;      /* For linking in peers */
 484 } *dpcache;
 485
 486 static ast_mutex_t dpcache_lock;
 487
 488 static void iax_debug_output(const char *data)
 489 {
 490         ast_verbose(data);
 491 }
 492
 493 static void iax_error_output(const char *data)
 494 {
 495         ast_log(LOG_WARNING, data);
 496 }
 497
 498 /* XXX We probably should use a mutex when working with this XXX */
 499 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
 500 static ast_mutex_t iaxsl[IAX_MAX_CALLS];
 501 static struct timeval lastused[IAX_MAX_CALLS];
 502
 503
 504 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, char *, int, int);
 505 static int send_command_locked(unsigned short callno, char, int, unsigned int, char *, int, int);
 506 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, char *, int, int);
 507 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, char *, int, int);
 508 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, char *, int);
 509
 510 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct timeval *tv);
 511
 512 static int send_ping(void *data)
 513 {
 514         int callno = (long)data;
 515         /* Ping only if it's real, not if it's bridged */
 516         if (iaxs[callno]) {
 517 #ifdef BRIDGE_OPTIMIZATION
 518                 if (!iaxs[callno]->bridgecallno)
 519 #endif
 520                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
 521                 return 1;
 522         } else
 523                 return 0;
 524 }
 525
 526 static int send_lagrq(void *data)
 527 {
 528         int callno = (long)data;
 529         /* Ping only if it's real not if it's bridged */
 530         if (iaxs[callno]) {
 531 #ifdef BRIDGE_OPTIMIZATION
 532                 if (!iaxs[callno]->bridgecallno)
 533 #endif
 534                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
 535                 return 1;
 536         } else
 537                 return 0;
 538 }
 539
 540 static unsigned char compress_subclass(int subclass)
 541 {
 542         int x;
 543         int power=-1;
 544         /* If it's 128 or smaller, just return it */
 545         if (subclass < IAX_FLAG_SC_LOG)
 546                 return subclass;
 547         /* Otherwise find its power */
 548         for (x = 0; x < IAX_MAX_SHIFT; x++) {
 549                 if (subclass & (1 << x)) {
 550                         if (power > -1) {
 551                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
 552                                 return 0;
 553                         } else
 554                                 power = x;
 555                 }
 556         }
 557         return power | IAX_FLAG_SC_LOG;
 558 }
 559
 560 static int uncompress_subclass(unsigned char csub)
 561 {
 562         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
 563         if (csub & IAX_FLAG_SC_LOG) {
 564                 /* special case for 'compressed' -1 */
 565                 if (csub == 0xff)
 566                         return -1;
 567                 else
 568                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
 569         }
 570         else
 571                 return csub;
 572 }
 573
 574 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
 575 {
 576         struct iax2_peer *peer;
 577         int res = 0;
 578         if (lockpeer)
 579                 ast_mutex_lock(&peerl.lock);
 580         peer = peerl.peers;
 581         while(peer) {
 582                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
 583                                 (peer->addr.sin_port == sin.sin_port)) {
 584                                         strncpy(host, peer->name, len-1);
 585                                         res = 1;
 586                                         break;
 587                 }
 588                 peer = peer->next;
 589         }
 590         if (lockpeer)
 591                 ast_mutex_unlock(&peerl.lock);
 592         return res;
 593 }
 594
 595 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer)
 596 {
 597         struct chan_iax2_pvt *tmp;
 598         tmp = malloc(sizeof(struct chan_iax2_pvt));
 599         if (tmp) {
 600                 memset(tmp, 0, sizeof(struct chan_iax2_pvt));
 601                 tmp->callno = 0;
 602                 tmp->peercallno = 0;
 603                 tmp->transfercallno = 0;
 604                 tmp->bridgecallno = 0;
 605                 tmp->pingid = -1;
 606                 tmp->lagid = -1;
 607                 tmp->autoid = -1;
 608                 tmp->initid = -1;
 609                 /* strncpy(tmp->context, context, sizeof(tmp->context)-1); */
 610                 strncpy(tmp->exten, "s", sizeof(tmp->exten)-1);
 611                 if (!iax2_getpeername(*sin, tmp->host, sizeof(tmp->host), lockpeer))
 612                         snprintf(tmp->host, sizeof(tmp->host), "%s:%d", inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
 613         }
 614         return tmp;
 615 }
 616
 617 static int get_samples(struct ast_frame *f)
 618 {
 619         int samples=0;
 620         switch(f->subclass) {
 621         case AST_FORMAT_SPEEX:
 622                 samples = 160;  /* XXX Not necessarily true XXX */
 623                 break;
 624         case AST_FORMAT_G723_1:
 625                 samples = 240 /* XXX Not necessarily true XXX */;
 626                 break;
 627         case AST_FORMAT_ILBC:
 628                 samples = 240 * (f->datalen / 50);
 629                 break;
 630         case AST_FORMAT_GSM:
 631                 samples = 160 * (f->datalen / 33);
 632                 break;
 633         case AST_FORMAT_G729A:
 634                 samples = 160 * (f->datalen / 20);
 635                 break;
 636         case AST_FORMAT_SLINEAR:
 637                 samples = f->datalen / 2;
 638                 break;
 639         case AST_FORMAT_LPC10:
 640                 samples = 22 * 8;
 641                 samples += (((char *)(f->data))[7] & 0x1) * 8;
 642                 break;
 643         case AST_FORMAT_ULAW:
 644                 samples = f->datalen;
 645                 break;
 646         case AST_FORMAT_ALAW:
 647                 samples = f->datalen;
 648                 break;
 649         case AST_FORMAT_ADPCM:
 650         case AST_FORMAT_G726:
 651                 samples = f->datalen *2;
 652                 break;
 653         default:
 654                 ast_log(LOG_WARNING, "Don't know how to calculate samples on %d packets\n", f->subclass);
 655         }
 656         return samples;
 657 }
 658
 659 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
 660 {
 661         /* Malloc() a copy of a frame */
 662         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen);
 663         if (new) {
 664                 memcpy(new, fr, sizeof(struct iax_frame));
 665                 iax_frame_wrap(new, &fr->af);
 666                 new->data = NULL;
 667                 new->datalen = 0;
 668                 new->direction = DIRECTION_INGRESS;
 669                 new->retrans = -1;
 670         }
 671         return new;
 672 }
 673
 674 #define NEW_PREVENT 0
 675 #define NEW_ALLOW       1
 676 #define NEW_FORCE       2
 677
 678 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, struct chan_iax2_pvt *cur)
 679 {
 680         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
 681                 (cur->addr.sin_port == sin->sin_port)) {
 682                 /* This is the main host */
 683                 if ((cur->peercallno == callno) ||
 684                         ((dcallno == cur->callno) && !cur->peercallno)) {
 685                         /* That's us.  Be sure we keep track of the peer call number */
 686                         return 1;
 687                 }
 688         }
 689         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
 690             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
 691                 /* We're transferring */
 692                 if (dcallno == cur->callno)
 693                         return 1;
 694         }
 695         return 0;
 696 }
 697
 698 static void update_max_trunk(void)
 699 {
 700         int max = TRUNK_CALL_START;
 701         int x;
 702         /* XXX Prolly don't need locks here XXX */
 703         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
 704                 if (iaxs[x])
 705                         max = x + 1;
 706         }
 707         maxtrunkcall = max;
 708         if (option_debug)
 709                 ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max);
 710 }
 711
 712 static void update_max_nontrunk(void)
 713 {
 714         int max = 1;
 715         int x;
 716         /* XXX Prolly don't need locks here XXX */
 717         for (x=1;x<TRUNK_CALL_START - 1; x++) {
 718                 if (iaxs[x])
 719                         max = x + 1;
 720         }
 721         maxnontrunkcall = max;
 722         if (option_debug)
 723                 ast_log(LOG_DEBUG, "New max nontrunk callno is %d\n", max);
 724 }
 725
 726 static int make_trunk(unsigned short callno, int locked)
 727 {
 728         int x;
 729         int res= 0;
 730         struct timeval now;
 731         if (iaxs[callno]->oseqno) {
 732                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
 733                 return -1;
 734         }
 735         if (callno & TRUNK_CALL_START) {
 736                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
 737                 return -1;
 738         }
 739         gettimeofday(&now, NULL);
 740         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
 741                 ast_mutex_lock(&iaxsl[x]);
 742                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
 743                         iaxs[x] = iaxs[callno];
 744                         iaxs[x]->callno = x;
 745                         iaxs[callno] = NULL;
 746                         /* Update the two timers that should have been started */
 747                         if (iaxs[x]->pingid > -1)
 748                                 ast_sched_del(sched, iaxs[x]->pingid);
 749                         if (iaxs[x]->lagid > -1)
 750                                 ast_sched_del(sched, iaxs[x]->lagid);
 751                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)x);
 752                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)x);
 753                         if (locked)
 754                                 ast_mutex_unlock(&iaxsl[callno]);
 755                         res = x;
 756                         if (!locked)
 757                                 ast_mutex_unlock(&iaxsl[x]);
 758                         break;
 759                 }
 760                 ast_mutex_unlock(&iaxsl[x]);
 761         }
 762         if (x >= IAX_MAX_CALLS - 1) {
 763                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
 764                 return -1;
 765         }
 766         ast_log(LOG_DEBUG, "Made call %d into trunk call %d\n", callno, x);
 767         /* We move this call from a non-trunked to a trunked call */
 768         update_max_trunk();
 769         update_max_nontrunk();
 770         return res;
 771 }
 772
 773 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer)
 774 {
 775         int res = 0;
 776         int x;
 777         struct timeval now;
 778         if (new <= NEW_ALLOW) {
 779                 /* Look for an existing connection first */
 780                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
 781                         ast_mutex_lock(&iaxsl[x]);
 782                         if (iaxs[x]) {
 783                                 /* Look for an exact match */
 784                                 if (match(sin, callno, dcallno, iaxs[x])) {
 785                                         res = x;
 786                                 }
 787                         }
 788                         ast_mutex_unlock(&iaxsl[x]);
 789                 }
 790                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
 791                         ast_mutex_lock(&iaxsl[x]);
 792                         if (iaxs[x]) {
 793                                 /* Look for an exact match */
 794                                 if (match(sin, callno, dcallno, iaxs[x])) {
 795                                         res = x;
 796                                 }
 797                         }
 798                         ast_mutex_unlock(&iaxsl[x]);
 799                 }
 800         }
 801         if ((res < 1) && (new >= NEW_ALLOW)) {
 802                 gettimeofday(&now, NULL);
 803                 for (x=1;x<TRUNK_CALL_START;x++) {
 804                         /* Find first unused call number that hasn't been used in a while */
 805                         ast_mutex_lock(&iaxsl[x]);
 806                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
 807                         ast_mutex_unlock(&iaxsl[x]);
 808                 }
 809                 /* We've still got lock held if we found a spot */
 810                 if (x >= TRUNK_CALL_START) {
 811                         ast_log(LOG_WARNING, "No more space\n");
 812                         return -1;
 813                 }
 814                 iaxs[x] = new_iax(sin, lockpeer);
 815                 ast_mutex_unlock(&iaxsl[x]);
 816                 update_max_nontrunk();
 817                 if (iaxs[x]) {
 818                         if (option_debug)
 819                                 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
 820                         iaxs[x]->addr.sin_port = sin->sin_port;
 821                         iaxs[x]->addr.sin_family = sin->sin_family;
 822                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
 823                         iaxs[x]->peercallno = callno;
 824                         iaxs[x]->callno = x;
 825                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
 826                         iaxs[x]->expirey = expirey;
 827                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)x);
 828                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)x);
 829                         iaxs[x]->amaflags = amaflags;
 830                         iaxs[x]->notransfer = notransfer;
 831                         strncpy(iaxs[x]->accountcode, accountcode, sizeof(iaxs[x]->accountcode)-1);
 832                 } else {
 833                         ast_log(LOG_WARNING, "Out of resources\n");
 834                         return 0;
 835                 }
 836                 res = x;
 837         }
 838         return res;
 839 }
 840
 841 static void iax2_frame_free(struct iax_frame *fr)
 842 {
 843         if (fr->retrans > -1)
 844                 ast_sched_del(sched, fr->retrans);
 845         iax_frame_free(fr);
 846 }
 847
 848 static int iax2_queue_frame(int callno, struct ast_frame *f)
 849 {
 850         int pass =0;
 851         /* Assumes lock for callno is already held... */
 852         for (;;) {
 853                 pass++;
 854                 if (!ast_mutex_trylock(&iaxsl[callno])) {
 855                         ast_log(LOG_WARNING, "Lock is not held on pass %d of iax2_queue_frame\n", pass);
 856                         CRASH;
 857                 }
 858                 if (iaxs[callno] && iaxs[callno]->owner) {
 859                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
 860                                 /* Avoid deadlock by pausing and trying again */
 861                                 ast_mutex_unlock(&iaxsl[callno]);
 862                                 usleep(1);
 863                                 ast_mutex_lock(&iaxsl[callno]);
 864                         } else {
 865                                 ast_queue_frame(iaxs[callno]->owner, f, 0);
 866                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
 867                                 break;
 868                         }
 869                 } else
 870                         break;
 871         }
 872         return 0;
 873 }
 874
 875 static void destroy_firmware(struct iax_firmware *cur)
 876 {
 877         /* Close firmware */
 878         if (cur->fwh) {
 879                 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
 880         }
 881         close(cur->fd);
 882         free(cur);
 883 }
 884
 885 static int try_firmware(char *s)
 886 {
 887         struct stat stbuf;
 888         struct iax_firmware *cur;
 889         int fd;
 890         int res;
 891         struct ast_iax2_firmware_header *fwh, fwh2;
 892         struct MD5Context md5;
 893         unsigned char sum[16];
 894         res = stat(s, &stbuf);
 895         if (res < 0) {
 896                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
 897                 return -1;
 898         }
 899         /* Make sure it's not a directory */
 900         if (S_ISDIR(stbuf.st_mode))
 901                 return -1;
 902         fd = open(s, O_RDONLY);
 903         if (fd < 0) {
 904                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
 905                 return -1;
 906         }
 907         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
 908                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
 909                 close(fd);
 910                 return -1;
 911         }
 912         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
 913                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
 914                 close(fd);
 915                 return -1;
 916         }
 917         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
 918                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
 919                 close(fd);
 920                 return -1;
 921         }
 922         if (fwh2.devname[sizeof(fwh2.devname) - 1] || !strlen(fwh2.devname)) {
 923                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
 924                 close(fd);
 925                 return -1;
 926         }
 927         fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 928         if (!fwh) {
 929                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
 930                 close(fd);
 931                 return -1;
 932         }
 933         MD5Init(&md5);
 934         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
 935         MD5Final(sum, &md5);
 936         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
 937                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
 938                 munmap(fwh, stbuf.st_size);
 939                 close(fd);
 940                 return -1;
 941         }
 942         cur = waresl.wares;
 943         while(cur) {
 944                 if (!strcmp(cur->fwh->devname, fwh->devname)) {
 945                         /* Found a candidate */
 946                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
 947                                 /* The version we have on loaded is older, load this one instead */
 948                                 break;
 949                         /* This version is no newer than what we have.  Don't worry about it.
 950                            We'll consider it a proper load anyhow though */
 951                         munmap(fwh, stbuf.st_size);
 952                         close(fd);
 953                         return 0;
 954                 }
 955                 cur = cur->next;
 956         }
 957         if (!cur) {
 958                 /* Allocate a new one and link it */
 959                 cur = malloc(sizeof(struct iax_firmware));
 960                 if (cur) {
 961                         memset(cur, 0, sizeof(struct iax_firmware));
 962                         cur->fd = -1;
 963                         cur->next = waresl.wares;
 964                         waresl.wares = cur;
 965                 }
 966         }
 967         if (cur) {
 968                 if (cur->fwh) {
 969                         munmap(cur->fwh, cur->mmaplen);
 970                 }
 971                 if (cur->fd > -1)
 972                         close(cur->fd);
 973                 cur->fwh = fwh;
 974                 cur->fd = fd;
 975                 cur->mmaplen = stbuf.st_size;
 976                 cur->dead = 0;
 977         }
 978         return 0;
 979 }
 980
 981 static int iax_check_version(char *dev)
 982 {
 983         int res = 0;
 984         struct iax_firmware *cur;
 985         if (dev && strlen(dev)) {
 986                 ast_mutex_lock(&waresl.lock);
 987                 cur = waresl.wares;
 988                 while(cur) {
 989                         if (!strcmp(dev, cur->fwh->devname)) {
 990                                 res = ntohs(cur->fwh->version);
 991                                 break;
 992                         }
 993                         cur = cur->next;
 994                 }
 995                 ast_mutex_unlock(&waresl.lock);
 996         }
 997         return res;
 998 }
 999
1000 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1001 {
1002         int res = -1;
1003         unsigned int bs = desc & 0xff;
1004         unsigned int start = (desc >> 8) & 0xffffff;
1005         unsigned int bytes;
1006         struct iax_firmware *cur;
1007         if (dev && strlen(dev) && bs) {
1008                 start *= bs;
1009                 ast_mutex_lock(&waresl.lock);
1010                 cur = waresl.wares;
1011                 while(cur) {
1012                         if (!strcmp(dev, cur->fwh->devname)) {
1013                                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1014                                 if (start < ntohl(cur->fwh->datalen)) {
1015                                         bytes = ntohl(cur->fwh->datalen) - start;
1016                                         if (bytes > bs)
1017                                                 bytes = bs;
1018                                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1019                                 } else {
1020                                         bytes = 0;
1021                                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1022                                 }
1023                                 if (bytes == bs)
1024                                         res = 0;
1025                                 else
1026                                         res = 1;
1027                                 break;
1028                         }
1029                         cur = cur->next;
1030                 }
1031                 ast_mutex_unlock(&waresl.lock);
1032         }
1033         return res;
1034 }
1035
1036
1037 static void reload_firmware(void)
1038 {
1039         struct iax_firmware *cur, *curl, *curp;
1040         DIR *fwd;
1041         struct dirent *de;
1042         char dir[256];
1043         char fn[256];
1044         /* Mark all as dead */
1045         ast_mutex_lock(&waresl.lock);
1046         cur = waresl.wares;
1047         while(cur) {
1048                 cur->dead = 1;
1049                 cur = cur->next;
1050         }
1051         /* Now that we've freed them, load the new ones */
1052         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_VAR_DIR);
1053         fwd = opendir(dir);
1054         if (fwd) {
1055                 while((de = readdir(fwd))) {
1056                         if (de->d_name[0] != '.') {
1057                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1058                                 if (!try_firmware(fn)) {
1059                                         if (option_verbose > 1)
1060                                                 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1061                                 }
1062                         }
1063                 }
1064                 closedir(fwd);
1065         } else
1066                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1067
1068         /* Clean up leftovers */
1069         cur = waresl.wares;
1070         curp = NULL;
1071         while(cur) {
1072                 curl = cur;
1073                 cur = cur->next;
1074                 if (curl->dead) {
1075                         if (curp) {
1076                                 curp->next = cur;
1077                         } else {
1078                                 waresl.wares = cur;
1079                         }
1080                         destroy_firmware(curl);
1081                 } else {
1082                         curp = cur;
1083                 }
1084         }
1085         ast_mutex_unlock(&waresl.lock);
1086 }
1087
1088 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1089
1090 static int __do_deliver(void *data)
1091 {
1092         /* Just deliver the packet by using queueing.  This is called by
1093           the IAX thread with the iaxsl lock held. */
1094         struct iax_frame *fr = data;
1095         unsigned int ts;
1096         fr->retrans = -1;
1097         if (iaxs[fr->callno] && !iaxs[fr->callno]->alreadygone) {
1098                 if (fr->af.frametype == AST_FRAME_IAX) {
1099                         /* We have to treat some of these packets specially because
1100                            they're LAG measurement packets */
1101                         if (fr->af.subclass == IAX_COMMAND_LAGRQ) {
1102                                 /* If we got a queued request, build a reply and send it */
1103                                 fr->af.subclass = IAX_COMMAND_LAGRP;
1104                                 iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
1105                         } else if (fr->af.subclass == IAX_COMMAND_LAGRP) {
1106                                 /* This is a reply we've been given, actually measure the difference */
1107                                 ts = calc_timestamp(iaxs[fr->callno], 0, NULL);
1108                                 iaxs[fr->callno]->lag = ts - fr->ts;
1109                         }
1110                 } else {
1111                         iax2_queue_frame(fr->callno, &fr->af);
1112                 }
1113         }
1114         /* Free our iax frame */
1115         iax2_frame_free(fr);
1116         /* And don't run again */
1117         return 0;
1118 }
1119
1120 static int do_deliver(void *data)
1121 {
1122         /* Locking version of __do_deliver */
1123         struct iax_frame *fr = data;
1124         int callno = fr->callno;
1125         int res;
1126         ast_mutex_lock(&iaxsl[callno]);
1127         res = __do_deliver(data);
1128         ast_mutex_unlock(&iaxsl[callno]);
1129         return res;
1130 }
1131
1132 static int handle_error(void)
1133 {
1134         /* XXX Ideally we should figure out why an error occured and then abort those
1135            rather than continuing to try.  Unfortunately, the published interface does
1136            not seem to work XXX */
1137 #if 0
1138         struct sockaddr_in *sin;
1139         int res;
1140         struct msghdr m;
1141         struct sock_extended_err e;
1142         m.msg_name = NULL;
1143         m.msg_namelen = 0;
1144         m.msg_iov = NULL;
1145         m.msg_control = &e;
1146         m.msg_controllen = sizeof(e);
1147         m.msg_flags = 0;
1148         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1149         if (res < 0)
1150                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1151         else {
1152                 if (m.msg_controllen) {
1153                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1154                         if (sin)
1155                                 ast_log(LOG_WARNING, "Receive error from %s\n", inet_ntoa(sin->sin_addr));
1156                         else
1157                                 ast_log(LOG_WARNING, "No address detected??\n");
1158                 } else {
1159                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1160                 }
1161         }
1162 #endif
1163         return 0;
1164 }
1165
1166 static int send_packet(struct iax_frame *f)
1167 {
1168         int res;
1169         /* Called with iaxsl held */
1170         if (option_debug)
1171                 ast_log(LOG_DEBUG, "Sending %d on %d/%d to %s:%d\n", f->ts, f->callno, iaxs[f->callno]->peercallno, inet_ntoa(iaxs[f->callno]->addr.sin_addr), ntohs(iaxs[f->callno]->addr.sin_port));
1172         /* Don't send if there was an error, but return error instead */
1173         if (!f->callno) {
1174                 ast_log(LOG_WARNING, "Call number = %d\n", f->callno);
1175                 return -1;
1176         }
1177         if (!iaxs[f->callno])
1178                 return -1;
1179         if (iaxs[f->callno]->error)
1180                 return -1;
1181         if (f->transfer) {
1182                 if (iaxdebug)
1183                         iax_showframe(f, NULL, 0, &iaxs[f->callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1184                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->transfer,
1185                                         sizeof(iaxs[f->callno]->transfer));
1186         } else {
1187                 if (iaxdebug)
1188                         iax_showframe(f, NULL, 0, &iaxs[f->callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1189                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->addr,
1190                                         sizeof(iaxs[f->callno]->addr));
1191         }
1192         if (res < 0) {
1193                 if (option_debug)
1194                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1195                 handle_error();
1196         } else
1197                 res = 0;
1198         return res;
1199 }
1200
1201
1202 static int iax2_predestroy(int callno)
1203 {
1204         struct ast_channel *c;
1205         struct chan_iax2_pvt *pvt;
1206         ast_mutex_lock(&iaxsl[callno]);
1207         pvt = iaxs[callno];
1208         if (!pvt) {
1209                 ast_mutex_unlock(&iaxsl[callno]);
1210                 return -1;
1211         }
1212         if (!pvt->alreadygone) {
1213                 /* No more pings or lagrq's */
1214                 if (pvt->pingid > -1)
1215                         ast_sched_del(sched, pvt->pingid);
1216                 if (pvt->lagid > -1)
1217                         ast_sched_del(sched, pvt->lagid);
1218                 if (pvt->autoid > -1)
1219                         ast_sched_del(sched, pvt->autoid);
1220                 if (pvt->initid > -1)
1221                         ast_sched_del(sched, pvt->initid);
1222                 pvt->pingid = -1;
1223                 pvt->lagid = -1;
1224                 pvt->autoid = -1;
1225                 pvt->initid = -1;
1226                 pvt->alreadygone = 1;
1227         }
1228         c = pvt->owner;
1229         if (c) {
1230                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1231                 c->pvt->pvt = NULL;
1232                 ast_queue_hangup(c, 0);
1233                 pvt->owner = NULL;
1234                 ast_mutex_lock(&usecnt_lock);
1235                 usecnt--;
1236                 if (usecnt < 0)
1237                         ast_log(LOG_WARNING, "Usecnt < 0???\n");
1238                 ast_mutex_unlock(&usecnt_lock);
1239         }
1240         ast_mutex_unlock(&iaxsl[callno]);
1241         ast_update_use_count();
1242         return 0;
1243 }
1244
1245 static int iax2_predestroy_nolock(int callno)
1246 {
1247         int res;
1248         ast_mutex_unlock(&iaxsl[callno]);
1249         res = iax2_predestroy(callno);
1250         ast_mutex_lock(&iaxsl[callno]);
1251         return res;
1252 }
1253
1254 static void iax2_destroy(int callno)
1255 {
1256         struct chan_iax2_pvt *pvt;
1257         struct iax_frame *cur;
1258         struct ast_channel *owner;
1259
1260 retry:
1261         ast_mutex_lock(&iaxsl[callno]);
1262         pvt = iaxs[callno];
1263         gettimeofday(&lastused[callno], NULL);
1264
1265         if (pvt)
1266                 owner = pvt->owner;
1267         else
1268                 owner = NULL;
1269         if (owner) {
1270                 if (ast_mutex_trylock(&owner->lock)) {
1271                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1272                         ast_mutex_unlock(&iaxsl[callno]);
1273                         usleep(1);
1274                         goto retry;
1275                 }
1276         }
1277         if (!owner)
1278                 iaxs[callno] = NULL;
1279         if (pvt) {
1280                 if (!owner)
1281                         pvt->owner = NULL;
1282                 /* No more pings or lagrq's */
1283                 if (pvt->pingid > -1)
1284                         ast_sched_del(sched, pvt->pingid);
1285                 if (pvt->lagid > -1)
1286                         ast_sched_del(sched, pvt->lagid);
1287                 if (pvt->autoid > -1)
1288                         ast_sched_del(sched, pvt->autoid);
1289                 if (pvt->initid > -1)
1290                         ast_sched_del(sched, pvt->initid);
1291                 pvt->pingid = -1;
1292                 pvt->lagid = -1;
1293                 pvt->autoid = -1;
1294                 pvt->initid = -1;
1295                 if (pvt->bridgetrans)
1296                         ast_translator_free_path(pvt->bridgetrans);
1297                 pvt->bridgetrans = NULL;
1298
1299                 /* Already gone */
1300                 pvt->alreadygone = 1;
1301
1302                 if (owner) {
1303                         /* If there's an owner, prod it to give up */
1304                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1305                         ast_queue_hangup(owner, 0);
1306                 }
1307
1308                 for (cur = iaxq.head; cur ; cur = cur->next) {
1309                         /* Cancel any pending transmissions */
1310                         if (cur->callno == pvt->callno)
1311                                 cur->retries = -1;
1312                 }
1313                 if (pvt->reg) {
1314                         pvt->reg->callno = 0;
1315                 }
1316                 if (!owner)
1317                         free(pvt);
1318         }
1319         if (owner) {
1320                 ast_mutex_unlock(&owner->lock);
1321         }
1322         ast_mutex_unlock(&iaxsl[callno]);
1323         if (callno & 0x4000)
1324                 update_max_trunk();
1325 }
1326 static void iax2_destroy_nolock(int callno)
1327 {
1328         /* Actually it's easier to unlock, kill it, and relock */
1329         ast_mutex_unlock(&iaxsl[callno]);
1330         iax2_destroy(callno);
1331         ast_mutex_lock(&iaxsl[callno]);
1332 }
1333
1334 static int update_packet(struct iax_frame *f)
1335 {
1336         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1337         struct ast_iax2_full_hdr *fh = f->data;
1338         /* Mark this as a retransmission */
1339         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1340         /* Update iseqno */
1341         f->iseqno = iaxs[f->callno]->iseqno;
1342         fh->iseqno = f->iseqno;
1343         return 0;
1344 }
1345
1346 static int attempt_transmit(void *data)
1347 {
1348         /* Attempt to transmit the frame to the remote peer...
1349            Called without iaxsl held. */
1350         struct iax_frame *f = data;
1351         int freeme=0;
1352         int callno = f->callno;
1353         /* Make sure this call is still active */
1354         if (callno)
1355                 ast_mutex_lock(&iaxsl[callno]);
1356         if ((f->callno) && iaxs[f->callno]) {
1357                 if ((f->retries < 0) /* Already ACK'd */ ||
1358                     (f->retries >= max_retries) /* Too many attempts */) {
1359                                 /* Record an error if we've transmitted too many times */
1360                                 if (f->retries >= max_retries) {
1361                                         if (f->transfer) {
1362                                                 /* Transfer timeout */
1363                                                 send_command(iaxs[f->callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1364                                         } else if (f->final) {
1365                                                 if (f->final)
1366                                                         iax2_destroy_nolock(f->callno);
1367                                         } else {
1368                                                 if (iaxs[f->callno]->owner)
1369                                                         ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
1370                                                 iaxs[f->callno]->error = ETIMEDOUT;
1371                                                 if (iaxs[f->callno]->owner) {
1372                                                         struct ast_frame fr = { 0, };
1373                                                         /* Hangup the fd */
1374                                                         fr.frametype = AST_FRAME_CONTROL;
1375                                                         fr.subclass = AST_CONTROL_HANGUP;
1376                                                         iax2_queue_frame(f->callno, &fr);
1377                                                 } else {
1378                                                         if (iaxs[f->callno]->reg) {
1379                                                                 memset(&iaxs[f->callno]->reg->us, 0, sizeof(iaxs[f->callno]->reg->us));
1380                                                                 iaxs[f->callno]->reg->regstate = REG_STATE_TIMEOUT;
1381                                                                 iaxs[f->callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1382                                                         }
1383                                                         iax2_destroy_nolock(f->callno);
1384                                                 }
1385                                         }
1386
1387                                 }
1388                                 freeme++;
1389                 } else {
1390                         /* Update it if it needs it */
1391                         update_packet(f);
1392                         /* Attempt transmission */
1393                         send_packet(f);
1394                         f->retries++;
1395                         /* Try again later after 10 times as long */
1396                         f->retrytime *= 10;
1397                         if (f->retrytime > MAX_RETRY_TIME)
1398                                 f->retrytime = MAX_RETRY_TIME;
1399                         /* Transfer messages max out at one second */
1400                         if (f->transfer && (f->retrytime > 1000))
1401                                 f->retrytime = 1000;
1402                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1403                 }
1404         } else {
1405                 /* Make sure it gets freed */
1406                 f->retries = -1;
1407                 freeme++;
1408         }
1409         if (callno)
1410                 ast_mutex_unlock(&iaxsl[callno]);
1411         /* Do not try again */
1412         if (freeme) {
1413                 /* Don't attempt delivery, just remove it from the queue */
1414                 ast_mutex_lock(&iaxq.lock);
1415                 if (f->prev)
1416                         f->prev->next = f->next;
1417                 else
1418                         iaxq.head = f->next;
1419                 if (f->next)
1420                         f->next->prev = f->prev;
1421                 else
1422                         iaxq.tail = f->prev;
1423                 iaxq.count--;
1424                 ast_mutex_unlock(&iaxq.lock);
1425                 f->retrans = -1;
1426                 /* Free the IAX frame */
1427                 iax2_frame_free(f);
1428         }
1429         return 0;
1430 }
1431
1432 static int iax2_set_jitter(int fd, int argc, char *argv[])
1433 {
1434         if ((argc != 4) && (argc != 5))
1435                 return RESULT_SHOWUSAGE;
1436         if (argc == 4) {
1437                 max_jitter_buffer = atoi(argv[3]);
1438                 if (max_jitter_buffer < 0)
1439                         max_jitter_buffer = 0;
1440         } else {
1441                 if (argc == 5) {
1442                         if ((atoi(argv[3]) >= 0) && (atoi(argv[3]) < IAX_MAX_CALLS)) {
1443                                 if (iaxs[atoi(argv[3])]) {
1444                                         iaxs[atoi(argv[3])]->jitterbuffer = atoi(argv[4]);
1445                                         if (iaxs[atoi(argv[3])]->jitterbuffer < 0)
1446                                                 iaxs[atoi(argv[3])]->jitterbuffer = 0;
1447                                 } else
1448                                         ast_cli(fd, "No such call '%d'\n", atoi(argv[3]));
1449                         } else
1450                                 ast_cli(fd, "%d is not a valid call number\n", atoi(argv[3]));
1451                 }
1452         }
1453         return RESULT_SUCCESS;
1454 }
1455
1456 static char jitter_usage[] =
1457 "Usage: iax set jitter [callid] <value>\n"
1458 "       If used with a callid, it sets the jitter buffer to the given static\n"
1459 "value (until its next calculation).  If used without a callid, the value is used\n"
1460 "to establish the maximum excess jitter buffer that is permitted before the jitter\n"
1461 "buffer size is reduced.";
1462
1463 static int iax2_show_stats(int fd, int argc, char *argv[])
1464 {
1465         struct iax_frame *cur;
1466         int cnt = 0, dead=0, final=0;
1467         if (argc != 3)
1468                 return RESULT_SHOWUSAGE;
1469         for (cur = iaxq.head; cur ; cur = cur->next) {
1470                 if (cur->retries < 0)
1471                         dead++;
1472                 if (cur->final)
1473                         final++;
1474                 cnt++;
1475         }
1476         ast_cli(fd, "    IAX Statistics\n");
1477         ast_cli(fd, "---------------------\n");
1478         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d outgress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
1479         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n", dead, final, cnt);
1480         return RESULT_SUCCESS;
1481 }
1482
1483 static int iax2_show_cache(int fd, int argc, char *argv[])
1484 {
1485         struct iax2_dpcache *dp;
1486         char tmp[1024], *pc;
1487         int s;
1488         int x,y;
1489         struct timeval tv;
1490         gettimeofday(&tv, NULL);
1491         ast_mutex_lock(&dpcache_lock);
1492         dp = dpcache;
1493         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
1494         while(dp) {
1495                 s = dp->expirey.tv_sec - tv.tv_sec;
1496                 strcpy(tmp, "");
1497                 if (dp->flags & CACHE_FLAG_EXISTS)
1498                         strcat(tmp, "EXISTS|");
1499                 if (dp->flags & CACHE_FLAG_NONEXISTANT)
1500                         strcat(tmp, "NONEXISTANT|");
1501                 if (dp->flags & CACHE_FLAG_CANEXIST)
1502                         strcat(tmp, "CANEXIST|");
1503                 if (dp->flags & CACHE_FLAG_PENDING)
1504                         strcat(tmp, "PENDING|");
1505                 if (dp->flags & CACHE_FLAG_TIMEOUT)
1506                         strcat(tmp, "TIMEOUT|");
1507                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
1508                         strcat(tmp, "TRANSMITTED|");
1509                 if (dp->flags & CACHE_FLAG_MATCHMORE)
1510                         strcat(tmp, "MATCHMORE|");
1511                 if (dp->flags & CACHE_FLAG_UNKNOWN)
1512                         strcat(tmp, "UNKNOWN|");
1513                 /* Trim trailing pipe */
1514                 if (strlen(tmp))
1515                         tmp[strlen(tmp) - 1] = '\0';
1516                 else
1517                         strcpy(tmp, "(none)");
1518                 y=0;
1519                 pc = strchr(dp->peercontext, '@');
1520                 if (!pc)
1521                         pc = dp->peercontext;
1522                 else
1523                         pc++;
1524                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
1525                         if (dp->waiters[x] > -1)
1526                                 y++;
1527                 if (s > 0)
1528                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
1529                 else
1530                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
1531                 dp = dp->next;
1532         }
1533         ast_mutex_unlock(&dpcache_lock);
1534         return RESULT_SUCCESS;
1535 }
1536
1537 static char show_stats_usage[] =
1538 "Usage: iax show stats\n"
1539 "       Display statistics on IAX channel driver.\n";
1540
1541
1542 static char show_cache_usage[] =
1543 "Usage: iax show cache\n"
1544 "       Display currently cached IAX Dialplan results.\n";
1545
1546 static struct ast_cli_entry cli_set_jitter =
1547 { { "iax2", "set", "jitter", NULL }, iax2_set_jitter, "Sets IAX jitter buffer", jitter_usage };
1548
1549 static struct ast_cli_entry cli_show_stats =
1550 { { "iax2", "show", "stats", NULL }, iax2_show_stats, "Display IAX statistics", show_stats_usage };
1551
1552 static struct ast_cli_entry cli_show_cache =
1553 { { "iax2", "show", "cache", NULL }, iax2_show_cache, "Display IAX cached dialplan", show_cache_usage };
1554
1555 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p);
1556
1557 #ifdef BRIDGE_OPTIMIZATION
1558 static unsigned int calc_fakestamp(struct chan_iax2_pvt *from, struct chan_iax2_pvt *to, unsigned int ts);
1559
1560 static int forward_delivery(struct iax_frame *fr)
1561 {
1562         struct chan_iax2_pvt *p1, *p2;
1563         p1 = iaxs[fr->callno];
1564         p2 = iaxs[p1->bridgecallno];
1565         if (!p1)
1566                 return -1;
1567         if (!p2)
1568                 return -1;
1569         /* Fix relative timestamp */
1570         fr->ts = calc_fakestamp(p1, p2, fr->ts);
1571         /* Now just send it send on the 2nd one
1572            with adjusted timestamp */
1573         return iax2_send(p2, &fr->af, fr->ts, -1, 0, 0, 0);
1574 }
1575 #endif
1576
1577 static int schedule_delivery(struct iax_frame *fr, int reallydeliver, int updatehistory)
1578 {
1579         int ms,x;
1580         int drops[MEMORY_SIZE];
1581         int min, max=0, maxone=0,y,z, match;
1582         /* ms is a measure of the "lateness" of the packet relative to the first
1583            packet we received, which always has a lateness of 1.  Called by
1584            IAX thread, with iaxsl lock held. */
1585         ms = calc_rxstamp(iaxs[fr->callno]) - fr->ts;
1586
1587         if (ms > 32767) {
1588                 /* What likely happened here is that our counter has circled but we haven't
1589                    gotten the update from the main packet.  We'll just pretend that we did, and
1590                    update the timestamp appropriately. */
1591                 ms -= 65536;
1592                 fr->ts += 65536;
1593         }
1594
1595         if (ms < -32768) {
1596                 /* We got this packet out of order.  Lets add 65536 to it to bring it into our new
1597                    time frame */
1598                 ms += 65536;
1599                 fr->ts -= 65536;
1600         }
1601
1602         fr->af.delivery.tv_sec = iaxs[fr->callno]->rxcore.tv_sec;
1603         fr->af.delivery.tv_usec = iaxs[fr->callno]->rxcore.tv_usec;
1604         fr->af.delivery.tv_sec += fr->ts / 1000;
1605         fr->af.delivery.tv_usec += (fr->ts % 1000) * 1000;
1606         if (fr->af.delivery.tv_usec >= 1000000) {
1607                 fr->af.delivery.tv_usec -= 1000000;
1608                 fr->af.delivery.tv_sec += 1;
1609         }
1610
1611
1612         /* Rotate our history queue of "lateness".  Don't worry about those initial
1613            zeros because the first entry will always be zero */
1614         if (updatehistory) {
1615                 for (x=0;x<MEMORY_SIZE - 1;x++)
1616                         iaxs[fr->callno]->history[x] = iaxs[fr->callno]->history[x+1];
1617                 /* Add a history entry for this one */
1618                 iaxs[fr->callno]->history[x] = ms;
1619         }
1620
1621         /* Initialize the minimum to reasonable values.  It's too much
1622            work to do the same for the maximum, repeatedly */
1623         min=iaxs[fr->callno]->history[0];
1624         for (z=0;z < iax2_dropcount + 1;z++) {
1625                 /* Start very optimistic ;-) */
1626                 max=-999999999;
1627                 for (x=0;x<MEMORY_SIZE;x++) {
1628                         if (max < iaxs[fr->callno]->history[x]) {
1629                                 /* We have a candidate new maximum value.  Make
1630                                    sure it's not in our drop list */
1631                                 match = 0;
1632                                 for (y=0;!match && (y<z);y++)
1633                                         match |= (drops[y] == x);
1634                                 if (!match) {
1635                                         /* It's not in our list, use it as the new maximum */
1636                                         max = iaxs[fr->callno]->history[x];
1637                                         maxone = x;
1638                                 }
1639
1640                         }
1641                         if (!z) {
1642                                 /* On our first pass, find the minimum too */
1643                                 if (min > iaxs[fr->callno]->history[x])
1644                                         min = iaxs[fr->callno]->history[x];
1645                         }
1646                 }
1647 #if 1
1648                 drops[z] = maxone;
1649 #endif
1650         }
1651         /* Just for reference, keep the "jitter" value, the difference between the
1652            earliest and the latest. */
1653         iaxs[fr->callno]->jitter = max - min;
1654
1655         /* IIR filter for keeping track of historic jitter, but always increase
1656            historic jitter immediately for increase */
1657
1658         if (iaxs[fr->callno]->jitter > iaxs[fr->callno]->historicjitter )
1659                 iaxs[fr->callno]->historicjitter = iaxs[fr->callno]->jitter;
1660         else
1661                 iaxs[fr->callno]->historicjitter = GAMMA * (double)iaxs[fr->callno]->jitter + (1-GAMMA) *
1662                         iaxs[fr->callno]->historicjitter;
1663
1664         /* If our jitter buffer is too big (by a significant margin), then we slowly
1665            shrink it by about 1 ms each time to avoid letting the change be perceived */
1666         if (max < iaxs[fr->callno]->jitterbuffer - max_jitter_buffer)
1667                 iaxs[fr->callno]->jitterbuffer -= 2;
1668
1669
1670 #if 1
1671         /* Constrain our maximum jitter buffer appropriately */
1672         if (max > min + maxjitterbuffer) {
1673                 if (option_debug)
1674                         ast_log(LOG_DEBUG, "Constraining buffer from %d to %d + %d\n", max, min , maxjitterbuffer);
1675                 max = min + maxjitterbuffer;
1676         }
1677 #endif
1678
1679         /* If our jitter buffer is smaller than our maximum delay, grow the jitter
1680            buffer immediately to accomodate it (and a little more).  */
1681         if (max > iaxs[fr->callno]->jitterbuffer)
1682                 iaxs[fr->callno]->jitterbuffer = max
1683                         /* + ((float)iaxs[fr->callno]->jitter) * 0.1 */;
1684
1685
1686         if (option_debug)
1687                 ast_log(LOG_DEBUG, "min = %d, max = %d, jb = %d, lateness = %d\n", min, max, iaxs[fr->callno]->jitterbuffer, ms);
1688
1689         /* Subtract the lateness from our jitter buffer to know how long to wait
1690            before sending our packet.  */
1691         ms = iaxs[fr->callno]->jitterbuffer - ms;
1692
1693         if (!use_jitterbuffer)
1694                 ms = 0;
1695
1696         /* If the caller just wanted us to update, return now */
1697         if (!reallydeliver)
1698                 return 0;
1699
1700         if (ms < 1) {
1701                 if (option_debug)
1702                         ast_log(LOG_DEBUG, "Calculated ms is %d\n", ms);
1703                 /* Don't deliver it more than 4 ms late */
1704                 if ((ms > -4) || (fr->af.frametype != AST_FRAME_VOICE)) {
1705                         __do_deliver(fr);
1706                 } else {
1707                         if (option_debug)
1708                                 ast_log(LOG_DEBUG, "Dropping voice packet since %d ms is, too old\n", ms);
1709                         /* Free our iax frame */
1710                         iax2_frame_free(fr);
1711                 }
1712         } else {
1713                 if (option_debug)
1714                         ast_log(LOG_DEBUG, "Scheduling delivery in %d ms\n", ms);
1715                 fr->retrans = ast_sched_add(sched, ms, do_deliver, fr);
1716         }
1717         return 0;
1718 }
1719
1720 static int iax2_transmit(struct iax_frame *fr)
1721 {
1722         /* Lock the queue and place this packet at the end */
1723         fr->next = NULL;
1724         fr->prev = NULL;
1725         /* By setting this to 0, the network thread will send it for us, and
1726            queue retransmission if necessary */
1727         fr->sentyet = 0;
1728         ast_mutex_lock(&iaxq.lock);
1729         if (!iaxq.head) {
1730                 /* Empty queue */
1731                 iaxq.head = fr;
1732                 iaxq.tail = fr;
1733         } else {
1734                 /* Double link */
1735                 iaxq.tail->next = fr;
1736                 fr->prev = iaxq.tail;
1737                 iaxq.tail = fr;
1738         }
1739         iaxq.count++;
1740         ast_mutex_unlock(&iaxq.lock);
1741         /* Wake up the network thread */
1742         pthread_kill(netthreadid, SIGURG);
1743         return 0;
1744 }
1745
1746
1747
1748 static int iax2_digit(struct ast_channel *c, char digit)
1749 {
1750         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
1751 }
1752
1753 static int iax2_sendtext(struct ast_channel *c, char *text)
1754 {
1755
1756         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_TEXT,
1757                 0, 0, text, strlen(text) + 1, -1);
1758 }
1759
1760 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
1761 {
1762         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
1763 }
1764
1765 static int iax2_sendhtml(struct ast_channel *c, int subclass, char *data, int datalen)
1766 {
1767         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_HTML, subclass, 0, data, datalen, -1);
1768 }
1769
1770 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan, int lock)
1771 {
1772         unsigned short callno = PTR_TO_CALLNO(newchan->pvt->pvt);
1773         if (lock)
1774                 ast_mutex_lock(&iaxsl[callno]);
1775         if (iaxs[callno])
1776                 iaxs[callno]->owner = newchan;
1777         else
1778                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
1779         if (lock)
1780                 ast_mutex_unlock(&iaxsl[callno]);
1781         return 0;
1782 }
1783
1784 #ifdef MYSQL_FRIENDS
1785
1786 static void mysql_update_peer(char *peer, struct sockaddr_in *sin)
1787 {
1788         if (mysql && (strlen(peer) < 128)) {
1789                 char query[512];
1790                 char *name;
1791                 time_t nowtime;
1792                 name = alloca(strlen(peer) * 2 + 1);
1793                 time(&nowtime);
1794                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1795                 snprintf(query, sizeof(query), "UPDATE iaxfriends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\" WHERE name=\"%s\"",
1796                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), nowtime, name);
1797                 ast_mutex_lock(&mysqllock);
1798                 if (mysql_real_query(mysql, query, strlen(query)))
1799                         ast_log(LOG_WARNING, "Unable to update database\n");
1800
1801                 ast_mutex_unlock(&mysqllock);
1802         }
1803 }
1804
1805 static struct iax2_peer *mysql_peer(char *peer)
1806 {
1807         struct iax2_peer *p;
1808         int success = 0;
1809
1810         p = malloc(sizeof(struct iax2_peer));
1811         memset(p, 0, sizeof(struct iax2_peer));
1812         if (mysql && (strlen(peer) < 128)) {
1813                 char query[512];
1814                 char *name;
1815                 int numfields, x;
1816                 int port;
1817                 time_t regseconds, nowtime;
1818                 MYSQL_RES *result;
1819                 MYSQL_FIELD *fields;
1820                 MYSQL_ROW rowval;
1821                 name = alloca(strlen(peer) * 2 + 1);
1822                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1823                 snprintf(query, sizeof(query), "SELECT * FROM iaxfriends WHERE name=\"%s\"", name);
1824                 ast_mutex_lock(&mysqllock);
1825                 mysql_query(mysql, query);
1826                 if ((result = mysql_store_result(mysql))) {
1827                         if ((rowval = mysql_fetch_row(result))) {
1828                                 numfields = mysql_num_fields(result);
1829                                 fields = mysql_fetch_fields(result);
1830                                 success = 1;
1831                                 for (x=0;x<numfields;x++) {
1832                                         if (rowval[x]) {
1833                                                 if (!strcasecmp(fields[x].name, "secret")) {
1834                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1835                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1836                                                         strncpy(p->context, rowval[x], sizeof(p->context) - 1);
1837                                                 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
1838                                                         inet_aton(rowval[x], &p->addr.sin_addr);
1839                                                 } else if (!strcasecmp(fields[x].name, "port")) {
1840                                                         if (sscanf(rowval[x], "%i", &port) != 1)
1841                                                                 port = 0;
1842                                                         p->addr.sin_port = htons(port);
1843                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1844                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
1845                                                                 regseconds = 0;
1846                                                 }
1847                                         }
1848                                 }
1849                                 time(&nowtime);
1850                                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE)
1851                                         memset(&p->addr, 0, sizeof(p->addr));
1852                         }
1853                         mysql_free_result(result);
1854                         result = NULL;
1855                 }
1856                 ast_mutex_unlock(&mysqllock);
1857         }
1858         if (!success) {
1859                 free(p);
1860                 p = NULL;
1861         } else {
1862                 strncpy(p->name, peer, sizeof(p->name) - 1);
1863                 p->dynamic = 1;
1864                 p->temponly = 1;
1865                 p->expire = -1;
1866                 p->capability = iax2_capability;
1867                 p->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
1868         }
1869         return p;
1870 }
1871 static struct iax2_user *mysql_user(char *user)
1872 {
1873         struct iax2_user *p;
1874         struct iax2_context *con;
1875         int success = 0;
1876
1877         p = malloc(sizeof(struct iax2_user));
1878         memset(p, 0, sizeof(struct iax2_user));
1879         con = malloc(sizeof(struct iax2_context));
1880         memset(con, 0, sizeof(struct iax2_context));
1881         strcpy(con->context, "default");
1882         p->contexts = con;
1883         if (mysql && (strlen(user) < 128)) {
1884                 char query[512];
1885                 char *name;
1886                 int numfields, x;
1887                 MYSQL_RES *result;
1888                 MYSQL_FIELD *fields;
1889                 MYSQL_ROW rowval;
1890                 name = alloca(strlen(user) * 2 + 1);
1891                 mysql_real_escape_string(mysql, name, user, strlen(user));
1892                 snprintf(query, sizeof(query), "SELECT * FROM iaxfriends WHERE name=\"%s\"", name);
1893                 ast_mutex_lock(&mysqllock);
1894                 mysql_query(mysql, query);
1895                 if ((result = mysql_store_result(mysql))) {
1896                         if ((rowval = mysql_fetch_row(result))) {
1897                                 numfields = mysql_num_fields(result);
1898                                 fields = mysql_fetch_fields(result);
1899                                 success = 1;
1900                                 for (x=0;x<numfields;x++) {
1901                                         if (rowval[x]) {
1902                                                 if (!strcasecmp(fields[x].name, "secret")) {
1903                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1904                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1905                                                         strncpy(p->contexts->context, rowval[x], sizeof(p->contexts->context) - 1);
1906                                                 }
1907                                         }
1908                                 }
1909                         }
1910                         mysql_free_result(result);
1911                         result = NULL;
1912                 }
1913                 ast_mutex_unlock(&mysqllock);
1914         }
1915         if (!success) {
1916                 if (p->contexts)
1917                         free(p->contexts);
1918                 free(p);
1919                 p = NULL;
1920         } else {
1921                 strncpy(p->name, user, sizeof(p->name) - 1);
1922                 p->temponly = 1;
1923                 p->capability = iax2_capability;
1924                 p->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
1925         }
1926         return p;
1927 }
1928 #endif /* MYSQL_FRIENDS */
1929
1930 static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, int *maxtime, char *peer, char *context, int *trunk, int *notransfer, char *secret, int seclen)
1931 {
1932         struct hostent *hp;
1933         struct iax2_peer *p;
1934         int found=0;
1935         if (sendani)
1936                 *sendani = 0;
1937         if (maxtime)
1938                 *maxtime = 0;
1939         if (trunk)
1940                 *trunk = 0;
1941         sin->sin_family = AF_INET;
1942         ast_mutex_lock(&peerl.lock);
1943         p = peerl.peers;
1944         while(p) {
1945                 if (!strcasecmp(p->name, peer)) {
1946                         break;
1947                 }
1948                 p = p->next;
1949         }
1950         ast_mutex_unlock(&peerl.lock);
1951 #ifdef MYSQL_FRIENDS
1952         if (!p)
1953                 p = mysql_peer(peer);
1954 #endif
1955         if (p) {
1956                 found++;
1957                 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1958                         (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
1959                         if (sendani)
1960                                 *sendani = p->sendani;          /* Whether we transmit ANI */
1961                         if (maxtime)
1962                                 *maxtime = p->maxms;            /* Max time they should take */
1963                         if (context)
1964                                 strncpy(context, p->context, AST_MAX_EXTENSION - 1);
1965                         if (trunk)
1966                                 *trunk = p->trunk;
1967                         if (capability)
1968                                 *capability = p->capability;
1969                         if (secret)
1970                                 strncpy(secret, p->secret, seclen);
1971                         if (p->addr.sin_addr.s_addr) {
1972                                 sin->sin_addr = p->addr.sin_addr;
1973                                 sin->sin_port = p->addr.sin_port;
1974                         } else {
1975                                 sin->sin_addr = p->defaddr.sin_addr;
1976                                 sin->sin_port = p->defaddr.sin_port;
1977                         }
1978                         if (notransfer)
1979                                 *notransfer=p->notransfer;
1980                 } else {
1981                         if (p->temponly)
1982                                 free(p);
1983                         p = NULL;
1984                 }
1985         }
1986         if (!p && !found) {
1987                 hp = gethostbyname(peer);
1988                 if (hp) {
1989                         memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
1990                         sin->sin_port = htons(IAX_DEFAULT_PORTNO);
1991                         return 0;
1992                 } else {
1993                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1994                         return -1;
1995                 }
1996         } else if (!p)
1997                 return -1;
1998         if (p->temponly)
1999                 free(p);
2000         return 0;
2001 }
2002
2003 static int auto_congest(void *nothing)
2004 {
2005         int callno = PTR_TO_CALLNO(nothing);
2006         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2007         ast_mutex_lock(&iaxsl[callno]);
2008         if (iaxs[callno]) {
2009                 iaxs[callno]->initid = -1;
2010                 iax2_queue_frame(callno, &f);
2011                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2012         }
2013         ast_mutex_unlock(&iaxsl[callno]);
2014         return 0;
2015 }
2016
2017 static unsigned int iax2_datetime(void)
2018 {
2019         time_t t;
2020         struct tm tm;
2021         unsigned int tmp;
2022         time(&t);
2023         localtime_r(&t, &tm);
2024         tmp  = (tm.tm_sec >> 1) & 0x1f;   /* 5 bits of seconds */
2025         tmp |= (tm.tm_min & 0x3f) << 5;   /* 6 bits of minutes */
2026         tmp |= (tm.tm_hour & 0x1f) << 11;   /* 5 bits of hours */
2027         tmp |= (tm.tm_mday & 0x1f) << 16; /* 5 bits of day of month */
2028         tmp |= ((tm.tm_mon + 1) & 0xf) << 21; /* 4 bits of month */
2029         tmp |= ((tm.tm_year - 100) & 0x7f) << 25; /* 7 bits of year */
2030         return tmp;
2031 }
2032
2033 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2034 {
2035         struct sockaddr_in sin;
2036         char host[256];
2037         char *rdest;
2038         char *rcontext;
2039         char *username;
2040         char *secret = NULL;
2041         char *hname;
2042         char cid[256] = "";
2043         char *l=NULL, *n=NULL;
2044         struct iax_ie_data ied;
2045         char myrdest [5] = "s";
2046         char context[AST_MAX_EXTENSION] ="";
2047         char *portno = NULL;
2048         char *opts = "";
2049         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2050         char *stringp=NULL;
2051         char storedsecret[80];
2052         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2053                 ast_log(LOG_WARNING, "Line is already in use (%s)?\n", c->name);
2054                 return -1;
2055         }
2056         strncpy(host, dest, sizeof(host)-1);
2057         stringp=host;
2058         strsep(&stringp, "/");
2059         /* If no destination extension specified, use 's' */
2060         rdest = strsep(&stringp, "/");
2061         if (!rdest)
2062                 rdest = myrdest;
2063         else {
2064                 /* Check for trailing options */
2065                 opts = strsep(&stringp, "/");
2066                 if (!opts)
2067                         opts = "";
2068         }
2069         stringp=rdest;
2070         strsep(&stringp, "@");
2071         rcontext = strsep(&stringp, "@");
2072         stringp=host;
2073         strsep(&stringp, "@");
2074         username = strsep(&stringp, "@");
2075         if (username) {
2076                 /* Really the second argument is the host, not the username */
2077                 hname = username;
2078                 username = host;
2079         } else {
2080                 hname = host;
2081         }
2082         if (username) {
2083                 stringp=username;
2084                 username = strsep(&stringp, ":");
2085                 secret = strsep(&stringp, ":");
2086         }
2087         stringp=hname;
2088         if (strsep(&stringp, ":")) {
2089                 stringp=hname;
2090                 strsep(&stringp, ":");
2091                 portno = strsep(&stringp, ":");
2092         }
2093         if (create_addr(&sin, NULL, NULL, NULL, hname, context, NULL, NULL, storedsecret, sizeof(storedsecret) - 1)) {
2094                 ast_log(LOG_WARNING, "No address associated with '%s'\n", hname);
2095                 return -1;
2096         }
2097         /* Keep track of the context for outgoing calls too */
2098         strncpy(c->context, context, sizeof(c->context) - 1);
2099         if (portno) {
2100                 sin.sin_port = htons(atoi(portno));
2101         }
2102         if (c->callerid) {
2103                 strncpy(cid, c->callerid, sizeof(cid) - 1);
2104                 ast_callerid_parse(cid, &n, &l);
2105                 if (l)
2106                         ast_shrink_phone_number(l);
2107         }
2108         /* Now build request */
2109         memset(&ied, 0, sizeof(ied));
2110         /* On new call, first IE MUST be IAX version of caller */
2111         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2112         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, rdest);
2113         if (strchr(opts, 'a')) {
2114                 /* Request auto answer */
2115                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
2116         }
2117         if (l)
2118                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
2119         if (n)
2120                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
2121         if (iaxs[callno]->sendani && c->ani) {
2122                 l = n = NULL;
2123                 strncpy(cid, c->ani, sizeof(cid) - 1);
2124                 ast_callerid_parse(cid, &n, &l);
2125                 if (l) {
2126                         ast_shrink_phone_number(l);
2127                         iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, l);
2128                 }
2129         }
2130         if (c->language && strlen(c->language))
2131                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
2132         if (c->dnid && strlen(c->dnid))
2133                 iax_ie_append_str(&ied, IAX_IE_DNID, c->dnid);
2134         if (rcontext)
2135                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, rcontext);
2136         if (username)
2137                 iax_ie_append_str(&ied, IAX_IE_USERNAME, username);
2138         if (!secret && strlen(storedsecret))
2139                 secret = storedsecret;
2140         ast_mutex_lock(&iaxsl[callno]);
2141         if (strlen(c->context))
2142                 strncpy(iaxs[callno]->context, c->context, sizeof(iaxs[callno]->context));
2143         if (secret) {
2144                 if (secret[0] == '[') {
2145                         /* This is an RSA key, not a normal secret */
2146                         strncpy(iaxs[callno]->outkey, secret + 1, sizeof(iaxs[callno]->secret)-1);
2147                         if (strlen(iaxs[callno]->outkey)) {
2148                                 iaxs[callno]->outkey[strlen(iaxs[callno]->outkey) - 1] = '\0';
2149                         }
2150                 } else
2151                         strncpy(iaxs[callno]->secret, secret, sizeof(iaxs[callno]->secret)-1);
2152         }
2153         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
2154         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
2155         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
2156         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime());
2157         /* Transmit the string in a "NEW" request */
2158 #if 0
2159         /* XXX We have no equivalent XXX */
2160         if (option_verbose > 2)
2161                 ast_verbose(VERBOSE_PREFIX_3 "Calling using options '%s'\n", requeststr);
2162 #endif
2163         if (iaxs[callno]->maxtime) {
2164                 /* Initialize pingtime and auto-congest time */
2165                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
2166                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
2167         }
2168         send_command(iaxs[callno], AST_FRAME_IAX,
2169                 IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
2170         ast_mutex_unlock(&iaxsl[callno]);
2171         ast_setstate(c, AST_STATE_RINGING);
2172         return 0;
2173 }
2174
2175 static int iax2_hangup(struct ast_channel *c)
2176 {
2177         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2178         int alreadygone;
2179         ast_mutex_lock(&iaxsl[callno]);
2180         if (callno && iaxs[callno]) {
2181                 ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
2182                 alreadygone = iaxs[callno]->alreadygone;
2183                 /* Send the hangup unless we have had a transmission error or are already gone */
2184                 if (!iaxs[callno]->error && !alreadygone)
2185                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, NULL, 0, -1);
2186                 /* Explicitly predestroy it */
2187                 iax2_predestroy_nolock(callno);
2188                 /* If we were already gone to begin with, destroy us now */
2189                 if (alreadygone) {
2190                         ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
2191                         iax2_destroy_nolock(callno);
2192                 }
2193         }
2194         ast_mutex_unlock(&iaxsl[callno]);
2195         if (option_verbose > 2)
2196                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
2197         return 0;
2198 }
2199
2200 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
2201 {
2202         struct ast_option_header *h;
2203         int res;
2204         h = malloc(datalen + sizeof(struct ast_option_header));
2205         if (h) {
2206                 h->flag = AST_OPTION_FLAG_REQUEST;
2207                 h->option = htons(option);
2208                 memcpy(h->data, data, datalen);
2209                 res = send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_CONTROL,
2210                         AST_CONTROL_OPTION, 0, (char *)h, datalen + sizeof(struct ast_option_header), -1);
2211                 free(h);
2212                 return res;
2213         } else
2214                 ast_log(LOG_WARNING, "Out of memory\n");
2215         return -1;
2216 }
2217
2218 static struct ast_frame *iax2_read(struct ast_channel *c)
2219 {
2220         static struct ast_frame f = { AST_FRAME_NULL, };
2221         ast_log(LOG_NOTICE, "I should never be called!\n");
2222         return &f;
2223 }
2224
2225 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1)
2226 {
2227         int res;
2228         struct iax_ie_data ied0;
2229         struct iax_ie_data ied1;
2230         unsigned int transferid = rand();
2231         memset(&ied0, 0, sizeof(ied0));
2232         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
2233         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
2234         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
2235
2236         memset(&ied1, 0, sizeof(ied1));
2237         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
2238         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
2239         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
2240
2241         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
2242         if (res)
2243                 return -1;
2244         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
2245         if (res)
2246                 return -1;
2247         iaxs[callno0]->transferring = TRANSFER_BEGIN;
2248         iaxs[callno1]->transferring = TRANSFER_BEGIN;
2249         return 0;
2250 }
2251
2252 static void lock_both(unsigned short callno0, unsigned short callno1)
2253 {
2254         ast_mutex_lock(&iaxsl[callno0]);
2255         while (ast_mutex_trylock(&iaxsl[callno1])) {
2256                 ast_mutex_unlock(&iaxsl[callno0]);
2257                 usleep(10);
2258                 ast_mutex_lock(&iaxsl[callno0]);
2259         }
2260 }
2261
2262 static void unlock_both(unsigned short callno0, unsigned short callno1)
2263 {
2264         ast_mutex_unlock(&iaxsl[callno1]);
2265         ast_mutex_unlock(&iaxsl[callno0]);
2266 }
2267
2268 static int iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
2269 {
2270         struct ast_channel *cs[3];
2271         struct ast_channel *who;
2272         int to = -1;
2273         int res = -1;
2274         int transferstarted=0;
2275         struct ast_frame *f;
2276         unsigned short callno0 = PTR_TO_CALLNO(c0->pvt->pvt);
2277         unsigned short callno1 = PTR_TO_CALLNO(c1->pvt->pvt);
2278         struct timeval waittimer = {0, 0}, tv;
2279
2280         lock_both(callno0, callno1);
2281         /* Put them in native bridge mode */
2282         iaxs[callno0]->bridgecallno = callno1;
2283         iaxs[callno1]->bridgecallno = callno0;
2284         unlock_both(callno0, callno1);
2285
2286         /* If not, try to bridge until we can execute a transfer, if we can */
2287         cs[0] = c0;
2288         cs[1] = c1;
2289         for (/* ever */;;) {
2290                 /* Check in case we got masqueraded into */
2291                 if ((c0->type != type) || (c1->type != type)) {
2292                         if (option_verbose > 2)
2293                                 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
2294                         /* Remove from native mode */
2295                         if (c0->type == type) {
2296                                 ast_mutex_lock(&iaxsl[callno0]);
2297                                 iaxs[callno0]->bridgecallno = 0;
2298                                 ast_mutex_unlock(&iaxsl[callno0]);
2299                         }
2300                         if (c1->type == type) {
2301                                 ast_mutex_lock(&iaxsl[callno1]);
2302                                 iaxs[callno1]->bridgecallno = 0;
2303                                 ast_mutex_unlock(&iaxsl[callno1]);
2304                         }
2305                         return -2;
2306                 }
2307                 if (c0->nativeformats != c1->nativeformats) {
2308                         ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs, can't native bridge...\n");
2309                         /* Remove from native mode */
2310                         lock_both(callno0, callno1);
2311                         iaxs[callno0]->bridgecallno = 0;
2312                         iaxs[callno1]->bridgecallno = 0;
2313                         unlock_both(callno0, callno1);
2314                         return -2;
2315                 }
2316                 /* check if transfered and if we really want native bridging */
2317                 if (!transferstarted && !iaxs[callno0]->notransfer && !iaxs[callno1]->notransfer) {
2318                         /* Try the transfer */
2319                         if (iax2_start_transfer(callno0, callno1))
2320                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
2321                         transferstarted = 1;
2322                 }
2323                 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
2324                         /* Call has been transferred.  We're no longer involved */
2325                         gettimeofday(&tv, NULL);
2326                         if (!waittimer.tv_sec && !waittimer.tv_usec) {
2327                                 waittimer.tv_sec = tv.tv_sec;
2328                                 waittimer.tv_usec = tv.tv_usec;
2329                         } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
2330                                 c0->_softhangup |= AST_SOFTHANGUP_DEV;
2331                                 c1->_softhangup |= AST_SOFTHANGUP_DEV;
2332                                 *fo = NULL;
2333                                 *rc = c0;
2334                                 res = 0;
2335                                 break;
2336                         }
2337                 }
2338                 to = 1000;
2339                 who = ast_waitfor_n(cs, 2, &to);
2340                 if (!who) {
2341                         if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
2342                                 res = -1;
2343                                 break;
2344                         }
2345                         continue;
2346                 }
2347                 f = ast_read(who);
2348                 if (!f) {
2349                         *fo = NULL;
2350                         *rc = who;
2351                         res = 0;
2352                         break;
2353                 }
2354                 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2355                         *fo = f;
2356                         *rc = who;
2357                         res =  0;
2358                         break;
2359                 }
2360                 if ((f->frametype == AST_FRAME_VOICE) ||
2361                         (f->frametype == AST_FRAME_TEXT) ||
2362                         (f->frametype == AST_FRAME_VIDEO) ||
2363                         (f->frametype == AST_FRAME_IMAGE) ||
2364                         (f->frametype == AST_FRAME_DTMF)) {
2365                         if ((f->frametype == AST_FRAME_DTMF) &&
2366                                 (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
2367                                 if ((who == c0)) {
2368                                         if  ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
2369                                                 *rc = c0;
2370                                                 *fo = f;
2371                                                 /* Take out of conference mode */
2372                                                 res = 0;
2373                                                 /* Remove from native mode */
2374                                                 break;
2375                                         } else
2376                                                 goto tackygoto;
2377                                 } else
2378                                 if ((who == c1)) {
2379                                         if (flags & AST_BRIDGE_DTMF_CHANNEL_1) {
2380                                                 *rc = c1;
2381                                                 *fo = f;
2382                                                 res =  0;
2383                                                 /* Remove from native mode */
2384                                                 break;
2385                                         } else
2386                                                 goto tackygoto;
2387                                 }
2388                         } else {
2389 #if 0
2390                                 ast_log(LOG_DEBUG, "Read from %s\n", who->name);
2391                                 if (who == last)
2392                                         ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
2393                                 last = who;
2394 #endif
2395 tackygoto:
2396                                 if (who == c0)
2397                                         ast_write(c1, f);
2398                                 else
2399                                         ast_write(c0, f);
2400                         }
2401                         ast_frfree(f);
2402                 } else
2403                         ast_frfree(f);
2404                 /* Swap who gets priority */
2405                 cs[2] = cs[0];
2406                 cs[0] = cs[1];
2407                 cs[1] = cs[2];
2408         }
2409         lock_both(callno0, callno1);
2410         iaxs[callno0]->bridgecallno = 0;
2411         iaxs[callno1]->bridgecallno = 0;
2412         unlock_both(callno0, callno1);
2413         return res;
2414 }
2415
2416 static int iax2_answer(struct ast_channel *c)
2417 {
2418         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2419         if (option_debug)
2420                 ast_log(LOG_DEBUG, "Answering\n");
2421         return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
2422 }
2423
2424 static int iax2_indicate(struct ast_channel *c, int condition)
2425 {
2426         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2427         if (option_debug)
2428                 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
2429         return send_command_locked(callno, AST_FRAME_CONTROL, condition, 0, NULL, 0, -1);
2430 }
2431
2432 static int iax2_transfer(struct ast_channel *c, char *dest)
2433 {
2434         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2435         struct iax_ie_data ied;
2436         char tmp[256] = "", *context;
2437         strncpy(tmp, dest, sizeof(tmp) - 1);
2438         context = strchr(tmp, '@');
2439         if (context) {
2440                 *context = '\0';
2441                 context++;
2442         }
2443         memset(&ied, 0, sizeof(ied));
2444         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
2445         if (context)
2446                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
2447         if (option_debug)
2448                 ast_log(LOG_DEBUG, "Transferring '%s' to '%s'\n", c->name, dest);
2449         return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
2450 }
2451
2452
2453 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
2454
2455 static int iax2_getpeertrunk(struct sockaddr_in sin)
2456 {
2457         struct iax2_peer *peer;
2458         int res = 0;
2459         ast_mutex_lock(&peerl.lock);
2460         peer = peerl.peers;
2461         while(peer) {
2462                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
2463                                 (peer->addr.sin_port == sin.sin_port)) {
2464                                         res = peer->trunk;
2465                                         break;
2466                 }
2467                 peer = peer->next;
2468         }
2469         ast_mutex_unlock(&peerl.lock);
2470         return res;
2471 }
2472
2473 static struct ast_channel *ast_iax2_new(struct chan_iax2_pvt *i, int state, int capability)
2474 {
2475         struct ast_channel *tmp;
2476         tmp = ast_channel_alloc(1);
2477         if (tmp) {
2478                 if (strlen(i->username))
2479                         snprintf(tmp->name, sizeof(tmp->name), "IAX2[%s@%s]/%d", i->username, i->host, i->callno);
2480                 else
2481                         snprintf(tmp->name, sizeof(tmp->name), "IAX2[%s]/%d", i->host, i->callno);
2482                 tmp->type = type;
2483                 /* We can support any format by default, until we get restricted */
2484                 tmp->nativeformats = capability;
2485                 tmp->readformat = 0;
2486                 tmp->writeformat = 0;
2487                 tmp->pvt->pvt = CALLNO_TO_PTR(i->callno);
2488                 tmp->pvt->send_digit = iax2_digit;
2489                 tmp->pvt->send_text = iax2_sendtext;
2490                 tmp->pvt->send_image = iax2_sendimage;
2491                 tmp->pvt->send_html = iax2_sendhtml;
2492                 tmp->pvt->call = iax2_call;
2493                 tmp->pvt->hangup = iax2_hangup;
2494                 tmp->pvt->answer = iax2_answer;
2495                 tmp->pvt->read = iax2_read;
2496                 tmp->pvt->write = iax2_write;
2497                 tmp->pvt->write_video = iax2_write;
2498                 tmp->pvt->indicate = iax2_indicate;
2499                 tmp->pvt->setoption = iax2_setoption;
2500                 tmp->pvt->bridge = iax2_bridge;
2501                 tmp->pvt->transfer = iax2_transfer;
2502                 if (strlen(i->callerid))
2503                         tmp->callerid = strdup(i->callerid);
2504                 if (strlen(i->ani))
2505                         tmp->ani = strdup(i->ani);
2506                 if (strlen(i->language))
2507                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2508                 if (strlen(i->dnid))
2509                         tmp->dnid = strdup(i->dnid);
2510                 if (strlen(i->accountcode))
2511                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2512                 if (i->amaflags)
2513                         tmp->amaflags = i->amaflags;
2514                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2515                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2516                 tmp->adsicpe = i->peeradsicpe;
2517                 tmp->pvt->fixup = iax2_fixup;
2518                 i->owner = tmp;
2519                 i->capability = capability;
2520                 ast_setstate(tmp, state);
2521                 ast_mutex_lock(&usecnt_lock);
2522                 usecnt++;
2523                 ast_mutex_unlock(&usecnt_lock);
2524                 ast_update_use_count();
2525                 if (state != AST_STATE_DOWN) {
2526                         if (ast_pbx_start(tmp)) {
2527                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2528                                 ast_hangup(tmp);
2529                                 tmp = NULL;
2530                         }
2531                 }
2532         }
2533         return tmp;
2534 }
2535
2536 static unsigned int calc_txpeerstamp(struct iax2_peer *peer)
2537 {
2538         struct timeval tv;
2539         unsigned int mssincetx;
2540         unsigned int ms;
2541         gettimeofday(&tv, NULL);
2542         mssincetx = (tv.tv_sec - peer->lasttxtime.tv_sec) * 1000 + (tv.tv_usec - peer->lasttxtime.tv_usec) / 1000;
2543         if (mssincetx > 5000) {
2544                 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
2545                 peer->txtrunktime.tv_sec = tv.tv_sec;
2546                 peer->txtrunktime.tv_usec = tv.tv_usec;
2547         }
2548         /* Update last transmit time now */
2549         peer->lasttxtime.tv_sec = tv.tv_sec;
2550         peer->lasttxtime.tv_usec = tv.tv_usec;
2551
2552         /* Calculate ms offset */
2553         ms = (tv.tv_sec - peer->txtrunktime.tv_sec) * 1000 + (tv.tv_usec - peer->txtrunktime.tv_usec) / 1000;
2554
2555         /* We never send the same timestamp twice, so fudge a little if we must */
2556         if (ms == peer->lastsent)
2557                 ms = peer->lastsent + 1;
2558         peer->lastsent = ms;
2559         return ms;
2560 }
2561
2562 static unsigned int fix_peerts(struct iax2_peer *peer, int callno, unsigned int ts)
2563 {
2564         long ms;        /* NOT unsigned */
2565         if (!iaxs[callno]->rxcore.tv_sec && !iaxs[callno]->rxcore.tv_usec) {
2566                 /* Initialize rxcore time if appropriate */
2567                 gettimeofday(&iaxs[callno]->rxcore, NULL);
2568                 /* Round to nearest 20ms */
2569                 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
2570         }
2571         /* Calculate difference between trunk and channel */
2572         ms = (peer->rxtrunktime.tv_sec - iaxs[callno]->rxcore.tv_sec) * 1000 +
2573                 (peer->rxtrunktime.tv_usec - iaxs[callno]->rxcore.tv_usec) / 1000;
2574         /* Return as the sum of trunk time and the difference between trunk and real time */
2575         return ms + ts;
2576 }
2577
2578 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct timeval *delivery)
2579 {
2580         struct timeval tv;
2581         unsigned int ms;
2582         if (!p->offset.tv_sec && !p->offset.tv_usec) {
2583                 gettimeofday(&p->offset, NULL);
2584                 /* Round to nearest 20ms */
2585                 p->offset.tv_usec -= p->offset.tv_usec % 20000;
2586         }
2587         /* If the timestamp is specified, just send it as is */
2588         if (ts)
2589                 return ts;
2590         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
2591                 ms = (delivery->tv_sec - p->offset.tv_sec) * 1000 + (delivery->tv_usec - p->offset.tv_usec) / 1000;
2592         } else {
2593                 gettimeofday(&tv, NULL);
2594                 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
2595         }
2596         /* We never send the same timestamp twice, so fudge a little if we must */
2597         if (ms <= p->lastsent) {
2598                 ms = p->lastsent + 1;
2599         }
2600         p->lastsent = ms;
2601         return ms;
2602 }
2603
2604 #ifdef BRIDGE_OPTIMIZATION
2605 static unsigned int calc_fakestamp(struct chan_iax2_pvt *p1, struct chan_iax2_pvt *p2, unsigned int fakets)
2606 {
2607         int ms;
2608         /* Receive from p1, send to p2 */
2609
2610         /* Setup rxcore if necessary on outgoing channel */
2611         if (!p1->rxcore.tv_sec && !p1->rxcore.tv_usec)
2612                 gettimeofday(&p1->rxcore, NULL);
2613
2614         /* Setup txcore if necessary on outgoing channel */
2615         if (!p2->offset.tv_sec && !p2->offset.tv_usec)
2616                 gettimeofday(&p2->offset, NULL);
2617
2618         /* Now, ts is the timestamp of the original packet in the orignal context.
2619            Adding rxcore to it gives us when we would want the packet to be delivered normally.
2620            Subtracting txcore of the outgoing channel gives us what we'd expect */
2621
2622         ms = (p1->rxcore.tv_sec - p2->offset.tv_sec) * 1000 + (p1->rxcore.tv_usec - p2->offset.tv_usec) / 1000;
2623         fakets += ms;
2624         if (fakets <= p2->lastsent)
2625                 fakets = p2->lastsent + 1;
2626         p2->lastsent = fakets;
2627         return fakets;
2628 }
2629 #endif
2630
2631 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p)
2632 {
2633         /* Returns where in "receive time" we are */
2634         struct timeval tv;
2635         unsigned int ms;
2636         /* Setup rxcore if necessary */
2637         if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
2638                 gettimeofday(&p->rxcore, NULL);
2639
2640         gettimeofday(&tv, NULL);
2641         ms = (tv.tv_sec - p->rxcore.tv_sec) * 1000 + (tv.tv_usec - p->rxcore.tv_usec) / 1000;
2642         return ms;
2643 }
2644
2645 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
2646 {
2647         /* Queue a packet for delivery on a given private structure.  Use "ts" for
2648            timestamp, or calculate if ts is 0.  Send immediately without retransmission
2649            or delayed, with retransmission */
2650         struct ast_iax2_full_hdr *fh;
2651         struct ast_iax2_mini_hdr *mh;
2652         struct ast_iax2_video_hdr *vh;
2653         struct {
2654                 struct iax_frame fr2;
2655                 unsigned char buffer[4096];
2656         } frb;
2657         struct iax_frame *fr;
2658         int res;
2659         int sendmini=0;
2660         unsigned int lastsent;
2661         unsigned int fts;
2662
2663         if (!pvt) {
2664                 ast_log(LOG_WARNING, "No private structure for packet?\n");
2665                 return -1;
2666         }
2667
2668         lastsent = pvt->lastsent;
2669
2670         /* Calculate actual timestamp */
2671         fts = calc_timestamp(pvt, ts, (f->frametype == AST_FRAME_VOICE) ? &f->delivery : NULL);
2672
2673         if ((pvt->trunk || ((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)))
2674                 /* High two bits are the same on timestamp, or sending on a trunk */ &&
2675             (f->frametype == AST_FRAME_VOICE)
2676                 /* is a voice frame */ &&
2677                 (f->subclass == pvt->svoiceformat)
2678                 /* is the same type */ ) {
2679                         /* Force immediate rather than delayed transmission */
2680                         now = 1;
2681                         /* Mark that mini-style frame is appropriate */
2682                         sendmini = 1;
2683         }
2684         if (((fts & 0xFFFF8000L) == (lastsent & 0xFFFF8000L)) &&
2685                 (f->frametype == AST_FRAME_VIDEO) &&
2686                 ((f->subclass & ~0x1) == pvt->svideoformat)) {
2687                         now = 1;
2688                         sendmini = 1;
2689         }
2690         /* Allocate an iax_frame */
2691         if (now) {
2692                 fr = &frb.fr2;
2693         } else
2694                 fr = iax_frame_new(DIRECTION_OUTGRESS, f->datalen);
2695         if (!fr) {
2696                 ast_log(LOG_WARNING, "Out of memory\n");
2697                 return -1;
2698         }
2699         /* Copy our prospective frame into our immediate or retransmitted wrapper */
2700         iax_frame_wrap(fr, f);
2701
2702         fr->ts = fts;
2703         if (!fr->ts) {
2704                 ast_log(LOG_WARNING, "timestamp is 0?\n");
2705                 if (!now)
2706                         iax2_frame_free(fr);
2707                 return -1;
2708         }
2709         fr->callno = pvt->callno;
2710         fr->transfer = transfer;
2711         fr->final = final;
2712         if (!sendmini) {
2713                 /* We need a full frame */
2714                 if (seqno > -1)
2715                         fr->oseqno = seqno;
2716                 else
2717                         fr->oseqno = pvt->oseqno++;
2718                 fr->iseqno = pvt->iseqno;
2719                 fh = (struct ast_iax2_full_hdr *)(fr->af.data - sizeof(struct ast_iax2_full_hdr));
2720                 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
2721                 fh->ts = htonl(fr->ts);
2722                 fh->oseqno = fr->oseqno;
2723                 if (transfer) {
2724                         fh->iseqno = 0;
2725                 } else
2726                         fh->iseqno = fr->iseqno;
2727                 /* Keep track of the last thing we've acknowledged */
2728                 if (!transfer)
2729                         pvt->aseqno = fr->iseqno;
2730                 fh->type = fr->af.frametype & 0xFF;
2731                 if (fr->af.frametype == AST_FRAME_VIDEO)
2732                         fh->csub = compress_subclass(fr->af.subclass & ~0x1) | ((fr->af.subclass & 0x1) << 6);
2733                 else
2734                         fh->csub = compress_subclass(fr->af.subclass);
2735                 if (transfer) {
2736                         fr->dcallno = pvt->transfercallno;
2737                 } else
2738                         fr->dcallno = pvt->peercallno;
2739                 fh->dcallno = htons(fr->dcallno);
2740                 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
2741                 fr->data = fh;
2742                 fr->retries = 0;
2743                 /* Retry after 2x the ping time has passed */
2744                 fr->retrytime = pvt->pingtime * 2;
2745                 if (fr->retrytime < MIN_RETRY_TIME)
2746                         fr->retrytime = MIN_RETRY_TIME;
2747                 if (fr->retrytime > MAX_RETRY_TIME)
2748                         fr->retrytime = MAX_RETRY_TIME;
2749                 /* Acks' don't get retried */
2750                 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == IAX_COMMAND_ACK))
2751                         fr->retries = -1;
2752                 if (f->frametype == AST_FRAME_VOICE) {
2753                         pvt->svoiceformat = f->subclass;
2754                 }
2755                 if (f->frametype == AST_FRAME_VIDEO) {
2756                         pvt->svideoformat = f->subclass & ~0x1;
2757                 }
2758                 if (now) {
2759                         res = send_packet(fr);
2760                 } else
2761                         res = iax2_transmit(fr);
2762         } else {
2763                 if (pvt->trunk) {
2764                         /* Queue for transmission in a meta frame */
2765                         if ((sizeof(pvt->trunkdata) - pvt->trunkdatalen) >= fr->af.datalen) {
2766                                 memcpy(pvt->trunkdata + pvt->trunkdatalen, fr->af.data, fr->af.datalen);
2767                                 pvt->trunkdatalen += fr->af.datalen;
2768                                 res = 0;
2769                                 pvt->trunkerror = 0;
2770                         } else {
2771                                 if (!pvt->trunkerror)
2772                                         ast_log(LOG_WARNING, "Out of trunk data space on call number %d, dropping\n", pvt->callno);
2773                                 pvt->trunkerror = 1;
2774                         }
2775                         res = 0;
2776                 } else if (fr->af.frametype == AST_FRAME_VIDEO) {
2777                         /* Video frame have no sequence number */
2778                         fr->oseqno = -1;
2779                         fr->iseqno = -1;
2780                         vh = (struct ast_iax2_video_hdr *)(fr->af.data - sizeof(struct ast_iax2_video_hdr));
2781                         vh->zeros = 0;
2782                         vh->callno = htons(0x8000 | fr->callno);
2783                         vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass & 0x1 ? 0x8000 : 0));
2784                         fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
2785                         fr->data = vh;
2786                         fr->retries = -1;
2787                         res = send_packet(fr);
2788                 } else {
2789                         /* Mini-frames have no sequence number */
2790                         fr->oseqno = -1;
2791                         fr->iseqno = -1;
2792                         /* Mini frame will do */
2793                         mh = (struct ast_iax2_mini_hdr *)(fr->af.data - sizeof(struct ast_iax2_mini_hdr));
2794                         mh->callno = htons(fr->callno);
2795                         mh->ts = htons(fr->ts & 0xFFFF);
2796                         fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
2797                         fr->data = mh;
2798                         fr->retries = -1;
2799                         res = send_packet(fr);
2800                 }
2801         }
2802         return res;
2803 }
2804
2805
2806
2807 static int iax2_show_users(int fd, int argc, char *argv[])
2808 {
2809 #define FORMAT "%-15.15s  %-15.15s  %-15.15s  %-15.15s  %-5.5s\n"
2810 #define FORMAT2 "%-15.15s  %-15.15s  %-15.15d  %-15.15s  %-5.5s\n"
2811         struct iax2_user *user;
2812         if (argc != 3)
2813                 return RESULT_SHOWUSAGE;
2814         ast_mutex_lock(&userl.lock);
2815         ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
2816         for(user=userl.users;user;user=user->next) {
2817                 ast_cli(fd, FORMAT2, user->name, user->secret, user->authmethods,
2818                                 user->contexts ? user->contexts->context : context,
2819                                 user->ha ? "Yes" : "No");
2820         }
2821         ast_mutex_unlock(&userl.lock);
2822         return RESULT_SUCCESS;
2823 #undef FORMAT
2824 #undef FORMAT2
2825 }
2826
2827 static int iax2_show_peers(int fd, int argc, char *argv[])
2828 {
2829 #define FORMAT2 "%-15.15s  %-15.15s %s  %-15.15s  %-8s  %-10s\n"
2830 #define FORMAT "%-15.15s  %-15.15s %s  %-15.15s  %-5d%s  %-10s\n"
2831         struct iax2_peer *peer;
2832         char name[256] = "";
2833         int registeredonly=0;
2834         if ((argc != 3) && (argc != 4))
2835                 return RESULT_SHOWUSAGE;
2836         if ((argc == 4)) {
2837                 if (!strcasecmp(argv[3], "registered")) {
2838                         registeredonly = 1;
2839                 } else
2840                         return RESULT_SHOWUSAGE;
2841         }
2842         ast_mutex_lock(&peerl.lock);
2843         ast_cli(fd, FORMAT2, "Name/Username", "Host", "   ", "Mask", "Port", "Status");
2844         for (peer = peerl.peers;peer;peer = peer->next) {
2845                 char nm[20];
2846                 char status[20];
2847                 if (registeredonly && !peer->addr.sin_addr.s_addr)
2848                         continue;
2849                 if (strlen(peer->username))
2850                         snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
2851                 else
2852                         strncpy(name, peer->name, sizeof(name) - 1);
2853                 if (peer->maxms) {
2854                         if (peer->lastms < 0)
2855                                 strcpy(status, "UNREACHABLE");
2856                         else if (peer->lastms > peer->maxms)
2857                                 snprintf(status, sizeof(status), "LAGGED (%d ms)", peer->lastms);
2858                         else if (peer->lastms)
2859                                 snprintf(status, sizeof(status), "OK (%d ms)", peer->lastms);
2860                         else
2861                                 strcpy(status, "UNKNOWN");
2862                 } else
2863                         strcpy(status, "Unmonitored");
2864                 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm)-1);
2865                 ast_cli(fd, FORMAT, name,
2866                                         peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Unspecified)",
2867                                         peer->dynamic ? "(D)" : "(S)",
2868                                         nm,
2869                                         ntohs(peer->addr.sin_port), peer->trunk ? "(T)" : "   ", status);
2870         }
2871         ast_mutex_unlock(&peerl.lock);
2872         return RESULT_SUCCESS;
2873 #undef FORMAT
2874 #undef FORMAT2
2875 }
2876
2877 static int iax2_show_firmware(int fd, int argc, char *argv[])
2878 {
2879 #define FORMAT2 "%-15.15s  %-15.15s %-15.15s\n"
2880 #define FORMAT "%-15.15s  %-15d %-15d\n"
2881         struct iax_firmware *cur;
2882         if ((argc != 3) && (argc != 4))
2883                 return RESULT_SHOWUSAGE;
2884         ast_mutex_lock(&waresl.lock);
2885
2886         ast_cli(fd, FORMAT2, "Device", "Version", "Size");
2887         for (cur = waresl.wares;cur;cur = cur->next) {
2888                 if ((argc == 3) || (!strcasecmp(argv[3], cur->fwh->devname)))
2889                         ast_cli(fd, FORMAT, cur->fwh->devname, ntohs(cur->fwh->version),
2890                                                 ntohl(cur->fwh->datalen));
2891         }
2892         ast_mutex_unlock(&waresl.lock);
2893         return RESULT_SUCCESS;
2894 #undef FORMAT
2895 #undef FORMAT2
2896 }
2897
2898 /* JDG: callback to display iax peers in manager */
2899 static int manager_iax2_show_peers( struct mansession *s, struct message *m )
2900 {
2901         char *a[] = { "iax2", "show", "users" };
2902         int ret;
2903         ret = iax2_show_peers( s->fd, 3, a );
2904         ast_cli( s->fd, "\r\n" );
2905         return ret;
2906 } /* /JDG */
2907
2908 static char *regstate2str(int regstate)
2909 {
2910         switch(regstate) {
2911         case REG_STATE_UNREGISTERED:
2912                 return "Unregistered";
2913         case REG_STATE_REGSENT:
2914                 return "Request Sent";
2915         case REG_STATE_AUTHSENT:
2916                 return "Auth. Sent";
2917         case REG_STATE_REGISTERED:
2918                 return "Registered";
2919         case REG_STATE_REJECTED:
2920                 return "Rejected";
2921         case REG_STATE_TIMEOUT:
2922                 return "Timeout";
2923         case REG_STATE_NOAUTH:
2924                 return "No Authentication";
2925         default:
2926                 return "Unknown";
2927         }
2928 }
2929
2930 static int iax2_show_registry(int fd, int argc, char *argv[])
2931 {
2932 #define FORMAT2 "%-20.20s  %-10.10s  %-20.20s %8.8s  %s\n"
2933 #define FORMAT "%-20.20s  %-10.10s  %-20.20s %8d  %s\n"
2934         struct iax2_registry *reg;
2935         char host[80];
2936         char perceived[80];
2937         if (argc != 3)
2938                 return RESULT_SHOWUSAGE;
2939         ast_mutex_lock(&peerl.lock);
2940         ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State");
2941         for (reg = registrations;reg;reg = reg->next) {
2942                 snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port));
2943                 if (reg->us.sin_addr.s_addr)
2944                         snprintf(perceived, sizeof(perceived), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
2945                 else
2946                         strcpy(perceived, "<Unregistered>");
2947                 ast_cli(fd, FORMAT, host,
2948                                         reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
2949         }
2950         ast_mutex_unlock(&peerl.lock);
2951         return RESULT_SUCCESS;
2952 #undef FORMAT
2953 #undef FORMAT2
2954 }
2955
2956 static int iax2_show_channels(int fd, int argc, char *argv[])
2957 {
2958 #define FORMAT2 "%-15.15s  %-10.10s  %-11.11s  %-11.11s  %-7.7s  %-6.6s  %s\n"
2959 #define FORMAT  "%-15.15s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  %-5.5dms  %-4.4dms  %-6.6s\n"
2960         int x;
2961         int numchans = 0;
2962         if (argc != 3)
2963                 return RESULT_SHOWUSAGE;
2964         ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
2965         for (x=0;x<IAX_MAX_CALLS;x++) {
2966                 ast_mutex_lock(&iaxsl[x]);
2967                 if (iaxs[x]) {
2968                         ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
2969                                                 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
2970                                                 iaxs[x]->callno, iaxs[x]->peercallno,
2971                                                 iaxs[x]->oseqno, iaxs[x]->iseqno,
2972                                                 iaxs[x]->lag,
2973                                                 iaxs[x]->jitter,
2974                                                 ast_getformatname(iaxs[x]->voiceformat) );
2975                         numchans++;
2976                 }
2977                 ast_mutex_unlock(&iaxsl[x]);
2978         }
2979         ast_cli(fd, "%d active IAX channel(s)\n", numchans);
2980         return RESULT_SUCCESS;
2981 #undef FORMAT
2982 #undef FORMAT2
2983 }
2984
2985 static int iax2_do_trunk_debug(int fd, int argc, char *argv[])
2986 {
2987         if (argc != 3)
2988                 return RESULT_SHOWUSAGE;
2989         iaxtrunkdebug = 1;
2990         ast_cli(fd, "IAX2 Trunk Debug Requested\n");
2991         return RESULT_SUCCESS;
2992 }
2993
2994 static int iax2_do_debug(int fd, int argc, char *argv[])
2995 {
2996         if (argc != 2)
2997                 return RESULT_SHOWUSAGE;
2998         iaxdebug = 1;
2999         ast_cli(fd, "IAX2 Debugging Enabled\n");
3000         return RESULT_SUCCESS;
3001 }
3002
3003 static int iax2_no_debug(int fd, int argc, char *argv[])
3004 {
3005         if (argc != 3)
3006                 return RESULT_SHOWUSAGE;
3007         iaxdebug = 0;
3008         ast_cli(fd, "IAX2 Debugging Disabled\n");
3009         return RESULT_SUCCESS;
3010 }
3011
3012
3013
3014 static char show_users_usage[] =
3015 "Usage: iax2 show users\n"
3016 "       Lists all users known to the IAX (Inter-Asterisk eXchange rev 2) subsystem.\n";
3017
3018 static char show_channels_usage[] =
3019 "Usage: iax2 show channels\n"
3020 "       Lists all currently active IAX channels.\n";
3021
3022 static char show_peers_usage[] =
3023 "Usage: iax2 show peers\n"
3024 "       Lists all known IAX peers.\n";
3025
3026 static char show_firmware_usage[] =
3027 "Usage: iax2 show firmware\n"
3028 "       Lists all known IAX firmware images.\n";
3029
3030 static char show_reg_usage[] =
3031 "Usage: iax2 show registry\n"
3032 "       Lists all registration requests and status.\n";
3033
3034 static char debug_usage[] =
3035 "Usage: iax2 debug\n"
3036 "       Enables dumping of IAX packets for debugging purposes\n";
3037
3038 static char no_debug_usage[] =
3039 "Usage: iax2 no debug\n"
3040 "       Disables dumping of IAX packets for debugging purposes\n";
3041
3042 static char debug_trunk_usage[] =
3043 "Usage: iax2 trunk debug\n"
3044 "       Requests current status of IAX trunking\n";
3045
3046 static struct ast_cli_entry  cli_show_users =
3047         { { "iax2", "show", "users", NULL }, iax2_show_users, "Show defined IAX users", show_users_usage };
3048 static struct ast_cli_entry  cli_show_firmware =
3049         { { "iax2", "show", "firmware", NULL }, iax2_show_firmware, "Show available IAX firmwares", show_firmware_usage };
3050 static struct ast_cli_entry  cli_show_channels =
3051         { { "iax2", "show", "channels", NULL }, iax2_show_channels, "Show active IAX channels", show_channels_usage };
3052 static struct ast_cli_entry  cli_show_peers =
3053         { { "iax2", "show", "peers", NULL }, iax2_show_peers, "Show defined IAX peers", show_peers_usage };