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         while((de = readdir(fwd))) {
1055                 if (de->d_name[0] != '.') {
1056                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1057                         if (!try_firmware(fn)) {
1058                                 if (option_verbose > 1)
1059                                         ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1060                         }
1061                 }
1062         }
1063         closedir(fwd);
1064
1065         /* Clean up leftovers */
1066         cur = waresl.wares;
1067         curp = NULL;
1068         while(cur) {
1069                 curl = cur;
1070                 cur = cur->next;
1071                 if (curl->dead) {
1072                         if (curp) {
1073                                 curp->next = cur;
1074                         } else {
1075                                 waresl.wares = cur;
1076                         }
1077                         destroy_firmware(curl);
1078                 } else {
1079                         curp = cur;
1080                 }
1081         }
1082         ast_mutex_unlock(&waresl.lock);
1083 }
1084
1085 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1086
1087 static int __do_deliver(void *data)
1088 {
1089         /* Just deliver the packet by using queueing.  This is called by
1090           the IAX thread with the iaxsl lock held. */
1091         struct iax_frame *fr = data;
1092         unsigned int ts;
1093         fr->retrans = -1;
1094         if (iaxs[fr->callno] && !iaxs[fr->callno]->alreadygone) {
1095                 if (fr->af.frametype == AST_FRAME_IAX) {
1096                         /* We have to treat some of these packets specially because
1097                            they're LAG measurement packets */
1098                         if (fr->af.subclass == IAX_COMMAND_LAGRQ) {
1099                                 /* If we got a queued request, build a reply and send it */
1100                                 fr->af.subclass = IAX_COMMAND_LAGRP;
1101                                 iax2_send(iaxs[fr->callno], &fr->af, fr->ts, -1, 0, 0, 0);
1102                         } else if (fr->af.subclass == IAX_COMMAND_LAGRP) {
1103                                 /* This is a reply we've been given, actually measure the difference */
1104                                 ts = calc_timestamp(iaxs[fr->callno], 0, NULL);
1105                                 iaxs[fr->callno]->lag = ts - fr->ts;
1106                         }
1107                 } else {
1108                         iax2_queue_frame(fr->callno, &fr->af);
1109                 }
1110         }
1111         /* Free our iax frame */
1112         iax2_frame_free(fr);
1113         /* And don't run again */
1114         return 0;
1115 }
1116
1117 static int do_deliver(void *data)
1118 {
1119         /* Locking version of __do_deliver */
1120         struct iax_frame *fr = data;
1121         int callno = fr->callno;
1122         int res;
1123         ast_mutex_lock(&iaxsl[callno]);
1124         res = __do_deliver(data);
1125         ast_mutex_unlock(&iaxsl[callno]);
1126         return res;
1127 }
1128
1129 static int handle_error(void)
1130 {
1131         /* XXX Ideally we should figure out why an error occured and then abort those
1132            rather than continuing to try.  Unfortunately, the published interface does
1133            not seem to work XXX */
1134 #if 0
1135         struct sockaddr_in *sin;
1136         int res;
1137         struct msghdr m;
1138         struct sock_extended_err e;
1139         m.msg_name = NULL;
1140         m.msg_namelen = 0;
1141         m.msg_iov = NULL;
1142         m.msg_control = &e;
1143         m.msg_controllen = sizeof(e);
1144         m.msg_flags = 0;
1145         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1146         if (res < 0)
1147                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1148         else {
1149                 if (m.msg_controllen) {
1150                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1151                         if (sin)
1152                                 ast_log(LOG_WARNING, "Receive error from %s\n", inet_ntoa(sin->sin_addr));
1153                         else
1154                                 ast_log(LOG_WARNING, "No address detected??\n");
1155                 } else {
1156                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1157                 }
1158         }
1159 #endif
1160         return 0;
1161 }
1162
1163 static int send_packet(struct iax_frame *f)
1164 {
1165         int res;
1166         /* Called with iaxsl held */
1167         if (option_debug)
1168                 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));
1169         /* Don't send if there was an error, but return error instead */
1170         if (!f->callno) {
1171                 ast_log(LOG_WARNING, "Call number = %d\n", f->callno);
1172                 return -1;
1173         }
1174         if (!iaxs[f->callno])
1175                 return -1;
1176         if (iaxs[f->callno]->error)
1177                 return -1;
1178         if (f->transfer) {
1179                 if (iaxdebug)
1180                         iax_showframe(f, NULL, 0, &iaxs[f->callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1181                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->transfer,
1182                                         sizeof(iaxs[f->callno]->transfer));
1183         } else {
1184                 if (iaxdebug)
1185                         iax_showframe(f, NULL, 0, &iaxs[f->callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1186                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->addr,
1187                                         sizeof(iaxs[f->callno]->addr));
1188         }
1189         if (res < 0) {
1190                 if (option_debug)
1191                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1192                 handle_error();
1193         } else
1194                 res = 0;
1195         return res;
1196 }
1197
1198
1199 static int iax2_predestroy(int callno)
1200 {
1201         struct ast_channel *c;
1202         struct chan_iax2_pvt *pvt;
1203         ast_mutex_lock(&iaxsl[callno]);
1204         pvt = iaxs[callno];
1205         if (!pvt) {
1206                 ast_mutex_unlock(&iaxsl[callno]);
1207                 return -1;
1208         }
1209         if (!pvt->alreadygone) {
1210                 /* No more pings or lagrq's */
1211                 if (pvt->pingid > -1)
1212                         ast_sched_del(sched, pvt->pingid);
1213                 if (pvt->lagid > -1)
1214                         ast_sched_del(sched, pvt->lagid);
1215                 if (pvt->autoid > -1)
1216                         ast_sched_del(sched, pvt->autoid);
1217                 if (pvt->initid > -1)
1218                         ast_sched_del(sched, pvt->initid);
1219                 pvt->pingid = -1;
1220                 pvt->lagid = -1;
1221                 pvt->autoid = -1;
1222                 pvt->initid = -1;
1223                 pvt->alreadygone = 1;
1224         }
1225         c = pvt->owner;
1226         if (c) {
1227                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1228                 c->pvt->pvt = NULL;
1229                 ast_queue_hangup(c, 0);
1230                 pvt->owner = NULL;
1231                 ast_mutex_lock(&usecnt_lock);
1232                 usecnt--;
1233                 if (usecnt < 0)
1234                         ast_log(LOG_WARNING, "Usecnt < 0???\n");
1235                 ast_mutex_unlock(&usecnt_lock);
1236         }
1237         ast_mutex_unlock(&iaxsl[callno]);
1238         ast_update_use_count();
1239         return 0;
1240 }
1241
1242 static int iax2_predestroy_nolock(int callno)
1243 {
1244         int res;
1245         ast_mutex_unlock(&iaxsl[callno]);
1246         res = iax2_predestroy(callno);
1247         ast_mutex_lock(&iaxsl[callno]);
1248         return res;
1249 }
1250
1251 static void iax2_destroy(int callno)
1252 {
1253         struct chan_iax2_pvt *pvt;
1254         struct iax_frame *cur;
1255         struct ast_channel *owner;
1256
1257 retry:
1258         ast_mutex_lock(&iaxsl[callno]);
1259         pvt = iaxs[callno];
1260         gettimeofday(&lastused[callno], NULL);
1261
1262         if (pvt)
1263                 owner = pvt->owner;
1264         else
1265                 owner = NULL;
1266         if (owner) {
1267                 if (ast_mutex_trylock(&owner->lock)) {
1268                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1269                         ast_mutex_unlock(&iaxsl[callno]);
1270                         usleep(1);
1271                         goto retry;
1272                 }
1273         }
1274         if (!owner)
1275                 iaxs[callno] = NULL;
1276         if (pvt) {
1277                 if (!owner)
1278                         pvt->owner = NULL;
1279                 /* No more pings or lagrq's */
1280                 if (pvt->pingid > -1)
1281                         ast_sched_del(sched, pvt->pingid);
1282                 if (pvt->lagid > -1)
1283                         ast_sched_del(sched, pvt->lagid);
1284                 if (pvt->autoid > -1)
1285                         ast_sched_del(sched, pvt->autoid);
1286                 if (pvt->initid > -1)
1287                         ast_sched_del(sched, pvt->initid);
1288                 pvt->pingid = -1;
1289                 pvt->lagid = -1;
1290                 pvt->autoid = -1;
1291                 pvt->initid = -1;
1292                 if (pvt->bridgetrans)
1293                         ast_translator_free_path(pvt->bridgetrans);
1294                 pvt->bridgetrans = NULL;
1295
1296                 /* Already gone */
1297                 pvt->alreadygone = 1;
1298
1299                 if (owner) {
1300                         /* If there's an owner, prod it to give up */
1301                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1302                         ast_queue_hangup(owner, 0);
1303                 }
1304
1305                 for (cur = iaxq.head; cur ; cur = cur->next) {
1306                         /* Cancel any pending transmissions */
1307                         if (cur->callno == pvt->callno)
1308                                 cur->retries = -1;
1309                 }
1310                 if (pvt->reg) {
1311                         pvt->reg->callno = 0;
1312                 }
1313                 if (!owner)
1314                         free(pvt);
1315         }
1316         if (owner) {
1317                 ast_mutex_unlock(&owner->lock);
1318         }
1319         ast_mutex_unlock(&iaxsl[callno]);
1320         if (callno & 0x4000)
1321                 update_max_trunk();
1322 }
1323 static void iax2_destroy_nolock(int callno)
1324 {
1325         /* Actually it's easier to unlock, kill it, and relock */
1326         ast_mutex_unlock(&iaxsl[callno]);
1327         iax2_destroy(callno);
1328         ast_mutex_lock(&iaxsl[callno]);
1329 }
1330
1331 static int update_packet(struct iax_frame *f)
1332 {
1333         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1334         struct ast_iax2_full_hdr *fh = f->data;
1335         /* Mark this as a retransmission */
1336         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1337         /* Update iseqno */
1338         f->iseqno = iaxs[f->callno]->iseqno;
1339         fh->iseqno = f->iseqno;
1340         return 0;
1341 }
1342
1343 static int attempt_transmit(void *data)
1344 {
1345         /* Attempt to transmit the frame to the remote peer...
1346            Called without iaxsl held. */
1347         struct iax_frame *f = data;
1348         int freeme=0;
1349         int callno = f->callno;
1350         /* Make sure this call is still active */
1351         if (callno)
1352                 ast_mutex_lock(&iaxsl[callno]);
1353         if ((f->callno) && iaxs[f->callno]) {
1354                 if ((f->retries < 0) /* Already ACK'd */ ||
1355                     (f->retries >= max_retries) /* Too many attempts */) {
1356                                 /* Record an error if we've transmitted too many times */
1357                                 if (f->retries >= max_retries) {
1358                                         if (f->transfer) {
1359                                                 /* Transfer timeout */
1360                                                 send_command(iaxs[f->callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1361                                         } else if (f->final) {
1362                                                 if (f->final)
1363                                                         iax2_destroy_nolock(f->callno);
1364                                         } else {
1365                                                 if (iaxs[f->callno]->owner)
1366                                                         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);
1367                                                 iaxs[f->callno]->error = ETIMEDOUT;
1368                                                 if (iaxs[f->callno]->owner) {
1369                                                         struct ast_frame fr = { 0, };
1370                                                         /* Hangup the fd */
1371                                                         fr.frametype = AST_FRAME_CONTROL;
1372                                                         fr.subclass = AST_CONTROL_HANGUP;
1373                                                         iax2_queue_frame(f->callno, &fr);
1374                                                 } else {
1375                                                         if (iaxs[f->callno]->reg) {
1376                                                                 memset(&iaxs[f->callno]->reg->us, 0, sizeof(iaxs[f->callno]->reg->us));
1377                                                                 iaxs[f->callno]->reg->regstate = REG_STATE_TIMEOUT;
1378                                                                 iaxs[f->callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1379                                                         }
1380                                                         iax2_destroy_nolock(f->callno);
1381                                                 }
1382                                         }
1383
1384                                 }
1385                                 freeme++;
1386                 } else {
1387                         /* Update it if it needs it */
1388                         update_packet(f);
1389                         /* Attempt transmission */
1390                         send_packet(f);
1391                         f->retries++;
1392                         /* Try again later after 10 times as long */
1393                         f->retrytime *= 10;
1394                         if (f->retrytime > MAX_RETRY_TIME)
1395                                 f->retrytime = MAX_RETRY_TIME;
1396                         /* Transfer messages max out at one second */
1397                         if (f->transfer && (f->retrytime > 1000))
1398                                 f->retrytime = 1000;
1399                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1400                 }
1401         } else {
1402                 /* Make sure it gets freed */
1403                 f->retries = -1;
1404                 freeme++;
1405         }
1406         if (callno)
1407                 ast_mutex_unlock(&iaxsl[callno]);
1408         /* Do not try again */
1409         if (freeme) {
1410                 /* Don't attempt delivery, just remove it from the queue */
1411                 ast_mutex_lock(&iaxq.lock);
1412                 if (f->prev)
1413                         f->prev->next = f->next;
1414                 else
1415                         iaxq.head = f->next;
1416                 if (f->next)
1417                         f->next->prev = f->prev;
1418                 else
1419                         iaxq.tail = f->prev;
1420                 iaxq.count--;
1421                 ast_mutex_unlock(&iaxq.lock);
1422                 f->retrans = -1;
1423                 /* Free the IAX frame */
1424                 iax2_frame_free(f);
1425         }
1426         return 0;
1427 }
1428
1429 static int iax2_set_jitter(int fd, int argc, char *argv[])
1430 {
1431         if ((argc != 4) && (argc != 5))
1432                 return RESULT_SHOWUSAGE;
1433         if (argc == 4) {
1434                 max_jitter_buffer = atoi(argv[3]);
1435                 if (max_jitter_buffer < 0)
1436                         max_jitter_buffer = 0;
1437         } else {
1438                 if (argc == 5) {
1439                         if ((atoi(argv[3]) >= 0) && (atoi(argv[3]) < IAX_MAX_CALLS)) {
1440                                 if (iaxs[atoi(argv[3])]) {
1441                                         iaxs[atoi(argv[3])]->jitterbuffer = atoi(argv[4]);
1442                                         if (iaxs[atoi(argv[3])]->jitterbuffer < 0)
1443                                                 iaxs[atoi(argv[3])]->jitterbuffer = 0;
1444                                 } else
1445                                         ast_cli(fd, "No such call '%d'\n", atoi(argv[3]));
1446                         } else
1447                                 ast_cli(fd, "%d is not a valid call number\n", atoi(argv[3]));
1448                 }
1449         }
1450         return RESULT_SUCCESS;
1451 }
1452
1453 static char jitter_usage[] =
1454 "Usage: iax set jitter [callid] <value>\n"
1455 "       If used with a callid, it sets the jitter buffer to the given static\n"
1456 "value (until its next calculation).  If used without a callid, the value is used\n"
1457 "to establish the maximum excess jitter buffer that is permitted before the jitter\n"
1458 "buffer size is reduced.";
1459
1460 static int iax2_show_stats(int fd, int argc, char *argv[])
1461 {
1462         struct iax_frame *cur;
1463         int cnt = 0, dead=0, final=0;
1464         if (argc != 3)
1465                 return RESULT_SHOWUSAGE;
1466         for (cur = iaxq.head; cur ; cur = cur->next) {
1467                 if (cur->retries < 0)
1468                         dead++;
1469                 if (cur->final)
1470                         final++;
1471                 cnt++;
1472         }
1473         ast_cli(fd, "    IAX Statistics\n");
1474         ast_cli(fd, "---------------------\n");
1475         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d outgress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
1476         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n", dead, final, cnt);
1477         return RESULT_SUCCESS;
1478 }
1479
1480 static int iax2_show_cache(int fd, int argc, char *argv[])
1481 {
1482         struct iax2_dpcache *dp;
1483         char tmp[1024], *pc;
1484         int s;
1485         int x,y;
1486         struct timeval tv;
1487         gettimeofday(&tv, NULL);
1488         ast_mutex_lock(&dpcache_lock);
1489         dp = dpcache;
1490         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
1491         while(dp) {
1492                 s = dp->expirey.tv_sec - tv.tv_sec;
1493                 strcpy(tmp, "");
1494                 if (dp->flags & CACHE_FLAG_EXISTS)
1495                         strcat(tmp, "EXISTS|");
1496                 if (dp->flags & CACHE_FLAG_NONEXISTANT)
1497                         strcat(tmp, "NONEXISTANT|");
1498                 if (dp->flags & CACHE_FLAG_CANEXIST)
1499                         strcat(tmp, "CANEXIST|");
1500                 if (dp->flags & CACHE_FLAG_PENDING)
1501                         strcat(tmp, "PENDING|");
1502                 if (dp->flags & CACHE_FLAG_TIMEOUT)
1503                         strcat(tmp, "TIMEOUT|");
1504                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
1505                         strcat(tmp, "TRANSMITTED|");
1506                 if (dp->flags & CACHE_FLAG_MATCHMORE)
1507                         strcat(tmp, "MATCHMORE|");
1508                 if (dp->flags & CACHE_FLAG_UNKNOWN)
1509                         strcat(tmp, "UNKNOWN|");
1510                 /* Trim trailing pipe */
1511                 if (strlen(tmp))
1512                         tmp[strlen(tmp) - 1] = '\0';
1513                 else
1514                         strcpy(tmp, "(none)");
1515                 y=0;
1516                 pc = strchr(dp->peercontext, '@');
1517                 if (!pc)
1518                         pc = dp->peercontext;
1519                 else
1520                         pc++;
1521                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
1522                         if (dp->waiters[x] > -1)
1523                                 y++;
1524                 if (s > 0)
1525                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
1526                 else
1527                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
1528                 dp = dp->next;
1529         }
1530         ast_mutex_unlock(&dpcache_lock);
1531         return RESULT_SUCCESS;
1532 }
1533
1534 static char show_stats_usage[] =
1535 "Usage: iax show stats\n"
1536 "       Display statistics on IAX channel driver.\n";
1537
1538
1539 static char show_cache_usage[] =
1540 "Usage: iax show cache\n"
1541 "       Display currently cached IAX Dialplan results.\n";
1542
1543 static struct ast_cli_entry cli_set_jitter =
1544 { { "iax2", "set", "jitter", NULL }, iax2_set_jitter, "Sets IAX jitter buffer", jitter_usage };
1545
1546 static struct ast_cli_entry cli_show_stats =
1547 { { "iax2", "show", "stats", NULL }, iax2_show_stats, "Display IAX statistics", show_stats_usage };
1548
1549 static struct ast_cli_entry cli_show_cache =
1550 { { "iax2", "show", "cache", NULL }, iax2_show_cache, "Display IAX cached dialplan", show_cache_usage };
1551
1552 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p);
1553
1554 #ifdef BRIDGE_OPTIMIZATION
1555 static unsigned int calc_fakestamp(struct chan_iax2_pvt *from, struct chan_iax2_pvt *to, unsigned int ts);
1556
1557 static int forward_delivery(struct iax_frame *fr)
1558 {
1559         struct chan_iax2_pvt *p1, *p2;
1560         p1 = iaxs[fr->callno];
1561         p2 = iaxs[p1->bridgecallno];
1562         if (!p1)
1563                 return -1;
1564         if (!p2)
1565                 return -1;
1566         /* Fix relative timestamp */
1567         fr->ts = calc_fakestamp(p1, p2, fr->ts);
1568         /* Now just send it send on the 2nd one
1569            with adjusted timestamp */
1570         return iax2_send(p2, &fr->af, fr->ts, -1, 0, 0, 0);
1571 }
1572 #endif
1573
1574 static int schedule_delivery(struct iax_frame *fr, int reallydeliver, int updatehistory)
1575 {
1576         int ms,x;
1577         int drops[MEMORY_SIZE];
1578         int min, max=0, maxone=0,y,z, match;
1579         /* ms is a measure of the "lateness" of the packet relative to the first
1580            packet we received, which always has a lateness of 1.  Called by
1581            IAX thread, with iaxsl lock held. */
1582         ms = calc_rxstamp(iaxs[fr->callno]) - fr->ts;
1583
1584         if (ms > 32767) {
1585                 /* What likely happened here is that our counter has circled but we haven't
1586                    gotten the update from the main packet.  We'll just pretend that we did, and
1587                    update the timestamp appropriately. */
1588                 ms -= 65536;
1589                 fr->ts += 65536;
1590         }
1591
1592         if (ms < -32768) {
1593                 /* We got this packet out of order.  Lets add 65536 to it to bring it into our new
1594                    time frame */
1595                 ms += 65536;
1596                 fr->ts -= 65536;
1597         }
1598
1599         fr->af.delivery.tv_sec = iaxs[fr->callno]->rxcore.tv_sec;
1600         fr->af.delivery.tv_usec = iaxs[fr->callno]->rxcore.tv_usec;
1601         fr->af.delivery.tv_sec += fr->ts / 1000;
1602         fr->af.delivery.tv_usec += (fr->ts % 1000) * 1000;
1603         if (fr->af.delivery.tv_usec >= 1000000) {
1604                 fr->af.delivery.tv_usec -= 1000000;
1605                 fr->af.delivery.tv_sec += 1;
1606         }
1607
1608
1609         /* Rotate our history queue of "lateness".  Don't worry about those initial
1610            zeros because the first entry will always be zero */
1611         if (updatehistory) {
1612                 for (x=0;x<MEMORY_SIZE - 1;x++)
1613                         iaxs[fr->callno]->history[x] = iaxs[fr->callno]->history[x+1];
1614                 /* Add a history entry for this one */
1615                 iaxs[fr->callno]->history[x] = ms;
1616         }
1617
1618         /* Initialize the minimum to reasonable values.  It's too much
1619            work to do the same for the maximum, repeatedly */
1620         min=iaxs[fr->callno]->history[0];
1621         for (z=0;z < iax2_dropcount + 1;z++) {
1622                 /* Start very optimistic ;-) */
1623                 max=-999999999;
1624                 for (x=0;x<MEMORY_SIZE;x++) {
1625                         if (max < iaxs[fr->callno]->history[x]) {
1626                                 /* We have a candidate new maximum value.  Make
1627                                    sure it's not in our drop list */
1628                                 match = 0;
1629                                 for (y=0;!match && (y<z);y++)
1630                                         match |= (drops[y] == x);
1631                                 if (!match) {
1632                                         /* It's not in our list, use it as the new maximum */
1633                                         max = iaxs[fr->callno]->history[x];
1634                                         maxone = x;
1635                                 }
1636
1637                         }
1638                         if (!z) {
1639                                 /* On our first pass, find the minimum too */
1640                                 if (min > iaxs[fr->callno]->history[x])
1641                                         min = iaxs[fr->callno]->history[x];
1642                         }
1643                 }
1644 #if 1
1645                 drops[z] = maxone;
1646 #endif
1647         }
1648         /* Just for reference, keep the "jitter" value, the difference between the
1649            earliest and the latest. */
1650         iaxs[fr->callno]->jitter = max - min;
1651
1652         /* IIR filter for keeping track of historic jitter, but always increase
1653            historic jitter immediately for increase */
1654
1655         if (iaxs[fr->callno]->jitter > iaxs[fr->callno]->historicjitter )
1656                 iaxs[fr->callno]->historicjitter = iaxs[fr->callno]->jitter;
1657         else
1658                 iaxs[fr->callno]->historicjitter = GAMMA * (double)iaxs[fr->callno]->jitter + (1-GAMMA) *
1659                         iaxs[fr->callno]->historicjitter;
1660
1661         /* If our jitter buffer is too big (by a significant margin), then we slowly
1662            shrink it by about 1 ms each time to avoid letting the change be perceived */
1663         if (max < iaxs[fr->callno]->jitterbuffer - max_jitter_buffer)
1664                 iaxs[fr->callno]->jitterbuffer -= 2;
1665
1666
1667 #if 1
1668         /* Constrain our maximum jitter buffer appropriately */
1669         if (max > min + maxjitterbuffer) {
1670                 if (option_debug)
1671                         ast_log(LOG_DEBUG, "Constraining buffer from %d to %d + %d\n", max, min , maxjitterbuffer);
1672                 max = min + maxjitterbuffer;
1673         }
1674 #endif
1675
1676         /* If our jitter buffer is smaller than our maximum delay, grow the jitter
1677            buffer immediately to accomodate it (and a little more).  */
1678         if (max > iaxs[fr->callno]->jitterbuffer)
1679                 iaxs[fr->callno]->jitterbuffer = max
1680                         /* + ((float)iaxs[fr->callno]->jitter) * 0.1 */;
1681
1682
1683         if (option_debug)
1684                 ast_log(LOG_DEBUG, "min = %d, max = %d, jb = %d, lateness = %d\n", min, max, iaxs[fr->callno]->jitterbuffer, ms);
1685
1686         /* Subtract the lateness from our jitter buffer to know how long to wait
1687            before sending our packet.  */
1688         ms = iaxs[fr->callno]->jitterbuffer - ms;
1689
1690         if (!use_jitterbuffer)
1691                 ms = 0;
1692
1693         /* If the caller just wanted us to update, return now */
1694         if (!reallydeliver)
1695                 return 0;
1696
1697         if (ms < 1) {
1698                 if (option_debug)
1699                         ast_log(LOG_DEBUG, "Calculated ms is %d\n", ms);
1700                 /* Don't deliver it more than 4 ms late */
1701                 if ((ms > -4) || (fr->af.frametype != AST_FRAME_VOICE)) {
1702                         __do_deliver(fr);
1703                 } else {
1704                         if (option_debug)
1705                                 ast_log(LOG_DEBUG, "Dropping voice packet since %d ms is, too old\n", ms);
1706                         /* Free our iax frame */
1707                         iax2_frame_free(fr);
1708                 }
1709         } else {
1710                 if (option_debug)
1711                         ast_log(LOG_DEBUG, "Scheduling delivery in %d ms\n", ms);
1712                 fr->retrans = ast_sched_add(sched, ms, do_deliver, fr);
1713         }
1714         return 0;
1715 }
1716
1717 static int iax2_transmit(struct iax_frame *fr)
1718 {
1719         /* Lock the queue and place this packet at the end */
1720         fr->next = NULL;
1721         fr->prev = NULL;
1722         /* By setting this to 0, the network thread will send it for us, and
1723            queue retransmission if necessary */
1724         fr->sentyet = 0;
1725         ast_mutex_lock(&iaxq.lock);
1726         if (!iaxq.head) {
1727                 /* Empty queue */
1728                 iaxq.head = fr;
1729                 iaxq.tail = fr;
1730         } else {
1731                 /* Double link */
1732                 iaxq.tail->next = fr;
1733                 fr->prev = iaxq.tail;
1734                 iaxq.tail = fr;
1735         }
1736         iaxq.count++;
1737         ast_mutex_unlock(&iaxq.lock);
1738         /* Wake up the network thread */
1739         pthread_kill(netthreadid, SIGURG);
1740         return 0;
1741 }
1742
1743
1744
1745 static int iax2_digit(struct ast_channel *c, char digit)
1746 {
1747         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
1748 }
1749
1750 static int iax2_sendtext(struct ast_channel *c, char *text)
1751 {
1752
1753         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_TEXT,
1754                 0, 0, text, strlen(text) + 1, -1);
1755 }
1756
1757 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
1758 {
1759         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
1760 }
1761
1762 static int iax2_sendhtml(struct ast_channel *c, int subclass, char *data, int datalen)
1763 {
1764         return send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_HTML, subclass, 0, data, datalen, -1);
1765 }
1766
1767 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan, int lock)
1768 {
1769         unsigned short callno = PTR_TO_CALLNO(newchan->pvt->pvt);
1770         if (lock)
1771                 ast_mutex_lock(&iaxsl[callno]);
1772         if (iaxs[callno])
1773                 iaxs[callno]->owner = newchan;
1774         else
1775                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
1776         if (lock)
1777                 ast_mutex_unlock(&iaxsl[callno]);
1778         return 0;
1779 }
1780
1781 #ifdef MYSQL_FRIENDS
1782
1783 static void mysql_update_peer(char *peer, struct sockaddr_in *sin)
1784 {
1785         if (mysql && (strlen(peer) < 128)) {
1786                 char query[512];
1787                 char *name;
1788                 time_t nowtime;
1789                 name = alloca(strlen(peer) * 2 + 1);
1790                 time(&nowtime);
1791                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1792                 snprintf(query, sizeof(query), "UPDATE iaxfriends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\" WHERE name=\"%s\"",
1793                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), nowtime, name);
1794                 ast_mutex_lock(&mysqllock);
1795                 if (mysql_real_query(mysql, query, strlen(query)))
1796                         ast_log(LOG_WARNING, "Unable to update database\n");
1797
1798                 ast_mutex_unlock(&mysqllock);
1799         }
1800 }
1801
1802 static struct iax2_peer *mysql_peer(char *peer)
1803 {
1804         struct iax2_peer *p;
1805         int success = 0;
1806
1807         p = malloc(sizeof(struct iax2_peer));
1808         memset(p, 0, sizeof(struct iax2_peer));
1809         if (mysql && (strlen(peer) < 128)) {
1810                 char query[512];
1811                 char *name;
1812                 int numfields, x;
1813                 int port;
1814                 time_t regseconds, nowtime;
1815                 MYSQL_RES *result;
1816                 MYSQL_FIELD *fields;
1817                 MYSQL_ROW rowval;
1818                 name = alloca(strlen(peer) * 2 + 1);
1819                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1820                 snprintf(query, sizeof(query), "SELECT * FROM iaxfriends WHERE name=\"%s\"", name);
1821                 ast_mutex_lock(&mysqllock);
1822                 mysql_query(mysql, query);
1823                 if ((result = mysql_store_result(mysql))) {
1824                         if ((rowval = mysql_fetch_row(result))) {
1825                                 numfields = mysql_num_fields(result);
1826                                 fields = mysql_fetch_fields(result);
1827                                 success = 1;
1828                                 for (x=0;x<numfields;x++) {
1829                                         if (rowval[x]) {
1830                                                 if (!strcasecmp(fields[x].name, "secret")) {
1831                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1832                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1833                                                         strncpy(p->context, rowval[x], sizeof(p->context) - 1);
1834                                                 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
1835                                                         inet_aton(rowval[x], &p->addr.sin_addr);
1836                                                 } else if (!strcasecmp(fields[x].name, "port")) {
1837                                                         if (sscanf(rowval[x], "%i", &port) != 1)
1838                                                                 port = 0;
1839                                                         p->addr.sin_port = htons(port);
1840                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1841                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
1842                                                                 regseconds = 0;
1843                                                 }
1844                                         }
1845                                 }
1846                                 time(&nowtime);
1847                                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE)
1848                                         memset(&p->addr, 0, sizeof(p->addr));
1849                         }
1850                         mysql_free_result(result);
1851                         result = NULL;
1852                 }
1853                 ast_mutex_unlock(&mysqllock);
1854         }
1855         if (!success) {
1856                 free(p);
1857                 p = NULL;
1858         } else {
1859                 strncpy(p->name, peer, sizeof(p->name) - 1);
1860                 p->dynamic = 1;
1861                 p->temponly = 1;
1862                 p->expire = -1;
1863                 p->capability = iax2_capability;
1864                 p->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
1865         }
1866         return p;
1867 }
1868 static struct iax2_user *mysql_user(char *user)
1869 {
1870         struct iax2_user *p;
1871         struct iax2_context *con;
1872         int success = 0;
1873
1874         p = malloc(sizeof(struct iax2_user));
1875         memset(p, 0, sizeof(struct iax2_user));
1876         con = malloc(sizeof(struct iax2_context));
1877         memset(con, 0, sizeof(struct iax2_context));
1878         strcpy(con->context, "default");
1879         p->contexts = con;
1880         if (mysql && (strlen(user) < 128)) {
1881                 char query[512];
1882                 char *name;
1883                 int numfields, x;
1884                 MYSQL_RES *result;
1885                 MYSQL_FIELD *fields;
1886                 MYSQL_ROW rowval;
1887                 name = alloca(strlen(user) * 2 + 1);
1888                 mysql_real_escape_string(mysql, name, user, strlen(user));
1889                 snprintf(query, sizeof(query), "SELECT * FROM iaxfriends WHERE name=\"%s\"", name);
1890                 ast_mutex_lock(&mysqllock);
1891                 mysql_query(mysql, query);
1892                 if ((result = mysql_store_result(mysql))) {
1893                         if ((rowval = mysql_fetch_row(result))) {
1894                                 numfields = mysql_num_fields(result);
1895                                 fields = mysql_fetch_fields(result);
1896                                 success = 1;
1897                                 for (x=0;x<numfields;x++) {
1898                                         if (rowval[x]) {
1899                                                 if (!strcasecmp(fields[x].name, "secret")) {
1900                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1901                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1902                                                         strncpy(p->contexts->context, rowval[x], sizeof(p->contexts->context) - 1);
1903                                                 }
1904                                         }
1905                                 }
1906                         }
1907                         mysql_free_result(result);
1908                         result = NULL;
1909                 }
1910                 ast_mutex_unlock(&mysqllock);
1911         }
1912         if (!success) {
1913                 if (p->contexts)
1914                         free(p->contexts);
1915                 free(p);
1916                 p = NULL;
1917         } else {
1918                 strncpy(p->name, user, sizeof(p->name) - 1);
1919                 p->temponly = 1;
1920                 p->capability = iax2_capability;
1921                 p->authmethods = IAX_AUTH_MD5 | IAX_AUTH_PLAINTEXT;
1922         }
1923         return p;
1924 }
1925 #endif /* MYSQL_FRIENDS */
1926
1927 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)
1928 {
1929         struct hostent *hp;
1930         struct iax2_peer *p;
1931         int found=0;
1932         if (sendani)
1933                 *sendani = 0;
1934         if (maxtime)
1935                 *maxtime = 0;
1936         if (trunk)
1937                 *trunk = 0;
1938         sin->sin_family = AF_INET;
1939         ast_mutex_lock(&peerl.lock);
1940         p = peerl.peers;
1941         while(p) {
1942                 if (!strcasecmp(p->name, peer)) {
1943                         break;
1944                 }
1945                 p = p->next;
1946         }
1947         ast_mutex_unlock(&peerl.lock);
1948 #ifdef MYSQL_FRIENDS
1949         if (!p)
1950                 p = mysql_peer(peer);
1951 #endif
1952         if (p) {
1953                 found++;
1954                 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1955                         (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
1956                         if (sendani)
1957                                 *sendani = p->sendani;          /* Whether we transmit ANI */
1958                         if (maxtime)
1959                                 *maxtime = p->maxms;            /* Max time they should take */
1960                         if (context)
1961                                 strncpy(context, p->context, AST_MAX_EXTENSION - 1);
1962                         if (trunk)
1963                                 *trunk = p->trunk;
1964                         if (capability)
1965                                 *capability = p->capability;
1966                         if (secret)
1967                                 strncpy(secret, p->secret, seclen);
1968                         if (p->addr.sin_addr.s_addr) {
1969                                 sin->sin_addr = p->addr.sin_addr;
1970                                 sin->sin_port = p->addr.sin_port;
1971                         } else {
1972                                 sin->sin_addr = p->defaddr.sin_addr;
1973                                 sin->sin_port = p->defaddr.sin_port;
1974                         }
1975                         if (notransfer)
1976                                 *notransfer=p->notransfer;
1977                 } else {
1978                         if (p->temponly)
1979                                 free(p);
1980                         p = NULL;
1981                 }
1982         }
1983         if (!p && !found) {
1984                 hp = gethostbyname(peer);
1985                 if (hp) {
1986                         memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
1987                         sin->sin_port = htons(IAX_DEFAULT_PORTNO);
1988                         return 0;
1989                 } else {
1990                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1991                         return -1;
1992                 }
1993         } else if (!p)
1994                 return -1;
1995         if (p->temponly)
1996                 free(p);
1997         return 0;
1998 }
1999
2000 static int auto_congest(void *nothing)
2001 {
2002         int callno = PTR_TO_CALLNO(nothing);
2003         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2004         ast_mutex_lock(&iaxsl[callno]);
2005         if (iaxs[callno]) {
2006                 iaxs[callno]->initid = -1;
2007                 iax2_queue_frame(callno, &f);
2008                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2009         }
2010         ast_mutex_unlock(&iaxsl[callno]);
2011         return 0;
2012 }
2013
2014 static unsigned int iax2_datetime(void)
2015 {
2016         time_t t;
2017         struct tm tm;
2018         unsigned int tmp;
2019         time(&t);
2020         localtime_r(&t, &tm);
2021         tmp  = (tm.tm_sec >> 1) & 0x1f;   /* 5 bits of seconds */
2022         tmp |= (tm.tm_min & 0x3f) << 5;   /* 6 bits of minutes */
2023         tmp |= (tm.tm_hour & 0x1f) << 11;   /* 5 bits of hours */
2024         tmp |= (tm.tm_mday & 0x1f) << 16; /* 5 bits of day of month */
2025         tmp |= ((tm.tm_mon + 1) & 0xf) << 21; /* 4 bits of month */
2026         tmp |= ((tm.tm_year - 100) & 0x7f) << 25; /* 7 bits of year */
2027         return tmp;
2028 }
2029
2030 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2031 {
2032         struct sockaddr_in sin;
2033         char host[256];
2034         char *rdest;
2035         char *rcontext;
2036         char *username;
2037         char *secret = NULL;
2038         char *hname;
2039         char cid[256] = "";
2040         char *l=NULL, *n=NULL;
2041         struct iax_ie_data ied;
2042         char myrdest [5] = "s";
2043         char context[AST_MAX_EXTENSION] ="";
2044         char *portno = NULL;
2045         char *opts = "";
2046         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2047         char *stringp=NULL;
2048         char storedsecret[80];
2049         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2050                 ast_log(LOG_WARNING, "Line is already in use (%s)?\n", c->name);
2051                 return -1;
2052         }
2053         strncpy(host, dest, sizeof(host)-1);
2054         stringp=host;
2055         strsep(&stringp, "/");
2056         /* If no destination extension specified, use 's' */
2057         rdest = strsep(&stringp, "/");
2058         if (!rdest)
2059                 rdest = myrdest;
2060         else {
2061                 /* Check for trailing options */
2062                 opts = strsep(&stringp, "/");
2063                 if (!opts)
2064                         opts = "";
2065         }
2066         stringp=rdest;
2067         strsep(&stringp, "@");
2068         rcontext = strsep(&stringp, "@");
2069         stringp=host;
2070         strsep(&stringp, "@");
2071         username = strsep(&stringp, "@");
2072         if (username) {
2073                 /* Really the second argument is the host, not the username */
2074                 hname = username;
2075                 username = host;
2076         } else {
2077                 hname = host;
2078         }
2079         if (username) {
2080                 stringp=username;
2081                 username = strsep(&stringp, ":");
2082                 secret = strsep(&stringp, ":");
2083         }
2084         stringp=hname;
2085         if (strsep(&stringp, ":")) {
2086                 stringp=hname;
2087                 strsep(&stringp, ":");
2088                 portno = strsep(&stringp, ":");
2089         }
2090         if (create_addr(&sin, NULL, NULL, NULL, hname, context, NULL, NULL, storedsecret, sizeof(storedsecret) - 1)) {
2091                 ast_log(LOG_WARNING, "No address associated with '%s'\n", hname);
2092                 return -1;
2093         }
2094         /* Keep track of the context for outgoing calls too */
2095         strncpy(c->context, context, sizeof(c->context) - 1);
2096         if (portno) {
2097                 sin.sin_port = htons(atoi(portno));
2098         }
2099         if (c->callerid) {
2100                 strncpy(cid, c->callerid, sizeof(cid) - 1);
2101                 ast_callerid_parse(cid, &n, &l);
2102                 if (l)
2103                         ast_shrink_phone_number(l);
2104         }
2105         /* Now build request */
2106         memset(&ied, 0, sizeof(ied));
2107         /* On new call, first IE MUST be IAX version of caller */
2108         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2109         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, rdest);
2110         if (strchr(opts, 'a')) {
2111                 /* Request auto answer */
2112                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
2113         }
2114         if (l)
2115                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
2116         if (n)
2117                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
2118         if (iaxs[callno]->sendani && c->ani) {
2119                 l = n = NULL;
2120                 strncpy(cid, c->ani, sizeof(cid) - 1);
2121                 ast_callerid_parse(cid, &n, &l);
2122                 if (l) {
2123                         ast_shrink_phone_number(l);
2124                         iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, l);
2125                 }
2126         }
2127         if (c->language && strlen(c->language))
2128                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
2129         if (c->dnid && strlen(c->dnid))
2130                 iax_ie_append_str(&ied, IAX_IE_DNID, c->dnid);
2131         if (rcontext)
2132                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, rcontext);
2133         if (username)
2134                 iax_ie_append_str(&ied, IAX_IE_USERNAME, username);
2135         if (!secret && strlen(storedsecret))
2136                 secret = storedsecret;
2137         ast_mutex_lock(&iaxsl[callno]);
2138         if (strlen(c->context))
2139                 strncpy(iaxs[callno]->context, c->context, sizeof(iaxs[callno]->context));
2140         if (secret) {
2141                 if (secret[0] == '[') {
2142                         /* This is an RSA key, not a normal secret */
2143                         strncpy(iaxs[callno]->outkey, secret + 1, sizeof(iaxs[callno]->secret)-1);
2144                         if (strlen(iaxs[callno]->outkey)) {
2145                                 iaxs[callno]->outkey[strlen(iaxs[callno]->outkey) - 1] = '\0';
2146                         }
2147                 } else
2148                         strncpy(iaxs[callno]->secret, secret, sizeof(iaxs[callno]->secret)-1);
2149         }
2150         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
2151         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
2152         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
2153         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime());
2154         /* Transmit the string in a "NEW" request */
2155 #if 0
2156         /* XXX We have no equivalent XXX */
2157         if (option_verbose > 2)
2158                 ast_verbose(VERBOSE_PREFIX_3 "Calling using options '%s'\n", requeststr);
2159 #endif
2160         if (iaxs[callno]->maxtime) {
2161                 /* Initialize pingtime and auto-congest time */
2162                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
2163                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
2164         }
2165         send_command(iaxs[callno], AST_FRAME_IAX,
2166                 IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
2167         ast_mutex_unlock(&iaxsl[callno]);
2168         ast_setstate(c, AST_STATE_RINGING);
2169         return 0;
2170 }
2171
2172 static int iax2_hangup(struct ast_channel *c)
2173 {
2174         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2175         int alreadygone;
2176         ast_mutex_lock(&iaxsl[callno]);
2177         if (callno && iaxs[callno]) {
2178                 ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
2179                 alreadygone = iaxs[callno]->alreadygone;
2180                 /* Send the hangup unless we have had a transmission error or are already gone */
2181                 if (!iaxs[callno]->error && !alreadygone)
2182                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, NULL, 0, -1);
2183                 /* Explicitly predestroy it */
2184                 iax2_predestroy_nolock(callno);
2185                 /* If we were already gone to begin with, destroy us now */
2186                 if (alreadygone) {
2187                         ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
2188                         iax2_destroy_nolock(callno);
2189                 }
2190         }
2191         ast_mutex_unlock(&iaxsl[callno]);
2192         if (option_verbose > 2)
2193                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
2194         return 0;
2195 }
2196
2197 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
2198 {
2199         struct ast_option_header *h;
2200         int res;
2201         h = malloc(datalen + sizeof(struct ast_option_header));
2202         if (h) {
2203                 h->flag = AST_OPTION_FLAG_REQUEST;
2204                 h->option = htons(option);
2205                 memcpy(h->data, data, datalen);
2206                 res = send_command_locked(PTR_TO_CALLNO(c->pvt->pvt), AST_FRAME_CONTROL,
2207                         AST_CONTROL_OPTION, 0, (char *)h, datalen + sizeof(struct ast_option_header), -1);
2208                 free(h);
2209                 return res;
2210         } else
2211                 ast_log(LOG_WARNING, "Out of memory\n");
2212         return -1;
2213 }
2214
2215 static struct ast_frame *iax2_read(struct ast_channel *c)
2216 {
2217         static struct ast_frame f = { AST_FRAME_NULL, };
2218         ast_log(LOG_NOTICE, "I should never be called!\n");
2219         return &f;
2220 }
2221
2222 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1)
2223 {
2224         int res;
2225         struct iax_ie_data ied0;
2226         struct iax_ie_data ied1;
2227         unsigned int transferid = rand();
2228         memset(&ied0, 0, sizeof(ied0));
2229         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
2230         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
2231         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
2232
2233         memset(&ied1, 0, sizeof(ied1));
2234         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
2235         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
2236         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
2237
2238         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
2239         if (res)
2240                 return -1;
2241         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
2242         if (res)
2243                 return -1;
2244         iaxs[callno0]->transferring = TRANSFER_BEGIN;
2245         iaxs[callno1]->transferring = TRANSFER_BEGIN;
2246         return 0;
2247 }
2248
2249 static void lock_both(unsigned short callno0, unsigned short callno1)
2250 {
2251         ast_mutex_lock(&iaxsl[callno0]);
2252         while (ast_mutex_trylock(&iaxsl[callno1])) {
2253                 ast_mutex_unlock(&iaxsl[callno0]);
2254                 usleep(10);
2255                 ast_mutex_lock(&iaxsl[callno0]);
2256         }
2257 }
2258
2259 static void unlock_both(unsigned short callno0, unsigned short callno1)
2260 {
2261         ast_mutex_unlock(&iaxsl[callno1]);
2262         ast_mutex_unlock(&iaxsl[callno0]);
2263 }
2264
2265 static int iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
2266 {
2267         struct ast_channel *cs[3];
2268         struct ast_channel *who;
2269         int to = -1;
2270         int res = -1;
2271         int transferstarted=0;
2272         struct ast_frame *f;
2273         unsigned short callno0 = PTR_TO_CALLNO(c0->pvt->pvt);
2274         unsigned short callno1 = PTR_TO_CALLNO(c1->pvt->pvt);
2275         struct timeval waittimer = {0, 0}, tv;
2276
2277         lock_both(callno0, callno1);
2278         /* Put them in native bridge mode */
2279         iaxs[callno0]->bridgecallno = callno1;
2280         iaxs[callno1]->bridgecallno = callno0;
2281         unlock_both(callno0, callno1);
2282
2283         /* If not, try to bridge until we can execute a transfer, if we can */
2284         cs[0] = c0;
2285         cs[1] = c1;
2286         for (/* ever */;;) {
2287                 /* Check in case we got masqueraded into */
2288                 if ((c0->type != type) || (c1->type != type)) {
2289                         if (option_verbose > 2)
2290                                 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
2291                         /* Remove from native mode */
2292                         if (c0->type == type) {
2293                                 ast_mutex_lock(&iaxsl[callno0]);
2294                                 iaxs[callno0]->bridgecallno = 0;
2295                                 ast_mutex_unlock(&iaxsl[callno0]);
2296                         }
2297                         if (c1->type == type) {
2298                                 ast_mutex_lock(&iaxsl[callno1]);
2299                                 iaxs[callno1]->bridgecallno = 0;
2300                                 ast_mutex_unlock(&iaxsl[callno1]);
2301                         }
2302                         return -2;
2303                 }
2304                 if (c0->nativeformats != c1->nativeformats) {
2305                         ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs, can't native bridge...\n");
2306                         /* Remove from native mode */
2307                         lock_both(callno0, callno1);
2308                         iaxs[callno0]->bridgecallno = 0;
2309                         iaxs[callno1]->bridgecallno = 0;
2310                         unlock_both(callno0, callno1);
2311                         return -2;
2312                 }
2313                 /* check if transfered and if we really want native bridging */
2314                 if (!transferstarted && !iaxs[callno0]->notransfer && !iaxs[callno1]->notransfer) {
2315                         /* Try the transfer */
2316                         if (iax2_start_transfer(callno0, callno1))
2317                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
2318                         transferstarted = 1;
2319                 }
2320                 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
2321                         /* Call has been transferred.  We're no longer involved */
2322                         gettimeofday(&tv, NULL);
2323                         if (!waittimer.tv_sec && !waittimer.tv_usec) {
2324                                 waittimer.tv_sec = tv.tv_sec;
2325                                 waittimer.tv_usec = tv.tv_usec;
2326                         } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
2327                                 c0->_softhangup |= AST_SOFTHANGUP_DEV;
2328                                 c1->_softhangup |= AST_SOFTHANGUP_DEV;
2329                                 *fo = NULL;
2330                                 *rc = c0;
2331                                 res = 0;
2332                                 break;
2333                         }
2334                 }
2335                 to = 1000;
2336                 who = ast_waitfor_n(cs, 2, &to);
2337                 if (!who) {
2338                         if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
2339                                 res = -1;
2340                                 break;
2341                         }
2342                         continue;
2343                 }
2344                 f = ast_read(who);
2345                 if (!f) {
2346                         *fo = NULL;
2347                         *rc = who;
2348                         res = 0;
2349                         break;
2350                 }
2351                 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2352                         *fo = f;
2353                         *rc = who;
2354                         res =  0;
2355                         break;
2356                 }
2357                 if ((f->frametype == AST_FRAME_VOICE) ||
2358                         (f->frametype == AST_FRAME_TEXT) ||
2359                         (f->frametype == AST_FRAME_VIDEO) ||
2360                         (f->frametype == AST_FRAME_IMAGE) ||
2361                         (f->frametype == AST_FRAME_DTMF)) {
2362                         if ((f->frametype == AST_FRAME_DTMF) &&
2363                                 (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
2364                                 if ((who == c0)) {
2365                                         if  ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
2366                                                 *rc = c0;
2367                                                 *fo = f;
2368                                                 /* Take out of conference mode */
2369                                                 res = 0;
2370                                                 /* Remove from native mode */
2371                                                 break;
2372                                         } else
2373                                                 goto tackygoto;
2374                                 } else
2375                                 if ((who == c1)) {
2376                                         if (flags & AST_BRIDGE_DTMF_CHANNEL_1) {
2377                                                 *rc = c1;
2378                                                 *fo = f;
2379                                                 res =  0;
2380                                                 /* Remove from native mode */
2381                                                 break;
2382                                         } else
2383                                                 goto tackygoto;
2384                                 }
2385                         } else {
2386 #if 0
2387                                 ast_log(LOG_DEBUG, "Read from %s\n", who->name);
2388                                 if (who == last)
2389                                         ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
2390                                 last = who;
2391 #endif
2392 tackygoto:
2393                                 if (who == c0)
2394                                         ast_write(c1, f);
2395                                 else
2396                                         ast_write(c0, f);
2397                         }
2398                         ast_frfree(f);
2399                 } else
2400                         ast_frfree(f);
2401                 /* Swap who gets priority */
2402                 cs[2] = cs[0];
2403                 cs[0] = cs[1];
2404                 cs[1] = cs[2];
2405         }
2406         lock_both(callno0, callno1);
2407         iaxs[callno0]->bridgecallno = 0;
2408         iaxs[callno1]->bridgecallno = 0;
2409         unlock_both(callno0, callno1);
2410         return res;
2411 }
2412
2413 static int iax2_answer(struct ast_channel *c)
2414 {
2415         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2416         if (option_debug)
2417                 ast_log(LOG_DEBUG, "Answering\n");
2418         return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
2419 }
2420
2421 static int iax2_indicate(struct ast_channel *c, int condition)
2422 {
2423         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2424         if (option_debug)
2425                 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
2426         return send_command_locked(callno, AST_FRAME_CONTROL, condition, 0, NULL, 0, -1);
2427 }
2428
2429 static int iax2_transfer(struct ast_channel *c, char *dest)
2430 {
2431         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
2432         struct iax_ie_data ied;
2433         char tmp[256] = "", *context;
2434         strncpy(tmp, dest, sizeof(tmp) - 1);
2435         context = strchr(tmp, '@');
2436         if (context) {
2437                 *context = '\0';
2438                 context++;
2439         }
2440         memset(&ied, 0, sizeof(ied));
2441         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
2442         if (context)
2443                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
2444         if (option_debug)
2445                 ast_log(LOG_DEBUG, "Transferring '%s' to '%s'\n", c->name, dest);
2446         return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
2447 }
2448
2449
2450 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
2451
2452 static int iax2_getpeertrunk(struct sockaddr_in sin)
2453 {
2454         struct iax2_peer *peer;
2455         int res = 0;
2456         ast_mutex_lock(&peerl.lock);
2457         peer = peerl.peers;
2458         while(peer) {
2459                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
2460                                 (peer->addr.sin_port == sin.sin_port)) {
2461                                         res = peer->trunk;
2462                                         break;
2463                 }
2464                 peer = peer->next;
2465         }
2466         ast_mutex_unlock(&peerl.lock);
2467         return res;
2468 }
2469
2470 static struct ast_channel *ast_iax2_new(struct chan_iax2_pvt *i, int state, int capability)
2471 {
2472         struct ast_channel *tmp;
2473         tmp = ast_channel_alloc(1);
2474         if (tmp) {
2475                 if (strlen(i->username))
2476                         snprintf(tmp->name, sizeof(tmp->name), "IAX2[%s@%s]/%d", i->username, i->host, i->callno);
2477                 else
2478                         snprintf(tmp->name, sizeof(tmp->name), "IAX2[%s]/%d", i->host, i->callno);
2479                 tmp->type = type;
2480                 /* We can support any format by default, until we get restricted */
2481                 tmp->nativeformats = capability;
2482                 tmp->readformat = 0;
2483                 tmp->writeformat = 0;
2484                 tmp->pvt->pvt = CALLNO_TO_PTR(i->callno);
2485                 tmp->pvt->send_digit = iax2_digit;
2486                 tmp->pvt->send_text = iax2_sendtext;
2487                 tmp->pvt->send_image = iax2_sendimage;
2488                 tmp->pvt->send_html = iax2_sendhtml;
2489                 tmp->pvt->call = iax2_call;
2490                 tmp->pvt->hangup = iax2_hangup;
2491                 tmp->pvt->answer = iax2_answer;
2492                 tmp->pvt->read = iax2_read;
2493                 tmp->pvt->write = iax2_write;
2494                 tmp->pvt->write_video = iax2_write;
2495                 tmp->pvt->indicate = iax2_indicate;
2496                 tmp->pvt->setoption = iax2_setoption;
2497                 tmp->pvt->bridge = iax2_bridge;
2498                 tmp->pvt->transfer = iax2_transfer;
2499                 if (strlen(i->callerid))
2500                         tmp->callerid = strdup(i->callerid);
2501                 if (strlen(i->ani))
2502                         tmp->ani = strdup(i->ani);
2503                 if (strlen(i->language))
2504                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2505                 if (strlen(i->dnid))
2506                         tmp->dnid = strdup(i->dnid);
2507                 if (strlen(i->accountcode))
2508                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2509                 if (i->amaflags)
2510                         tmp->amaflags = i->amaflags;
2511                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2512                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2513                 tmp->adsicpe = i->peeradsicpe;
2514                 tmp->pvt->fixup = iax2_fixup;
2515                 i->owner = tmp;
2516                 i->capability = capability;
2517                 ast_setstate(tmp, state);
2518                 ast_mutex_lock(&usecnt_lock);
2519                 usecnt++;
2520                 ast_mutex_unlock(&usecnt_lock);
2521                 ast_update_use_count();
2522                 if (state != AST_STATE_DOWN) {
2523                         if (ast_pbx_start(tmp)) {
2524                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2525                                 ast_hangup(tmp);
2526                                 tmp = NULL;
2527                         }
2528                 }
2529         }
2530         return tmp;
2531 }
2532
2533 static unsigned int calc_txpeerstamp(struct iax2_peer *peer)
2534 {
2535         struct timeval tv;
2536         unsigned int mssincetx;
2537         unsigned int ms;
2538         gettimeofday(&tv, NULL);
2539         mssincetx = (tv.tv_sec - peer->lasttxtime.tv_sec) * 1000 + (tv.tv_usec - peer->lasttxtime.tv_usec) / 1000;
2540         if (mssincetx > 5000) {
2541                 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
2542                 peer->txtrunktime.tv_sec = tv.tv_sec;
2543                 peer->txtrunktime.tv_usec = tv.tv_usec;
2544         }
2545         /* Update last transmit time now */
2546         peer->lasttxtime.tv_sec = tv.tv_sec;
2547         peer->lasttxtime.tv_usec = tv.tv_usec;
2548
2549         /* Calculate ms offset */
2550         ms = (tv.tv_sec - peer->txtrunktime.tv_sec) * 1000 + (tv.tv_usec - peer->txtrunktime.tv_usec) / 1000;
2551
2552         /* We never send the same timestamp twice, so fudge a little if we must */
2553         if (ms == peer->lastsent)
2554                 ms = peer->lastsent + 1;
2555         peer->lastsent = ms;
2556         return ms;
2557 }
2558
2559 static unsigned int fix_peerts(struct iax2_peer *peer, int callno, unsigned int ts)
2560 {
2561         long ms;        /* NOT unsigned */
2562         if (!iaxs[callno]->rxcore.tv_sec && !iaxs[callno]->rxcore.tv_usec) {
2563                 /* Initialize rxcore time if appropriate */
2564                 gettimeofday(&iaxs[callno]->rxcore, NULL);
2565                 /* Round to nearest 20ms */
2566                 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
2567         }
2568         /* Calculate difference between trunk and channel */
2569         ms = (peer->rxtrunktime.tv_sec - iaxs[callno]->rxcore.tv_sec) * 1000 +
2570                 (peer->rxtrunktime.tv_usec - iaxs[callno]->rxcore.tv_usec) / 1000;
2571         /* Return as the sum of trunk time and the difference between trunk and real time */
2572         return ms + ts;
2573 }
2574
2575 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct timeval *delivery)
2576 {
2577         struct timeval tv;
2578         unsigned int ms;
2579         if (!p->offset.tv_sec && !p->offset.tv_usec) {
2580                 gettimeofday(&p->offset, NULL);
2581                 /* Round to nearest 20ms */
2582                 p->offset.tv_usec -= p->offset.tv_usec % 20000;
2583         }
2584         /* If the timestamp is specified, just send it as is */
2585         if (ts)
2586                 return ts;
2587         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
2588                 ms = (delivery->tv_sec - p->offset.tv_sec) * 1000 + (delivery->tv_usec - p->offset.tv_usec) / 1000;
2589         } else {
2590                 gettimeofday(&tv, NULL);
2591                 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
2592         }
2593         /* We never send the same timestamp twice, so fudge a little if we must */
2594         if (ms <= p->lastsent) {
2595                 ms = p->lastsent + 1;
2596         }
2597         p->lastsent = ms;
2598         return ms;
2599 }
2600
2601 #ifdef BRIDGE_OPTIMIZATION
2602 static unsigned int calc_fakestamp(struct chan_iax2_pvt *p1, struct chan_iax2_pvt *p2, unsigned int fakets)
2603 {
2604         int ms;
2605         /* Receive from p1, send to p2 */
2606
2607         /* Setup rxcore if necessary on outgoing channel */
2608         if (!p1->rxcore.tv_sec && !p1->rxcore.tv_usec)
2609                 gettimeofday(&p1->rxcore, NULL);
2610
2611         /* Setup txcore if necessary on outgoing channel */
2612         if (!p2->offset.tv_sec && !p2->offset.tv_usec)
2613                 gettimeofday(&p2->offset, NULL);
2614
2615         /* Now, ts is the timestamp of the original packet in the orignal context.
2616            Adding rxcore to it gives us when we would want the packet to be delivered normally.
2617            Subtracting txcore of the outgoing channel gives us what we'd expect */
2618
2619         ms = (p1->rxcore.tv_sec - p2->offset.tv_sec) * 1000 + (p1->rxcore.tv_usec - p2->offset.tv_usec) / 1000;
2620         fakets += ms;
2621         if (fakets <= p2->lastsent)
2622                 fakets = p2->lastsent + 1;
2623         p2->lastsent = fakets;
2624         return fakets;
2625 }
2626 #endif
2627
2628 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p)
2629 {
2630         /* Returns where in "receive time" we are */
2631         struct timeval tv;
2632         unsigned int ms;
2633         /* Setup rxcore if necessary */
2634         if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
2635                 gettimeofday(&p->rxcore, NULL);
2636
2637         gettimeofday(&tv, NULL);
2638         ms = (tv.tv_sec - p->rxcore.tv_sec) * 1000 + (tv.tv_usec - p->rxcore.tv_usec) / 1000;
2639         return ms;
2640 }
2641
2642 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
2643 {
2644         /* Queue a packet for delivery on a given private structure.  Use "ts" for
2645            timestamp, or calculate if ts is 0.  Send immediately without retransmission
2646            or delayed, with retransmission */
2647         struct ast_iax2_full_hdr *fh;
2648         struct ast_iax2_mini_hdr *mh;
2649         struct ast_iax2_video_hdr *vh;
2650         struct {
2651                 struct iax_frame fr2;
2652                 unsigned char buffer[4096];
2653         } frb;
2654         struct iax_frame *fr;
2655         int res;
2656         int sendmini=0;
2657         unsigned int lastsent;
2658         unsigned int fts;
2659
2660         if (!pvt) {
2661                 ast_log(LOG_WARNING, "No private structure for packet?\n");
2662                 return -1;
2663         }
2664
2665         lastsent = pvt->lastsent;
2666
2667         /* Calculate actual timestamp */
2668         fts = calc_timestamp(pvt, ts, (f->frametype == AST_FRAME_VOICE) ? &f->delivery : NULL);
2669
2670         if ((pvt->trunk || ((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)))
2671                 /* High two bits are the same on timestamp, or sending on a trunk */ &&
2672             (f->frametype == AST_FRAME_VOICE)
2673                 /* is a voice frame */ &&
2674                 (f->subclass == pvt->svoiceformat)
2675                 /* is the same type */ ) {
2676                         /* Force immediate rather than delayed transmission */
2677                         now = 1;
2678                         /* Mark that mini-style frame is appropriate */
2679                         sendmini = 1;
2680         }
2681         if (((fts & 0xFFFF8000L) == (lastsent & 0xFFFF8000L)) &&
2682                 (f->frametype == AST_FRAME_VIDEO) &&
2683                 ((f->subclass & ~0x1) == pvt->svideoformat)) {
2684                         now = 1;
2685                         sendmini = 1;
2686         }
2687         /* Allocate an iax_frame */
2688         if (now) {
2689                 fr = &frb.fr2;
2690         } else
2691                 fr = iax_frame_new(DIRECTION_OUTGRESS, f->datalen);
2692         if (!fr) {
2693                 ast_log(LOG_WARNING, "Out of memory\n");
2694                 return -1;
2695         }
2696         /* Copy our prospective frame into our immediate or retransmitted wrapper */
2697         iax_frame_wrap(fr, f);
2698
2699         fr->ts = fts;
2700         if (!fr->ts) {
2701                 ast_log(LOG_WARNING, "timestamp is 0?\n");
2702                 if (!now)
2703                         iax2_frame_free(fr);
2704                 return -1;
2705         }
2706         fr->callno = pvt->callno;
2707         fr->transfer = transfer;
2708         fr->final = final;
2709         if (!sendmini) {
2710                 /* We need a full frame */
2711                 if (seqno > -1)
2712                         fr->oseqno = seqno;
2713                 else
2714                         fr->oseqno = pvt->oseqno++;
2715                 fr->iseqno = pvt->iseqno;
2716                 fh = (struct ast_iax2_full_hdr *)(fr->af.data - sizeof(struct ast_iax2_full_hdr));
2717                 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
2718                 fh->ts = htonl(fr->ts);
2719                 fh->oseqno = fr->oseqno;
2720                 if (transfer) {
2721                         fh->iseqno = 0;
2722                 } else
2723                         fh->iseqno = fr->iseqno;
2724                 /* Keep track of the last thing we've acknowledged */
2725                 if (!transfer)
2726                         pvt->aseqno = fr->iseqno;
2727                 fh->type = fr->af.frametype & 0xFF;
2728                 if (fr->af.frametype == AST_FRAME_VIDEO)
2729                         fh->csub = compress_subclass(fr->af.subclass & ~0x1) | ((fr->af.subclass & 0x1) << 6);
2730                 else
2731                         fh->csub = compress_subclass(fr->af.subclass);
2732                 if (transfer) {
2733                         fr->dcallno = pvt->transfercallno;
2734                 } else
2735                         fr->dcallno = pvt->peercallno;
2736                 fh->dcallno = htons(fr->dcallno);
2737                 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
2738                 fr->data = fh;
2739                 fr->retries = 0;
2740                 /* Retry after 2x the ping time has passed */
2741                 fr->retrytime = pvt->pingtime * 2;
2742                 if (fr->retrytime < MIN_RETRY_TIME)
2743                         fr->retrytime = MIN_RETRY_TIME;
2744                 if (fr->retrytime > MAX_RETRY_TIME)
2745                         fr->retrytime = MAX_RETRY_TIME;
2746                 /* Acks' don't get retried */
2747                 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == IAX_COMMAND_ACK))
2748                         fr->retries = -1;
2749                 if (f->frametype == AST_FRAME_VOICE) {
2750                         pvt->svoiceformat = f->subclass;
2751                 }
2752                 if (f->frametype == AST_FRAME_VIDEO) {
2753                         pvt->svideoformat = f->subclass & ~0x1;
2754                 }
2755                 if (now) {
2756                         res = send_packet(fr);
2757                 } else
2758                         res = iax2_transmit(fr);
2759         } else {
2760                 if (pvt->trunk) {
2761                         /* Queue for transmission in a meta frame */
2762                         if ((sizeof(pvt->trunkdata) - pvt->trunkdatalen) >= fr->af.datalen) {
2763                                 memcpy(pvt->trunkdata + pvt->trunkdatalen, fr->af.data, fr->af.datalen);
2764                                 pvt->trunkdatalen += fr->af.datalen;
2765                                 res = 0;
2766                                 pvt->trunkerror = 0;
2767                         } else {
2768                                 if (!pvt->trunkerror)
2769                                         ast_log(LOG_WARNING, "Out of trunk data space on call number %d, dropping\n", pvt->callno);
2770                                 pvt->trunkerror = 1;
2771                         }
2772                         res = 0;
2773                 } else if (fr->af.frametype == AST_FRAME_VIDEO) {
2774                         /* Video frame have no sequence number */
2775                         fr->oseqno = -1;
2776                         fr->iseqno = -1;
2777                         vh = (struct ast_iax2_video_hdr *)(fr->af.data - sizeof(struct ast_iax2_video_hdr));
2778                         vh->zeros = 0;
2779                         vh->callno = htons(0x8000 | fr->callno);
2780                         vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass & 0x1 ? 0x8000 : 0));
2781                         fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
2782                         fr->data = vh;
2783                         fr->retries = -1;
2784                         res = send_packet(fr);
2785                 } else {
2786                         /* Mini-frames have no sequence number */
2787                         fr->oseqno = -1;
2788                         fr->iseqno = -1;
2789                         /* Mini frame will do */
2790                         mh = (struct ast_iax2_mini_hdr *)(fr->af.data - sizeof(struct ast_iax2_mini_hdr));
2791                         mh->callno = htons(fr->callno);
2792                         mh->ts = htons(fr->ts & 0xFFFF);
2793                         fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
2794                         fr->data = mh;
2795                         fr->retries = -1;
2796                         res = send_packet(fr);
2797                 }
2798         }
2799         return res;
2800 }
2801
2802
2803
2804 static int iax2_show_users(int fd, int argc, char *argv[])
2805 {
2806 #define FORMAT "%-15.15s  %-15.15s  %-15.15s  %-15.15s  %-5.5s\n"
2807 #define FORMAT2 "%-15.15s  %-15.15s  %-15.15d  %-15.15s  %-5.5s\n"
2808         struct iax2_user *user;
2809         if (argc != 3)
2810                 return RESULT_SHOWUSAGE;
2811         ast_mutex_lock(&userl.lock);
2812         ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
2813         for(user=userl.users;user;user=user->next) {
2814                 ast_cli(fd, FORMAT2, user->name, user->secret, user->authmethods,
2815                                 user->contexts ? user->contexts->context : context,
2816                                 user->ha ? "Yes" : "No");
2817         }
2818         ast_mutex_unlock(&userl.lock);
2819         return RESULT_SUCCESS;
2820 #undef FORMAT
2821 #undef FORMAT2
2822 }
2823
2824 static int iax2_show_peers(int fd, int argc, char *argv[])
2825 {
2826 #define FORMAT2 "%-15.15s  %-15.15s %s  %-15.15s  %-8s  %-10s\n"
2827 #define FORMAT "%-15.15s  %-15.15s %s  %-15.15s  %-5d%s  %-10s\n"
2828         struct iax2_peer *peer;
2829         char name[256] = "";
2830         int registeredonly=0;
2831         if ((argc != 3) && (argc != 4))
2832                 return RESULT_SHOWUSAGE;
2833         if ((argc == 4)) {
2834                 if (!strcasecmp(argv[3], "registered")) {
2835                         registeredonly = 1;
2836                 } else
2837                         return RESULT_SHOWUSAGE;
2838         }
2839         ast_mutex_lock(&peerl.lock);
2840         ast_cli(fd, FORMAT2, "Name/Username", "Host", "   ", "Mask", "Port", "Status");
2841         for (peer = peerl.peers;peer;peer = peer->next) {
2842                 char nm[20];
2843                 char status[20];
2844                 if (registeredonly && !peer->addr.sin_addr.s_addr)
2845                         continue;
2846                 if (strlen(peer->username))
2847                         snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
2848                 else
2849                         strncpy(name, peer->name, sizeof(name) - 1);
2850                 if (peer->maxms) {
2851                         if (peer->lastms < 0)
2852                                 strcpy(status, "UNREACHABLE");
2853                         else if (peer->lastms > peer->maxms)
2854                                 snprintf(status, sizeof(status), "LAGGED (%d ms)", peer->lastms);
2855                         else if (peer->lastms)
2856                                 snprintf(status, sizeof(status), "OK (%d ms)", peer->lastms);
2857                         else
2858                                 strcpy(status, "UNKNOWN");
2859                 } else
2860                         strcpy(status, "Unmonitored");
2861                 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm)-1);
2862                 ast_cli(fd, FORMAT, name,
2863                                         peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Unspecified)",
2864                                         peer->dynamic ? "(D)" : "(S)",
2865                                         nm,
2866                                         ntohs(peer->addr.sin_port), peer->trunk ? "(T)" : "   ", status);
2867         }
2868         ast_mutex_unlock(&peerl.lock);
2869         return RESULT_SUCCESS;
2870 #undef FORMAT
2871 #undef FORMAT2
2872 }
2873
2874 static int iax2_show_firmware(int fd, int argc, char *argv[])
2875 {
2876 #define FORMAT2 "%-15.15s  %-15.15s %-15.15s\n"
2877 #define FORMAT "%-15.15s  %-15d %-15d\n"
2878         struct iax_firmware *cur;
2879         if ((argc != 3) && (argc != 4))
2880                 return RESULT_SHOWUSAGE;
2881         ast_mutex_lock(&waresl.lock);
2882
2883         ast_cli(fd, FORMAT2, "Device", "Version", "Size");
2884         for (cur = waresl.wares;cur;cur = cur->next) {
2885                 if ((argc == 3) || (!strcasecmp(argv[3], cur->fwh->devname)))
2886                         ast_cli(fd, FORMAT, cur->fwh->devname, ntohs(cur->fwh->version),
2887                                                 ntohl(cur->fwh->datalen));
2888         }
2889         ast_mutex_unlock(&waresl.lock);
2890         return RESULT_SUCCESS;
2891 #undef FORMAT
2892 #undef FORMAT2
2893 }
2894
2895 /* JDG: callback to display iax peers in manager */
2896 static int manager_iax2_show_peers( struct mansession *s, struct message *m )
2897 {
2898         char *a[] = { "iax2", "show", "users" };
2899         int ret;
2900         ret = iax2_show_peers( s->fd, 3, a );
2901         ast_cli( s->fd, "\r\n" );
2902         return ret;
2903 } /* /JDG */
2904
2905 static char *regstate2str(int regstate)
2906 {
2907         switch(regstate) {
2908         case REG_STATE_UNREGISTERED:
2909                 return "Unregistered";
2910         case REG_STATE_REGSENT:
2911                 return "Request Sent";
2912         case REG_STATE_AUTHSENT:
2913                 return "Auth. Sent";
2914         case REG_STATE_REGISTERED:
2915                 return "Registered";
2916         case REG_STATE_REJECTED:
2917                 return "Rejected";
2918         case REG_STATE_TIMEOUT:
2919                 return "Timeout";
2920         case REG_STATE_NOAUTH:
2921                 return "No Authentication";
2922         default:
2923                 return "Unknown";
2924         }
2925 }
2926
2927 static int iax2_show_registry(int fd, int argc, char *argv[])
2928 {
2929 #define FORMAT2 "%-20.20s  %-10.10s  %-20.20s %8.8s  %s\n"
2930 #define FORMAT "%-20.20s  %-10.10s  %-20.20s %8d  %s\n"
2931         struct iax2_registry *reg;
2932         char host[80];
2933         char perceived[80];
2934         if (argc != 3)
2935                 return RESULT_SHOWUSAGE;
2936         ast_mutex_lock(&peerl.lock);
2937         ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State");
2938         for (reg = registrations;reg;reg = reg->next) {
2939                 snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port));
2940                 if (reg->us.sin_addr.s_addr)
2941                         snprintf(perceived, sizeof(perceived), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
2942                 else
2943                         strcpy(perceived, "<Unregistered>");
2944                 ast_cli(fd, FORMAT, host,
2945                                         reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
2946         }
2947         ast_mutex_unlock(&peerl.lock);
2948         return RESULT_SUCCESS;
2949 #undef FORMAT
2950 #undef FORMAT2
2951 }
2952
2953 static int iax2_show_channels(int fd, int argc, char *argv[])
2954 {
2955 #define FORMAT2 "%-15.15s  %-10.10s  %-11.11s  %-11.11s  %-7.7s  %-6.6s  %s\n"
2956 #define FORMAT  "%-15.15s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  %-5.5dms  %-4.4dms  %-6.6s\n"
2957         int x;
2958         int numchans = 0;
2959         if (argc != 3)
2960                 return RESULT_SHOWUSAGE;
2961         ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
2962         for (x=0;x<IAX_MAX_CALLS;x++) {
2963                 ast_mutex_lock(&iaxsl[x]);
2964                 if (iaxs[x]) {
2965                         ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
2966                                                 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
2967                                                 iaxs[x]->callno, iaxs[x]->peercallno,
2968                                                 iaxs[x]->oseqno, iaxs[x]->iseqno,
2969                                                 iaxs[x]->lag,
2970                                                 iaxs[x]->jitter,
2971                                                 ast_getformatname(iaxs[x]->voiceformat) );
2972                         numchans++;
2973                 }
2974                 ast_mutex_unlock(&iaxsl[x]);
2975         }
2976         ast_cli(fd, "%d active IAX channel(s)\n", numchans);
2977         return RESULT_SUCCESS;
2978 #undef FORMAT
2979 #undef FORMAT2
2980 }
2981
2982 static int iax2_do_trunk_debug(int fd, int argc, char *argv[])
2983 {
2984         if (argc != 3)
2985                 return RESULT_SHOWUSAGE;
2986         iaxtrunkdebug = 1;
2987         ast_cli(fd, "IAX2 Trunk Debug Requested\n");
2988         return RESULT_SUCCESS;
2989 }
2990
2991 static int iax2_do_debug(int fd, int argc, char *argv[])
2992 {
2993         if (argc != 2)
2994                 return RESULT_SHOWUSAGE;
2995         iaxdebug = 1;
2996         ast_cli(fd, "IAX2 Debugging Enabled\n");
2997         return RESULT_SUCCESS;
2998 }
2999
3000 static int iax2_no_debug(int fd, int argc, char *argv[])
3001 {
3002         if (argc != 3)
3003                 return RESULT_SHOWUSAGE;
3004         iaxdebug = 0;
3005         ast_cli(fd, "IAX2 Debugging Disabled\n");
3006         return RESULT_SUCCESS;
3007 }
3008
3009
3010
3011 static char show_users_usage[] =
3012 "Usage: iax2 show users\n"
3013 "       Lists all users known to the IAX (Inter-Asterisk eXchange rev 2) subsystem.\n";
3014
3015 static char show_channels_usage[] =
3016 "Usage: iax2 show channels\n"
3017 "       Lists all currently active IAX channels.\n";
3018
3019 static char show_peers_usage[] =
3020 "Usage: iax2 show peers\n"
3021 "       Lists all known IAX peers.\n";
3022
3023 static char show_firmware_usage[] =
3024 "Usage: iax2 show firmware\n"
3025 "       Lists all known IAX firmware images.\n";
3026
3027 static char show_reg_usage[] =
3028 "Usage: iax2 show registry\n"
3029 "       Lists all registration requests and status.\n";
3030
3031 static char debug_usage[] =
3032 "Usage: iax2 debug\n"
3033 "       Enables dumping of IAX packets for debugging purposes\n";
3034
3035 static char no_debug_usage[] =
3036 "Usage: iax2 no debug\n"
3037 "       Disables dumping of IAX packets for debugging purposes\n";
3038
3039 static char debug_trunk_usage[] =
3040 "Usage: iax2 trunk debug\n"
3041 "       Requests current status of IAX trunking\n";
3042
3043 static struct ast_cli_entry  cli_show_users =
3044         { { "iax2", "show", "users", NULL }, iax2_show_users, "Show defined IAX users", show_users_usage };
3045 static struct ast_cli_entry  cli_show_firmware =
3046         { { "iax2", "show", "firmware", NULL }, iax2_show_firmware, "Show available IAX firmwares", show_firmware_usage };
3047 static struct ast_cli_entry  cli_show_channels =
3048         { { "iax2", "show", "channels", NULL }, iax2_show_channels, "Show active IAX channels", show_channels_usage };
3049 static struct ast_cli_entry  cli_show_peers =
3050         { { "iax2", "show", "peers", NULL }, iax2_show_peers, "Show defined IAX peers", show_peers_usage };
3051 static struct ast_cli_entry  cli_show_registry =
3052         { { "iax2", "show", "registry", NULL }, iax2_show_registry, "Show IAX registration status", show_reg_usage };
3053 static struct ast_cli_entry  cli_debug =
3054         { { "iax2", "debug", NULL }, iax2_do_debug, "Enable IAX debugging", debug_usage };
3055 static struct ast_cli_entry  cli_trunk_debug =
3056         { { "iax2", "trunk", "debug", NULL }, iax2_do_trunk_debug, "Request IAX trunk debug", debug_trunk_usage };
3057 static struct ast_cli_entry  cli_no_debug =
3058         { { "iax2", "no", "debug", NULL }, iax2_no_debug, "Disable IAX debugging", no_debug_usage };
3059
3060 static int iax2_write(struct ast_channel *c, struct ast_frame *f)
3061 {
3062         unsigned short callno = PTR_TO_CALLNO(c->pvt->pvt);
3063         int res = -1;
3064         ast_mutex_lock(&iaxsl[callno]);
3065         if (iaxs[callno]) {
3066         /* If there's an outstanding error, return failure now */
3067                 if (!iaxs[callno]->error) {
3068                         if (iaxs[callno]->alreadygone)
3069                                 res = 0;
3070                                 /* Don't waste bandwidth sending null frames */
3071                         else if (f->frametype == AST_FRAME_NULL)
3072                                 res = 0;
3073                         else if ((f->frametype == AST_FRAME_VOICE) && iaxs[callno]->quelch)
3074                                 res = 0;
3075                         else if (!(iaxs[callno]->state & IAX_STATE_STARTED))
3076                                 res = 0;
3077                         else
3078                         /* Simple, just queue for transmission */
3079                                 res = iax2_send(iaxs[callno], f, 0, -1, 0, 0, 0);
3080                 } else {
3081                         ast_log(LOG_DEBUG, "Write error: %s\n", strerror(errno));
3082                 }
3083         }
3084         /* If it's already gone, just return */
3085         ast_mutex_unlock(&iaxsl[callno]);
3086         return res;
3087 }
3088
3089 static int __send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno,
3090                 int now, int transfer, int final)
3091 {
3092         struct ast_frame f;
3093         f.frametype = type;
3094         f.subclass = command;
3095         f.datalen = datalen;
3096         f.samples = 0;
3097         f.mallocd = 0;
3098         f.offset = 0;
3099         f.src = __FUNCTION__;
3100         f.data = data;
3101         return iax2_send(i, &f, ts, seqno, now, transfer, final);
3102 }
3103
3104 static int send_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
3105 {
3106         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
3107 }
3108
3109 static int send_command_locked(unsigned short callno, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
3110 {
3111         int res;
3112         ast_mutex_lock(&iaxsl[callno]);
3113         res = send_command(iaxs[callno], type, command, ts, data, datalen, seqno);
3114         ast_mutex_unlock(&iaxsl[callno]);
3115         return res;
3116 }
3117
3118 #ifdef BRIDGE_OPTIMIZATION
3119 static int forward_command(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
3120 {
3121         return __send_command(iaxs[i->bridgecallno], type, command, ts, data, datalen, seqno, 0, 0, 0);
3122 }
3123 #endif
3124
3125 static int send_command_final(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
3126 {
3127         /* It is assumed that the callno has already been locked */
3128         iax2_predestroy_nolock(i->callno);
3129         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
3130 }
3131
3132 static int send_command_immediate(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
3133 {
3134         return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
3135 }
3136
3137 static int send_command_transfer(struct chan_iax2_pvt *i, char type, int command, unsigned int ts, char *data, int datalen)
3138 {
3139         return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
3140 }
3141
3142 static int apply_context(struct iax2_context *con, char *context)
3143 {
3144         while(con) {
3145                 if (!strcmp(con->context, context))
3146                         return -1;
3147                 con = con->next;
3148         }
3149         return 0;
3150 }
3151
3152
3153 static int check_access(int callno, struct sockaddr_in *sin, struct iax_ies *ies)
3154 {
3155         /* Start pessimistic */
3156         int res = -1;
3157         int version = 2;
3158         struct iax2_user *user;
3159         int gotcapability=0;
3160         if (!iaxs[callno])
3161                 return res;
3162         if (ies->called_number)
3163                 strncpy(iaxs[callno]->exten, ies->called_number, sizeof(iaxs[callno]->exten) - 1);
3164         if (ies->calling_number) {
3165                 if (ies->calling_name)
3166                         snprintf(iaxs[callno]->callerid, sizeof(iaxs[callno]->callerid), "\"%s\" <%s>", ies->calling_name, ies->calling_number);
3167                 else
3168                         strncpy(iaxs[callno]->callerid, ies->calling_number, sizeof(iaxs[callno]->callerid) - 1);
3169         } else if (ies->calling_name)
3170                 strncpy(iaxs[callno]->callerid, ies->calling_name, sizeof(iaxs[callno]->callerid) - 1);
3171         if (ies->calling_ani)
3172                 strncpy(iaxs[callno]->ani, ies->calling_ani, sizeof(iaxs[callno]->ani) - 1);
3173         if (ies->dnid)
3174                 strncpy(iaxs[callno]->dnid, ies->dnid, sizeof(iaxs[callno]->dnid)-1);
3175         if (ies->called_context)
3176                 strncpy(iaxs[callno]->context, ies->called_context, sizeof(iaxs[callno]->context)-1);
3177         if (ies->language)
3178                 strncpy(iaxs[callno]->language, ies->language, sizeof(iaxs[callno]->language)-1);
3179         if (ies->username)
3180                 strncpy(iaxs[callno]->username, ies->username, sizeof(iaxs[callno]->username)-1);
3181         if (ies->format)
3182                 iaxs[callno]->peerformat = ies->format;
3183         if (ies->adsicpe)
3184                 iaxs[callno]->peeradsicpe = ies->adsicpe;
3185         if (ies->capability) {
3186                 gotcapability = 1;
3187                 iaxs[callno]->peercapability = ies->capability;
3188         }
3189         if (ies->version)
3190                 version = ies->version;
3191         if (!gotcapability)
3192                 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
3193         if (version > IAX_PROTO_VERSION) {
3194                 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
3195                         inet_ntoa(sin->sin_addr), version);
3196                 return res;
3197         }
3198         ast_mutex_lock(&userl.lock);
3199         /* Search the userlist for a compatible entry, and fill in the rest */
3200         user = userl.users;
3201         while(user) {
3202                 if ((!strlen(iaxs[callno]->username) ||                         /* No username specified */
3203                         !strcmp(iaxs[callno]->username, user->name))    /* Or this username specified */
3204                         && ast_apply_ha(user->ha, sin)  /* Access is permitted from this IP */
3205                         && (!strlen(iaxs[callno]->context) ||                   /* No context specified */
3206                              apply_context(user->contexts, iaxs[callno]->context))) {                   /* Context is permitted */
3207                         break;
3208                 }
3209                 user = user->next;
3210         }
3211         ast_mutex_unlock(&userl.lock);
3212 #ifdef MYSQL_FRIENDS
3213         if (!user && mysql && strlen(iaxs[callno]->username) && (strlen(iaxs[callno]->username) < 128)) {
3214                 user = mysql_user(iaxs[callno]->username);
3215                 if (user && strlen(iaxs[callno]->context) &&                    /* No context specified */
3216                              !apply_context(user->contexts, iaxs[callno]->context)) {                   /* Context is permitted */
3217                         if (user->contexts)
3218                                 free(user->contexts);
3219                         free(user);
3220                         user = NULL;
3221                 }
3222         }
3223 #endif
3224         if (user) {
3225                 /* We found our match (use the first) */
3226
3227                 /* Store the requested username if not specified */
3228                 if (!strlen(iaxs[callno]->username))
3229                         strncpy(iaxs[callno]->username, user->name, sizeof(iaxs[callno]->username)-1);
3230                 /* Store whether this is a trunked call, too, of course, and move if appropriate */
3231                 iaxs[callno]->trunk = user->trunk;
3232                 iaxs[callno]->capability = user->capability;
3233                 /* And use the default context */
3234                 if (!strlen(iaxs[callno]->context)) {
3235                         if (user->contexts)
3236                                 strncpy(iaxs[callno]->context, user->contexts->context, sizeof(iaxs[callno]->context)-1);
3237                         else
3238                                 strncpy(iaxs[callno]->context, context, sizeof(iaxs[callno]->context)-1);
3239                 }
3240                 /* Copy the secret */
3241                 strncpy(iaxs[callno]->secret, user->secret, sizeof(iaxs[callno]->secret)-1);
3242                 /* And any input keys */
3243                 strncpy(iaxs[callno]->inkeys, user->inkeys, sizeof(iaxs[callno]->inkeys));
3244                 /* And the permitted authentication methods */
3245                 iaxs[callno]->authmethods = user->authmethods;
3246                 /* If they have callerid, override the given caller id.  Always store the ANI */
3247                 if (strlen(iaxs[callno]->callerid)) {
3248                         if (user->hascallerid)
3249                                 strncpy(iaxs[callno]->callerid, user->callerid, sizeof(iaxs[callno]->callerid)-1);
3250                         strncpy(iaxs[callno]->ani, user->callerid, sizeof(iaxs[callno]->ani)-1);
3251                 }
3252                 if (strlen(user->accountcode))
3253                         strncpy(iaxs[callno]->accountcode, user->accountcode, sizeof(iaxs[callno]->accountcode)-1);
3254                 if (user->amaflags)
3255                         iaxs[callno]->amaflags = user->amaflags;
3256                 iaxs[callno]->notransfer = user->notransfer;
3257                 res = 0;
3258         }
3259         iaxs[callno]->trunk = iax2_getpeertrunk(*sin);
3260         return res;
3261 }
3262
3263 static int raw_hangup(struct sockaddr_in *sin, unsigned short src, unsigned short dst)
3264 {
3265         struct ast_iax2_full_hdr fh;
3266         fh.scallno = htons(src | IAX_FLAG_FULL);
3267         fh.dcallno = htons(dst);
3268         fh.ts = 0;
3269         fh.oseqno = 0;
3270         fh.iseqno = 0;
3271         fh.type = AST_FRAME_IAX;
3272         fh.csub = compress_subclass(IAX_COMMAND_INVAL);
3273 #if 0
3274         if (option_debug)
3275 #endif
3276                 ast_log(LOG_DEBUG, "Raw Hangup %s:%d, src=%d, dst=%d\n",
3277                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), src, dst);
3278         return sendto(netsocket, &fh, sizeof(fh), 0, (struct sockaddr *)sin, sizeof(*sin));
3279 }
3280
3281 static int authenticate_request(struct chan_iax2_pvt *p)
3282 {
3283         struct iax_ie_data ied;
3284         memset(&ied, 0, sizeof(ied));
3285         iax_ie_append_short(&ied, IAX_IE_AUTHMETHODS, p->authmethods);
3286         if (p->authmethods & (IAX_AUTH_MD5 | IAX_AUTH_RSA)) {
3287                 snprintf(p->challenge, sizeof(p->challenge), "%d", rand());
3288                 iax_ie_append_str(&ied, IAX_IE_CHALLENGE, p->challenge);
3289         }
3290         iax_ie_append_str(&ied,IAX_IE_USERNAME, p->username);
3291         return send_command(p, AST_FRAME_IAX, IAX_COMMAND_AUTHREQ, 0, ied.buf, ied.pos, -1);
3292 }
3293
3294 static int authenticate_verify(struct chan_iax2_pvt *p, struct iax_ies *ies)
3295 {
3296         char requeststr[256] = "";
3297         char md5secret[256] = "";
3298         char secret[256] = "";
3299         char rsasecret[256] = "";
3300         int res = -1;
3301         int x;
3302
3303         if (!(p->state & IAX_STATE_AUTHENTICATED))
3304                 return res;
3305         if (ies->password)
3306                 strncpy(secret, ies->password, sizeof(secret) - 1);
3307         if (ies->md5_result)
3308                 strncpy(md5secret, ies->md5_result, sizeof(md5secret)-1);
3309         if (ies->rsa_result)
3310                 strncpy(rsasecret, ies->rsa_result, sizeof(rsasecret)-1);
3311         if ((p->authmethods & IAX_AUTH_RSA) && strlen(rsasecret) && strlen(p->inkeys)) {
3312                 struct ast_key *key;
3313                 char *keyn;
3314                 char tmpkey[256];
3315                 char *stringp=NULL;
3316                 strncpy(tmpkey, p->inkeys, sizeof(tmpkey));
3317                 stringp=tmpkey;
3318                 keyn = strsep(&stringp, ":");
3319                 while(keyn) {
3320                         key = ast_key_get(keyn, AST_KEY_PUBLIC);
3321                         if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
3322                                 res = 0;
3323                                 break;
3324                         } else if (!key)
3325                                 ast_log(LOG_WARNING, "requested inkey '%s' for RSA authentication does not exist\n", keyn);
3326                         keyn = strsep(&stringp, ":");
3327                 }
3328         } else if (p->authmethods & IAX_AUTH_MD5) {
3329                 struct MD5Context md5;
3330                 unsigned char digest[16];
3331                 MD5Init(&md5);
3332                 MD5Update(&md5, p->challenge, strlen(p->challenge));
3333                 MD5Update(&md5, p->secret, strlen(p->secret));
3334                 MD5Final(digest, &md5);
3335                 /* If they support md5, authenticate with it.  */
3336                 for (x=0;x<16;x++)
3337                         sprintf(requeststr + (x << 1), "%2.2x", digest[x]);
3338                 if (!strcasecmp(requeststr, md5secret))
3339                         res = 0;
3340         } else if (p->authmethods & IAX_AUTH_PLAINTEXT) {
3341                 if (!strcmp(secret, p->secret))
3342                         res = 0;
3343         }
3344         return res;
3345 }
3346
3347 static int register_verify(int callno, struct sockaddr_in *sin, struct iax_ies *ies)
3348 {
3349         char requeststr[256] = "";
3350         char peer[256] = "";
3351         char md5secret[256] = "";
3352         char rsasecret[256] = "";
3353         char secret[256] = "";
3354         struct iax2_peer *p;
3355         struct ast_key *key;
3356         char *keyn;
3357         int x;
3358         int expire = 0;
3359
3360         iaxs[callno]->state &= ~IAX_STATE_AUTHENTICATED;
3361         strcpy(iaxs[callno]->peer, "");
3362         if (ies->username)
3363                 strncpy(peer, ies->username, sizeof(peer) - 1);
3364         if (ies->password)
3365                 strncpy(secret, ies->password, sizeof(secret) - 1);
3366         if (ies->md5_result)
3367                 strncpy(md5secret, ies->md5_result, sizeof(md5secret)-1);
3368         if (ies->rsa_result)
3369                 strncpy(rsasecret, ies->rsa_result, sizeof(rsasecret)-1);
3370         if (ies->refresh)
3371                 expire = ies->refresh;
3372
3373         if (!strlen(peer)) {
3374                 ast_log(LOG_NOTICE, "Empty registration from %s\n", inet_ntoa(sin->sin_addr));
3375                 return -1;
3376         }
3377
3378         ast_mutex_lock(&peerl.lock);
3379         for (p = peerl.peers; p ; p = p->next)
3380                 if (!strcasecmp(p->name, peer))
3381                         break;
3382         ast_mutex_unlock(&peerl.lock);
3383 #ifdef MYSQL_FRIENDS
3384         if (!p)
3385                 p = mysql_peer(peer);
3386 #endif
3387
3388         if (!p) {
3389                 if (authdebug)
3390                         ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, inet_ntoa(sin->sin_addr));
3391                 return -1;
3392         }
3393
3394         if (!p->dynamic) {
3395                 if (authdebug)
3396                         ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, inet_ntoa(sin->sin_addr));
3397                 if (p->temponly)
3398                         free(p);
3399                 return -1;
3400         }
3401
3402         if (!ast_apply_ha(p->ha, sin)) {
3403                 if (authdebug)
3404                         ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", inet_ntoa(sin->sin_addr), p->name);
3405                 if (p->temponly)
3406                         free(p);
3407                 return -1;
3408         }
3409         strncpy(iaxs[callno]->secret, p->secret, sizeof(iaxs[callno]->secret)-1);
3410         strncpy(iaxs[callno]->inkeys, p->inkeys, sizeof(iaxs[callno]->inkeys)-1);
3411         /* Check secret against what we have on file */
3412         if (strlen(rsasecret) && (p->authmethods & IAX_AUTH_RSA) && strlen(iaxs[callno]->challenge)) {
3413                 if (strlen(p->inkeys)) {
3414                         char tmpkeys[256];
3415                         char *stringp=NULL;
3416                         strncpy(tmpkeys, p->inkeys, sizeof(tmpkeys));
3417                         stringp=tmpkeys;
3418                         keyn = strsep(&stringp, ":");
3419                         while(keyn) {
3420                                 key = ast_key_get(keyn, AST_KEY_PUBLIC);
3421                                 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
3422                                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
3423                                         break;
3424                                 } else if (!key)
3425                                         ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
3426                                 keyn = strsep(&stringp, ":");
3427                         }
3428                         if (!keyn) {
3429                                 if (authdebug)
3430                                         ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
3431                                 if (p->temponly)
3432                                         free(p);
3433                                 return -1;
3434                         }
3435                 } else {
3436                         if (authdebug)
3437                                 ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
3438                         if (p->temponly)
3439                                 free(p);
3440                         return -1;
3441                 }
3442         } else if (strlen(secret) && (p->authmethods & IAX_AUTH_PLAINTEXT)) {
3443                 /* They've provided a plain text password and we support that */
3444                 if (strcmp(secret, p->secret)) {
3445                         if (authdebug)
3446                                 ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", inet_ntoa(sin->sin_addr), p->name);
3447                         if (p->temponly)
3448                                 free(p);
3449                         return -1;
3450                 } else
3451                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
3452         } else if (strlen(md5secret) && (p->authmethods & IAX_AUTH_MD5) && strlen(iaxs[callno]->challenge)) {
3453                 struct MD5Context md5;
3454                 unsigned char digest[16];
3455                 MD5Init(&md5);
3456                 MD5Update(&md5, iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
3457                 MD5Update(&md5, p->secret, strlen(p->secret));
3458                 MD5Final(digest, &md5);
3459                 for (x=0;x<16;x++)
3460                         sprintf(requeststr + (x << 1), "%2.2x", digest[x]);
3461                 if (strcasecmp(requeststr, md5secret)) {
3462                         if (authdebug)
3463                                 ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", inet_ntoa(sin->sin_addr), p->name, requeststr, md5secret);
3464                         if (p->temponly)
3465                                 free(p);
3466                         return -1;
3467                 } else
3468                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
3469         } else if (strlen(md5secret) || strlen(secret)) {
3470                 if (authdebug)
3471                         ast_log(LOG_NOTICE, "Inappropriate authentication received\n");
3472                 if (p->temponly)
3473                         free(p);
3474                 return -1;
3475         }
3476         strncpy(iaxs[callno]->peer, peer, sizeof(iaxs[callno]->peer)-1);
3477         /* Choose lowest expirey number */
3478         if (expire && (expire < iaxs[callno]->expirey))
3479                 iaxs[callno]->expirey = expire;
3480         if (p->temponly)
3481                 free(p);
3482         return 0;
3483
3484 }
3485
3486 static int authenticate(char *challenge, char *secret, char *keyn, int authmethods, struct iax_ie_data *ied, struct sockaddr_in *sin)
3487 {
3488         int res = -1;
3489         int x;
3490         if (keyn && strlen(keyn)) {
3491                 if (!(authmethods & IAX_AUTH_RSA)) {
3492                         if (!secret || !strlen(secret))
3493                                 ast_log(LOG_NOTICE, "Asked to authenticate to %s with an RSA key, but they don't allow RSA authentication\n", inet_ntoa(sin->sin_addr));