channels/chan_iax.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of Inter-Asterisk eXchange
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   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 <arpa/inet.h>
  33 #include <sys/socket.h>
  34 #include <netinet/in.h>
  35 #include <netinet/in_systm.h>
  36 #include <netinet/ip.h>
  37 #include <sys/time.h>
  38 #include <sys/signal.h>
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <errno.h>
  43 #include <unistd.h>
  44 #include <netdb.h>
  45 #include <fcntl.h>
  46
  47 #ifdef MYSQL_FRIENDS
  48 #include <mysql/mysql.h>
  49 #endif
  50
  51 #include "iax.h"
  52
  53 #ifndef IPTOS_MINCOST
  54 #define IPTOS_MINCOST 0x02
  55 #endif
  56
  57 /*
  58  * Uncomment to try experimental IAX bridge optimization,
  59  * designed to reduce latency when IAX calls cannot
  60  * be trasnferred
  61  */
  62
  63 #define BRIDGE_OPTIMIZATION
  64
  65
  66 #define DEFAULT_RETRY_TIME 1000
  67 #define MEMORY_SIZE 100
  68 #define DEFAULT_DROP 3
  69
  70 #define DEBUG_SUPPORT
  71
  72 /* Sample over last 100 units to determine historic jitter */
  73 #define GAMMA (0.01)
  74
  75 #ifdef MYSQL_FRIENDS
  76 static ast_mutex_t mysqllock = AST_MUTEX_INITIALIZER;
  77 static MYSQL *mysql;
  78 static char mydbuser[80];
  79 static char mydbpass[80];
  80 static char mydbhost[80];
  81 static char mydbname[80];
  82 #endif
  83
  84 static char *desc = "Inter Asterisk eXchange";
  85 static char *tdesc = "Inter Asterisk eXchange Drver";
  86 static char *type = "IAX";
  87
  88 static char context[80] = "default";
  89
  90 static int max_retries = 4;
  91 static int ping_time = 20;
  92 static int lagrq_time = 10;
  93 static int nextcallno = 0;
  94 static int maxjitterbuffer=3000;
  95
  96 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
  97
  98 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
  99
 100 static int netsocket = -1;
 101
 102 static int tos = 0;
 103
 104 static int expirey = AST_DEFAULT_REG_EXPIRE;
 105
 106 static int usecnt;
 107 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
 108
 109 int (*iax_regfunk)(char *username, int onoff) = NULL;
 110
 111 /* Ethernet, etc */
 112 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
 113 /* T1, maybe ISDN */
 114 #define IAX_CAPABILITY_MEDBANDWIDTH     (IAX_CAPABILITY_FULLBANDWIDTH & \
 115                                                                         ~AST_FORMAT_SLINEAR & \
 116                                                                         ~AST_FORMAT_ULAW & \
 117                                                                         ~AST_FORMAT_ALAW)
 118 /* A modem */
 119 #define IAX_CAPABILITY_LOWBANDWIDTH             (IAX_CAPABILITY_MEDBANDWIDTH & \
 120                                                                         ~AST_FORMAT_ADPCM & \
 121                                                                         ~AST_FORMAT_G726)
 122
 123 #define IAX_CAPABILITY_LOWFREE          (IAX_CAPABILITY_LOWBANDWIDTH & \
 124                                                                          ~AST_FORMAT_G723_1)
 125
 126
 127 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
 128 #define DEFAULT_FREQ_OK         60 * 1000               /* How often to check for the host to be up */
 129 #define DEFAULT_FREQ_NOTOK      10 * 1000               /* How often to check, if the host is down... */
 130
 131 static  struct io_context *io;
 132 static  struct sched_context *sched;
 133
 134 static int iax_capability = IAX_CAPABILITY_FULLBANDWIDTH;
 135
 136 static int iax_dropcount = DEFAULT_DROP;
 137
 138 static int use_jitterbuffer = 1;
 139
 140 static int iaxdebug = 0;
 141
 142 static char accountcode[20];
 143 static int amaflags = 0;
 144
 145 static pthread_t netthreadid;
 146
 147 #define IAX_STATE_STARTED               (1 << 0)
 148 #define IAX_STATE_AUTHENTICATED (1 << 1)
 149 #define IAX_STATE_TBD                   (1 << 2)
 150
 151 struct iax_context {
 152         char context[AST_MAX_EXTENSION];
 153         struct iax_context *next;
 154 };
 155
 156 struct iax_user {
 157         char name[80];
 158         char secret[80];
 159         char methods[80];
 160         char accountcode[20];
 161         char inkeys[80];                                /* Key(s) this user can use to authenticate to us */
 162         int amaflags;
 163         int hascallerid;
 164         int delme;
 165         char callerid[AST_MAX_EXTENSION];
 166         struct ast_ha *ha;
 167         struct iax_context *contexts;
 168         struct iax_user *next;
 169 };
 170
 171 struct iax_peer {
 172         char name[80];
 173         char username[80];
 174         char secret[80];
 175         char outkey[80];                /* What key we use to talk to this peer */
 176         char context[AST_MAX_EXTENSION];        /* Default context (for transfer really) */
 177         struct sockaddr_in addr;
 178         int formats;
 179         struct in_addr mask;
 180
 181         /* Dynamic Registration fields */
 182         int dynamic;                                    /* If this is a dynamic peer */
 183         struct sockaddr_in defaddr;             /* Default address if there is one */
 184         char methods[80];
 185         char inkeys[80];                                /* Key(s) this peer can use to authenticate to us */
 186
 187         int hascallerid;
 188         /* Suggested caller id if registering */
 189         char callerid[AST_MAX_EXTENSION];
 190         /* Whether or not to send ANI */
 191         int sendani;
 192         int expire;                                             /* Schedule entry for expirey */
 193         int expirey;                                    /* How soon to expire */
 194         int capability;                                 /* Capability */
 195         int delme;                                              /* I need to be deleted */
 196
 197         /* Qualification */
 198         int callno;                                     /* Call number of POKE request */
 199         int pokeexpire;                                 /* When to expire poke */
 200         int lastms;                                     /* How long last response took (in ms), or -1 for no response */
 201         int maxms;                                      /* Max ms we will accept for the host to be up, 0 to not monitor */
 202
 203         struct ast_ha *ha;
 204         struct iax_peer *next;
 205 };
 206
 207 #define REG_STATE_UNREGISTERED 0
 208 #define REG_STATE_REGSENT          1
 209 #define REG_STATE_AUTHSENT         2
 210 #define REG_STATE_REGISTERED   3
 211 #define REG_STATE_REJECTED         4
 212 #define REG_STATE_TIMEOUT          5
 213 #define REG_STATE_NOAUTH           6
 214
 215 #define TRANSFER_NONE                   0
 216 #define TRANSFER_BEGIN                  1
 217 #define TRANSFER_READY                  2
 218 #define TRANSFER_RELEASED               3
 219 #define TRANSFER_PASSTHROUGH    4
 220
 221 struct iax_registry {
 222         struct sockaddr_in addr;                /* Who we connect to for registration purposes */
 223         char username[80];
 224         char secret[80];                        /* Password or key name in []'s */
 225         char random[80];
 226         int expire;                                             /* Sched ID of expiration */
 227         int refresh;                                    /* How often to refresh */
 228         int regstate;
 229         int callno;                                             /* Associated call number if applicable */
 230         struct sockaddr_in us;                  /* Who the server thinks we are */
 231         struct iax_registry *next;
 232 };
 233
 234 static struct iax_registry *registrations;
 235
 236 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
 237 #define MIN_RETRY_TIME  10
 238 #define MAX_RETRY_TIME  10000
 239 #define MAX_JITTER_BUFFER 50
 240
 241 /* If we have more than this much excess real jitter buffer, srhink it. */
 242 static int max_jitter_buffer = MAX_JITTER_BUFFER;
 243
 244 struct chan_iax_pvt {
 245         /* Pipes for communication.  pipe[1] belongs to the
 246            network thread (write), and pipe[0] belongs to the individual
 247            channel (read) */
 248         /* Whether or not we Quelch audio */
 249         int quelch;
 250         /* Last received voice format */
 251         int voiceformat;
 252         /* Last sent voice format */
 253         int svoiceformat;
 254         /* What we are capable of sending */
 255         int capability;
 256         /* Last received timestamp */
 257         unsigned int last;
 258         /* Last sent timestamp - never send the same timestamp twice in a single call */
 259         unsigned int lastsent;
 260         /* Ping time */
 261         unsigned int pingtime;
 262         /* Max time for initial response */
 263         int maxtime;
 264         /* Peer Address */
 265         struct sockaddr_in addr;
 266         /* Our call number */
 267         int callno;
 268         /* Peer callno */
 269         int peercallno;
 270         /* Peer selected format */
 271         int peerformat;
 272         /* Peer capability */
 273         int peercapability;
 274         /* timeval that we base our transmission on */
 275         struct timeval offset;
 276         /* timeval that we base our delivery on */
 277         struct timeval rxcore;
 278         /* Historical delivery time */
 279         int history[MEMORY_SIZE];
 280         /* Current base jitterbuffer */
 281         int jitterbuffer;
 282         /* Current jitter measure */
 283         int jitter;
 284         /* Historic jitter value */
 285         int historicjitter;
 286         /* LAG */
 287         int lag;
 288         /* Error, as discovered by the manager */
 289         int error;
 290         /* Owner if we have one */
 291         struct ast_channel *owner;
 292         /* What's our state? */
 293         int state;
 294         /* Expirey (optional) */
 295         int expirey;
 296         /* Next outgoing sequence number */
 297         unsigned short oseqno;
 298         /* Next incoming sequence number */
 299         unsigned short iseqno;
 300         /* Peer name */
 301         char peer[80];
 302         /* Default Context */
 303         char context[80];
 304         /* Caller ID if available */
 305         char callerid[80];
 306         /* Hidden Caller ID (i.e. ANI) if appropriate */
 307         char ani[80];
 308         /* Whether or not ani should be transmitted in addition to Caller*ID */
 309         int sendani;
 310         /* DNID */
 311         char dnid[80];
 312         /* Requested Extension */
 313         char exten[AST_MAX_EXTENSION];
 314         /* Expected Username */
 315         char username[80];
 316         /* Expected Secret */
 317         char secret[80];
 318         /* permitted authentication methods */
 319         char methods[80];
 320         /* MD5 challenge */
 321         char challenge[10];
 322         /* Public keys permitted keys for incoming authentication */
 323         char inkeys[80];
 324         /* Private key for outgoing authentication */
 325         char outkey[80];
 326         /* Preferred language */
 327         char language[80];
 328         /* Associated registry */
 329         struct iax_registry *reg;
 330         /* Associated peer for poking */
 331         struct iax_peer *peerpoke;
 332
 333         /* Transferring status */
 334         int transferring;
 335         /* Already disconnected */
 336         int alreadygone;
 337         /* Who we are IAX transfering to */
 338         struct sockaddr_in transfer;
 339         /* What's the new call number for the transfer */
 340         int transfercallno;
 341
 342         /* Status of knowledge of peer ADSI capability */
 343         int peeradsicpe;
 344
 345         /* Who we are bridged to */
 346         int bridgecallno;
 347         int pingid;                     /* Transmit PING request */
 348         int lagid;                      /* Retransmit lag request */
 349         int autoid;                     /* Auto hangup for Dialplan requestor */
 350         int initid;                     /* Initial peer auto-congest ID (based on qualified peers) */
 351         char dproot[AST_MAX_EXTENSION];
 352         char accountcode[20];
 353         int amaflags;
 354         struct iax_dpcache *dpentries;
 355 };
 356
 357 #define DIRECTION_INGRESS 1
 358 #define DIRECTION_OUTGRESS 2
 359
 360 struct ast_iax_frame {
 361         /* Actual, isolated frame */
 362         struct ast_frame *f;
 363         /* /Our/ call number */
 364         short callno;
 365         /* Start of raw frame (outgoing only) */
 366         void *data;
 367         /* Length of frame (outgoing only) */
 368         int datalen;
 369         /* How many retries so far? */
 370         int retries;
 371         /* Outgoing relative timestamp (ms) */
 372         unsigned int ts;
 373         /* How long to wait before retrying */
 374         int retrytime;
 375         /* Are we received out of order?  */
 376         int outoforder;
 377         /* Have we been sent at all yet? */
 378         int sentyet;
 379         /* Packet sequence number */
 380         int seqno;
 381         /* Non-zero if should be sent to transfer peer */
 382         int transfer;
 383         /* Non-zero if this is the final message */
 384         int final;
 385         /* Ingress or outgres */
 386         int direction;
 387         /* Retransmission ID */
 388         int retrans;
 389
 390
 391         /* Easy linking */
 392         struct ast_iax_frame *next;
 393         struct ast_iax_frame *prev;
 394 };
 395
 396 static struct ast_iax_queue {
 397         struct ast_iax_frame *head;
 398         struct ast_iax_frame *tail;
 399         int count;
 400         ast_mutex_t lock;
 401 } iaxq;
 402
 403 static struct ast_user_list {
 404         struct iax_user *users;
 405         ast_mutex_t lock;
 406 } userl;
 407
 408 static struct ast_peer_list {
 409         struct iax_peer *peers;
 410         ast_mutex_t lock;
 411 } peerl;
 412
 413 /* Extension exists */
 414 #define CACHE_FLAG_EXISTS               (1 << 0)
 415 /* Extension is non-existant */
 416 #define CACHE_FLAG_NONEXISTANT  (1 << 1)
 417 /* Extension can exist */
 418 #define CACHE_FLAG_CANEXIST             (1 << 2)
 419 /* Waiting to hear back response */
 420 #define CACHE_FLAG_PENDING              (1 << 3)
 421 /* Timed out */
 422 #define CACHE_FLAG_TIMEOUT              (1 << 4)
 423 /* Request transmitted */
 424 #define CACHE_FLAG_TRANSMITTED  (1 << 5)
 425 /* Timeout */
 426 #define CACHE_FLAG_UNKNOWN              (1 << 6)
 427 /* Matchmore */
 428 #define CACHE_FLAG_MATCHMORE    (1 << 7)
 429
 430 static struct iax_dpcache {
 431         char peercontext[AST_MAX_EXTENSION];
 432         char exten[AST_MAX_EXTENSION];
 433         struct timeval orig;
 434         struct timeval expirey;
 435         int flags;
 436         int callno;
 437         int waiters[256];
 438         struct iax_dpcache *next;
 439         struct iax_dpcache *peer;       /* For linking in peers */
 440 } *dpcache;
 441
 442 static ast_mutex_t dpcache_lock;
 443
 444 #ifdef DEBUG_SUPPORT
 445 static void showframe(struct ast_iax_frame *f, struct ast_iax_full_hdr *fhi, int rx, struct sockaddr_in *sin)
 446 {
 447         char *frames[] = {
 448                 "(0?)",
 449                 "DTMF   ",
 450                 "VOICE  ",
 451                 "VIDEO  ",
 452                 "CONTROL",
 453                 "NULL   ",
 454                 "IAX    ",
 455                 "TEXT   ",
 456                 "IMAGE  " };
 457         char *iaxs[] = {
 458                 "(0?)",
 459                 "NEW    ",
 460                 "PING   ",
 461                 "PONG   ",
 462                 "ACK    ",
 463                 "HANGUP ",
 464                 "REJECT ",
 465                 "ACCEPT ",
 466                 "AUTHREQ",
 467                 "AUTHREP",
 468                 "INVAL  ",
 469                 "LAGRQ  ",
 470                 "LAGRP  ",
 471                 "REGREQ ",
 472                 "REGAUTH",
 473                 "REGACK ",
 474                 "REGREJ ",
 475                 "REGREL ",
 476                 "VNAK   ",
 477                 "DPREQ  ",
 478                 "DPREP  ",
 479                 "DIAL   ",
 480                 "TXREQ  ",
 481                 "TXCNT  ",
 482                 "TXACC  ",
 483                 "TXREADY",
 484                 "TXREL  ",
 485                 "TXREJ  ",
 486                 "QUELCH ",
 487                 "UNQULCH",
 488                 "POKE",
 489         };
 490         char *cmds[] = {
 491                 "(0?)",
 492                 "HANGUP ",
 493                 "RING   ",
 494                 "RINGING",
 495                 "ANSWER ",
 496                 "BUSY   ",
 497                 "TKOFFHK ",
 498                 "OFFHOOK" };
 499         struct ast_iax_full_hdr *fh;
 500         char retries[20];
 501         char class2[20];
 502         char subclass2[20];
 503         char *class;
 504         char *subclass;
 505         if (f) {
 506                 fh = f->data;
 507                 snprintf(retries, sizeof(retries), "%03d", f->retries);
 508         } else {
 509                 strcpy(retries, "N/A");
 510                 fh = fhi;
 511         }
 512         if (!(ntohs(fh->callno) & AST_FLAG_FULL)) {
 513                 /* Don't mess with mini-frames */
 514                 return;
 515         }
 516         if (fh->type > sizeof(frames)/sizeof(char *)) {
 517                 snprintf(class2, sizeof(class2), "(%d?)", fh->type);
 518                 class = class2;
 519         } else {
 520                 class = frames[(int)fh->type];
 521         }
 522         if (fh->type == AST_FRAME_DTMF) {
 523                 sprintf(subclass2, "%c", fh->csub);
 524                 subclass = subclass2;
 525         } else if (fh->type == AST_FRAME_IAX) {
 526                 if (fh->csub >= sizeof(iaxs)/sizeof(iaxs[0])) {
 527                         snprintf(subclass2, sizeof(subclass2), "(%d?)", fh->csub);
 528                         subclass = subclass2;
 529                 } else {
 530                         subclass = iaxs[(int)fh->csub];
 531                 }
 532         } else if (fh->type == AST_FRAME_CONTROL) {
 533                 if (fh->csub > sizeof(cmds)/sizeof(char *)) {
 534                         snprintf(subclass2, sizeof(subclass2), "(%d?)", fh->csub);
 535                         subclass = subclass2;
 536                 } else {
 537                         subclass = cmds[(int)fh->csub];
 538                 }
 539         } else {
 540                 snprintf(subclass2, sizeof(subclass2), "%d", fh->csub);
 541                 subclass = subclass2;
 542         }
 543         ast_verbose(
 544 "%s-Frame Retry[%s] -- Seqno: %2.2d  Type: %s Subclass: %s\n",
 545         (rx ? "Rx" : "Tx"),
 546         retries, ntohs(fh->seqno), class, subclass);
 547                 fprintf(stderr,
 548 "   Timestamp: %05ldms  Callno: %5.5d  DCall: %5.5d [%s:%d]\n",
 549         (long)ntohl(fh->ts),
 550         (short)(ntohs(fh->callno) & ~AST_FLAG_FULL), (short) ntohs(fh->dcallno),
 551                 inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
 552 }
 553 #endif
 554
 555 /* XXX We probably should use a mutex when working with this XXX */
 556 static struct chan_iax_pvt *iaxs[AST_IAX_MAX_CALLS];
 557 static ast_mutex_t iaxsl[AST_IAX_MAX_CALLS];
 558
 559 static int send_command(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int);
 560 static int send_command_immediate(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int);
 561 static int send_command_final(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int);
 562 static int send_command_transfer(struct chan_iax_pvt *, char, int, unsigned int, char *, int);
 563
 564 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts);
 565
 566 static int send_ping(void *data)
 567 {
 568         int callno = (long)data;
 569         /* Ping only if it's real, not if it's bridged */
 570         if (iaxs[callno]) {
 571 #ifdef BRIDGE_OPTIMIZATION
 572                 if (iaxs[callno]->bridgecallno < 0)
 573 #endif
 574                         send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_PING, 0, NULL, 0, -1);
 575                 return 1;
 576         } else
 577                 return 0;
 578 }
 579
 580 static int send_lagrq(void *data)
 581 {
 582         int callno = (long)data;
 583         /* Ping only if it's real not if it's bridged */
 584         if (iaxs[callno]) {
 585 #ifdef BRIDGE_OPTIMIZATION
 586                 if (iaxs[callno]->bridgecallno < 0)
 587 #endif
 588                         send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
 589                 return 1;
 590         } else
 591                 return 0;
 592 }
 593
 594 static unsigned char compress_subclass(int subclass)
 595 {
 596         int x;
 597         int power=-1;
 598         /* If it's 128 or smaller, just return it */
 599         if (subclass < AST_FLAG_SC_LOG)
 600                 return subclass;
 601         /* Otherwise find its power */
 602         for (x = 0; x < AST_MAX_SHIFT; x++) {
 603                 if (subclass & (1 << x)) {
 604                         if (power > -1) {
 605                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
 606                                 return 0;
 607                         } else
 608                                 power = x;
 609                 }
 610         }
 611         return power | AST_FLAG_SC_LOG;
 612 }
 613
 614 static int uncompress_subclass(unsigned char csub)
 615 {
 616         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
 617         if (csub & AST_FLAG_SC_LOG) {
 618                 /* special case for 'compressed' -1 */
 619                 if (csub == 0xff)
 620                         return -1;
 621                 else
 622                         return 1 << (csub & ~AST_FLAG_SC_LOG & AST_MAX_SHIFT);
 623         }
 624         else
 625                 return csub;
 626 }
 627
 628 static struct chan_iax_pvt *new_iax(void)
 629 {
 630         struct chan_iax_pvt *tmp;
 631         tmp = malloc(sizeof(struct chan_iax_pvt));
 632         if (tmp) {
 633                 memset(tmp, 0, sizeof(struct chan_iax_pvt));
 634                 tmp->callno = -1;
 635                 tmp->peercallno = -1;
 636                 tmp->transfercallno = -1;
 637                 tmp->bridgecallno = -1;
 638                 tmp->pingid = -1;
 639                 tmp->lagid = -1;
 640                 tmp->autoid = -1;
 641                 tmp->initid = -1;
 642                 /* strncpy(tmp->context, context, sizeof(tmp->context)-1); */
 643                 strncpy(tmp->exten, "s", sizeof(tmp->exten)-1);
 644         }
 645         return tmp;
 646 }
 647
 648 static int get_samples(struct ast_frame *f)
 649 {
 650         int samples=0;
 651         switch(f->subclass) {
 652         case AST_FORMAT_G723_1:
 653                 samples = 240 /* XXX Not necessarily true XXX */;
 654                 break;
 655         case AST_FORMAT_GSM:
 656                 samples = 160 * (f->datalen / 33);
 657                 break;
 658         case AST_FORMAT_ILBC:
 659                 samples = 240 * (f->datalen / 50);
 660                 break;
 661         case AST_FORMAT_G729A:
 662                 samples = 160 * (f->datalen / 20);
 663                 break;
 664         case AST_FORMAT_SLINEAR:
 665                 samples = f->datalen / 2;
 666                 break;
 667         case AST_FORMAT_LPC10:
 668                 samples = 22 * 8;
 669                 samples += (((char *)(f->data))[7] & 0x1) * 8;
 670                 break;
 671         case AST_FORMAT_ULAW:
 672                 samples = f->datalen;
 673                 break;
 674         case AST_FORMAT_ALAW:
 675                 samples = f->datalen;
 676                 break;
 677         case AST_FORMAT_ADPCM:
 678                 samples = f->datalen *2;
 679                 break;
 680         case AST_FORMAT_SPEEX:
 681                 samples = (f->datalen/39)*160;
 682                 break;
 683         default:
 684                 ast_log(LOG_WARNING, "Don't know how to calculate samples on %d packets\n", f->subclass);
 685         }
 686         return samples;
 687 }
 688
 689 static int frames = 0;
 690 static int iframes = 0;
 691 static int oframes = 0;
 692
 693 static struct ast_iax_frame *ast_iax_frame_new(int direction)
 694 {
 695         struct ast_iax_frame *fr;
 696         fr = malloc(sizeof(struct ast_iax_frame));
 697         if (fr) {
 698                 fr->direction = direction;
 699                 fr->retrans = -1;
 700                 frames++;
 701                 if (fr->direction == DIRECTION_INGRESS)
 702                         iframes++;
 703                 else
 704                         oframes++;
 705         }
 706         return fr;
 707 }
 708
 709 static void ast_iax_frame_free(struct ast_iax_frame *fr)
 710 {
 711         if (fr->retrans > -1)
 712                 ast_sched_del(sched, fr->retrans);
 713         if (fr->direction == DIRECTION_INGRESS)
 714                 iframes--;
 715         else if (fr->direction == DIRECTION_OUTGRESS)
 716                 oframes--;
 717         else {
 718                 ast_log(LOG_WARNING, "Attempt to double free frame detected\n");
 719                 CRASH;
 720                 return;
 721         }
 722         fr->direction = 0;
 723         free(fr);
 724         frames--;
 725 }
 726
 727 static struct ast_iax_frame *iaxfrdup2(struct ast_iax_frame *fr, int ch)
 728 {
 729         /* Malloc() a copy of a frame */
 730         struct ast_iax_frame *new = ast_iax_frame_new(DIRECTION_INGRESS);
 731         if (new) {
 732                 memcpy(new, fr, sizeof(struct ast_iax_frame));
 733                 new->f = ast_frdup(fr->f);
 734                 /* Copy full header */
 735                 if (ch) {
 736                         memcpy(new->f->data - sizeof(struct ast_iax_full_hdr),
 737                                         fr->f->data - sizeof(struct ast_iax_full_hdr),
 738                                                 sizeof(struct ast_iax_full_hdr));
 739                         /* Grab new data pointer */
 740                         new->data = new->f->data - (fr->f->data - fr->data);
 741                 } else {
 742                         new->data = NULL;
 743                         new->datalen = 0;
 744                 }
 745                 new->direction = DIRECTION_INGRESS;
 746                 new->retrans = -1;
 747         }
 748         return new;
 749 }
 750
 751 #define NEW_PREVENT 0
 752 #define NEW_ALLOW       1
 753 #define NEW_FORCE       2
 754
 755 static int match(struct sockaddr_in *sin, short callno, short dcallno, struct chan_iax_pvt *cur)
 756 {
 757         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
 758                 (cur->addr.sin_port == sin->sin_port)) {
 759                 /* This is the main host */
 760                 if ((cur->peercallno == callno) ||
 761                         ((dcallno == cur->callno) && (cur->peercallno) == -1)) {
 762                         /* That's us.  Be sure we keep track of the peer call number */
 763                         return 1;
 764                 }
 765         }
 766         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
 767             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
 768                 /* We're transferring */
 769                 if (dcallno == cur->callno)
 770                         return 1;
 771         }
 772         return 0;
 773 }
 774
 775 static int find_callno(short callno, short dcallno ,struct sockaddr_in *sin, int new)
 776 {
 777         int res = -1;
 778         int x;
 779         int start;
 780         if (new <= NEW_ALLOW) {
 781                 /* Look for an existing connection first */
 782                 for (x=0;(res < 0) && (x<AST_IAX_MAX_CALLS);x++) {
 783                         ast_mutex_lock(&iaxsl[x]);
 784                         if (iaxs[x]) {
 785                                 /* Look for an exact match */
 786                                 if (match(sin, callno, dcallno, iaxs[x])) {
 787                                         res = x;
 788                                 }
 789                         }
 790                         ast_mutex_unlock(&iaxsl[x]);
 791                 }
 792         }
 793         if ((res < 0) && (new >= NEW_ALLOW)) {
 794                 /* Create a new one */
 795                 start = nextcallno;
 796                 for (x = (nextcallno + 1) % AST_IAX_MAX_CALLS; iaxs[x] && (x != start); x = (x + 1) % AST_IAX_MAX_CALLS)
 797                 if (x == start) {
 798                         ast_log(LOG_WARNING, "Unable to accept more calls\n");
 799                         return -1;
 800                 }
 801                 ast_mutex_lock(&iaxsl[x]);
 802                 iaxs[x] = new_iax();
 803                 ast_mutex_unlock(&iaxsl[x]);
 804                 if (iaxs[x]) {
 805                         if (option_debug)
 806                                 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
 807                         iaxs[x]->addr.sin_port = sin->sin_port;
 808                         iaxs[x]->addr.sin_family = sin->sin_family;
 809                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
 810                         iaxs[x]->peercallno = callno;
 811                         iaxs[x]->callno = x;
 812                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
 813                         iaxs[x]->expirey = expirey;
 814                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)x);
 815                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)x);
 816                         iaxs[x]->amaflags = amaflags;
 817                         strncpy(iaxs[x]->accountcode, accountcode, sizeof(iaxs[x]->accountcode)-1);
 818                 } else {
 819                         ast_log(LOG_WARNING, "Out of resources\n");
 820                         return -1;
 821                 }
 822                 res = x;
 823                 nextcallno = x;
 824         }
 825         return res;
 826 }
 827
 828 static int iax_queue_frame(int callno, struct ast_frame *f)
 829 {
 830         int pass =0;
 831         /* Assumes lock for callno is already held... */
 832         for (;;) {
 833                 pass++;
 834                 if (!ast_mutex_trylock(&iaxsl[callno])) {
 835                         ast_log(LOG_WARNING, "Lock is not held on pass %d of iax_queue_frame\n", pass);
 836                         CRASH;
 837                 }
 838                 if (iaxs[callno] && iaxs[callno]->owner) {
 839                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
 840                                 /* Avoid deadlock by pausing and trying again */
 841                                 ast_mutex_unlock(&iaxsl[callno]);
 842                                 usleep(1);
 843                                 ast_mutex_lock(&iaxsl[callno]);
 844                         } else {
 845                                 ast_queue_frame(iaxs[callno]->owner, f, 0);
 846                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
 847                                 break;
 848                         }
 849                 } else
 850                         break;
 851         }
 852         return 0;
 853 }
 854
 855 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
 856
 857 static int __do_deliver(void *data)
 858 {
 859         /* Just deliver the packet by using queueing.  This is called by
 860           the IAX thread with the iaxsl lock held. */
 861         struct ast_iax_frame *fr = data;
 862         unsigned int ts;
 863         fr->retrans = -1;
 864         if (iaxs[fr->callno] && !iaxs[fr->callno]->alreadygone) {
 865                 if (fr->f->frametype == AST_FRAME_IAX) {
 866                         /* We have to treat some of these packets specially because
 867                            they're LAG measurement packets */
 868                         if (fr->f->subclass == AST_IAX_COMMAND_LAGRQ) {
 869                                 /* If we got a queued request, build a reply and send it */
 870                                 fr->f->subclass = AST_IAX_COMMAND_LAGRP;
 871                                 iax_send(iaxs[fr->callno], fr->f, fr->ts, -1, 0, 0, 0);
 872                         } else if (fr->f->subclass == AST_IAX_COMMAND_LAGRP) {
 873                                 /* This is a reply we've been given, actually measure the difference */
 874                                 ts = calc_timestamp(iaxs[fr->callno], 0);
 875                                 iaxs[fr->callno]->lag = ts - fr->ts;
 876                         }
 877                 } else {
 878                         iax_queue_frame(fr->callno, fr->f);
 879                 }
 880         }
 881         /* Free the packet */
 882         ast_frfree(fr->f);
 883         /* And our iax frame */
 884         ast_iax_frame_free(fr);
 885         /* And don't run again */
 886         return 0;
 887 }
 888
 889 static int do_deliver(void *data)
 890 {
 891         /* Locking version of __do_deliver */
 892         struct ast_iax_frame *fr = data;
 893         int callno = fr->callno;
 894         int res;
 895         ast_mutex_lock(&iaxsl[callno]);
 896         res = __do_deliver(data);
 897         ast_mutex_unlock(&iaxsl[callno]);
 898         return res;
 899 }
 900
 901 static int handle_error(void)
 902 {
 903         /* XXX Ideally we should figure out why an error occured and then abort those
 904            rather than continuing to try.  Unfortunately, the published interface does
 905            not seem to work XXX */
 906 #if 0
 907         struct sockaddr_in *sin;
 908         int res;
 909         struct msghdr m;
 910         struct sock_extended_err e;
 911         m.msg_name = NULL;
 912         m.msg_namelen = 0;
 913         m.msg_iov = NULL;
 914         m.msg_control = &e;
 915         m.msg_controllen = sizeof(e);
 916         m.msg_flags = 0;
 917         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
 918         if (res < 0)
 919                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
 920         else {
 921                 if (m.msg_controllen) {
 922                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
 923                         if (sin)
 924                                 ast_log(LOG_WARNING, "Receive error from %s\n", inet_ntoa(sin->sin_addr));
 925                         else
 926                                 ast_log(LOG_WARNING, "No address detected??\n");
 927                 } else {
 928                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
 929                 }
 930         }
 931 #endif
 932         return 0;
 933 }
 934
 935 static int send_packet(struct ast_iax_frame *f)
 936 {
 937         int res;
 938         /* Called with iaxsl held */
 939         if (option_debug)
 940                 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));
 941         /* Don't send if there was an error, but return error instead */
 942         if (f->callno < 0) {
 943                 ast_log(LOG_WARNING, "Call number = %d\n", f->callno);
 944                 return -1;
 945         }
 946         if (!iaxs[f->callno])
 947                 return -1;
 948         if (iaxs[f->callno]->error)
 949                 return -1;
 950         if (f->transfer) {
 951 #ifdef DEBUG_SUPPORT
 952                 if (iaxdebug)
 953                         showframe(f, NULL, 0, &iaxs[f->callno]->transfer);
 954 #endif
 955                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->transfer,
 956                                         sizeof(iaxs[f->callno]->transfer));
 957         } else {
 958 #ifdef DEBUG_SUPPORT
 959                 if (iaxdebug)
 960                         showframe(f, NULL, 0, &iaxs[f->callno]->addr);
 961 #endif
 962                 res = sendto(netsocket, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[f->callno]->addr,
 963                                         sizeof(iaxs[f->callno]->addr));
 964         }
 965         if (res < 0) {
 966                 if (option_debug)
 967                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
 968                 handle_error();
 969         } else
 970                 res = 0;
 971         return res;
 972 }
 973
 974
 975 static int iax_predestroy(int callno)
 976 {
 977         struct ast_channel *c;
 978         struct chan_iax_pvt *pvt;
 979         ast_mutex_lock(&iaxsl[callno]);
 980         pvt = iaxs[callno];
 981         if (!pvt) {
 982                 ast_mutex_unlock(&iaxsl[callno]);
 983                 return -1;
 984         }
 985         if (!pvt->alreadygone) {
 986                 /* No more pings or lagrq's */
 987                 if (pvt->pingid > -1)
 988                         ast_sched_del(sched, pvt->pingid);
 989                 if (pvt->lagid > -1)
 990                         ast_sched_del(sched, pvt->lagid);
 991                 if (pvt->autoid > -1)
 992                         ast_sched_del(sched, pvt->autoid);
 993                 if (pvt->initid > -1)
 994                         ast_sched_del(sched, pvt->initid);
 995                 pvt->pingid = -1;
 996                 pvt->lagid = -1;
 997                 pvt->autoid = -1;
 998                 pvt->initid = -1;
 999                 pvt->alreadygone = 1;
1000         }
1001         c = pvt->owner;
1002         if (c) {
1003                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1004                 c->pvt->pvt = NULL;
1005                 pvt->owner = NULL;
1006                 ast_mutex_lock(&usecnt_lock);
1007                 usecnt--;
1008                 if (usecnt < 0)
1009                         ast_log(LOG_WARNING, "Usecnt < 0???\n");
1010                 ast_mutex_unlock(&usecnt_lock);
1011                 ast_update_use_count();
1012         }
1013         ast_mutex_unlock(&iaxsl[callno]);
1014         return 0;
1015 }
1016
1017 static int iax_predestroy_nolock(int callno)
1018 {
1019         int res;
1020         ast_mutex_unlock(&iaxsl[callno]);
1021         res = iax_predestroy(callno);
1022         ast_mutex_lock(&iaxsl[callno]);
1023         return res;
1024 }
1025
1026 static void iax_destroy(int callno)
1027 {
1028         struct chan_iax_pvt *pvt;
1029         struct ast_iax_frame *cur;
1030         struct ast_channel *owner;
1031
1032 retry:
1033         ast_mutex_lock(&iaxsl[callno]);
1034         pvt = iaxs[callno];
1035         iaxs[callno] = NULL;
1036
1037         if (pvt)
1038                 owner = pvt->owner;
1039         else
1040                 owner = NULL;
1041         if (owner) {
1042                 if (ast_mutex_trylock(&owner->lock)) {
1043                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1044                         ast_mutex_unlock(&iaxsl[callno]);
1045                         usleep(1);
1046                         goto retry;
1047                 }
1048         }
1049         if (pvt) {
1050                 pvt->owner = NULL;
1051                 /* No more pings or lagrq's */
1052                 if (pvt->pingid > -1)
1053                         ast_sched_del(sched, pvt->pingid);
1054                 if (pvt->lagid > -1)
1055                         ast_sched_del(sched, pvt->lagid);
1056                 if (pvt->autoid > -1)
1057                         ast_sched_del(sched, pvt->autoid);
1058                 if (pvt->initid > -1)
1059                         ast_sched_del(sched, pvt->initid);
1060                 pvt->pingid = -1;
1061                 pvt->lagid = -1;
1062                 pvt->autoid = -1;
1063                 pvt->initid = -1;
1064
1065                 /* Already gone */
1066                 pvt->alreadygone = 1;
1067
1068                 if (owner) {
1069                         /* If there's an owner, prod it to give up */
1070                         owner->pvt->pvt = NULL;
1071                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1072                         ast_queue_hangup(owner, 0);
1073                 }
1074
1075                 for (cur = iaxq.head; cur ; cur = cur->next) {
1076                         /* Cancel any pending transmissions */
1077                         if (cur->callno == pvt->callno)
1078                                 cur->retries = -1;
1079                 }
1080                 if (pvt->reg) {
1081                         pvt->reg->callno = -1;
1082                 }
1083                 free(pvt);
1084         }
1085         if (owner) {
1086                 ast_mutex_unlock(&owner->lock);
1087         }
1088         ast_mutex_unlock(&iaxsl[callno]);
1089 }
1090 static void iax_destroy_nolock(int callno)
1091 {
1092         /* Actually it's easier to unlock, kill it, and relock */
1093         ast_mutex_unlock(&iaxsl[callno]);
1094         iax_destroy(callno);
1095         ast_mutex_lock(&iaxsl[callno]);
1096 }
1097
1098
1099
1100 static int attempt_transmit(void *data)
1101 {
1102         /* Attempt to transmit the frame to the remote peer...
1103            Called without iaxsl held. */
1104         struct ast_iax_frame *f = data;
1105         int freeme=0;
1106         int callno = f->callno;
1107         /* Make sure this call is still active */
1108         if (callno > -1)
1109                 ast_mutex_lock(&iaxsl[callno]);
1110         if ((f->callno > -1) && iaxs[f->callno]) {
1111                 if ((f->retries < 0) /* Already ACK'd */ ||
1112                     (f->retries >= max_retries) /* Too many attempts */) {
1113                                 /* Record an error if we've transmitted too many times */
1114                                 if (f->retries >= max_retries) {
1115                                         if (f->transfer) {
1116                                                 /* Transfer timeout */
1117                                                 send_command(iaxs[f->callno], AST_FRAME_IAX, AST_IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1118                                         } else if (f->final) {
1119                                                 if (f->final)
1120                                                         iax_destroy_nolock(f->callno);
1121                                         } else {
1122                                                 if (iaxs[f->callno]->owner)
1123                                                         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->f->frametype, f->f->subclass, f->ts, f->seqno);
1124                                                 iaxs[f->callno]->error = ETIMEDOUT;
1125                                                 if (iaxs[f->callno]->owner) {
1126                                                         struct ast_frame fr = { 0, };
1127                                                         /* Hangup the fd */
1128                                                         fr.frametype = AST_FRAME_CONTROL;
1129                                                         fr.subclass = AST_CONTROL_HANGUP;
1130                                                         iax_queue_frame(f->callno, &fr);
1131                                                 } else {
1132                                                         if (iaxs[f->callno]->reg) {
1133                                                                 memset(&iaxs[f->callno]->reg->us, 0, sizeof(iaxs[f->callno]->reg->us));
1134                                                                 iaxs[f->callno]->reg->regstate = REG_STATE_TIMEOUT;
1135                                                                 iaxs[f->callno]->reg->refresh = AST_DEFAULT_REG_EXPIRE;
1136                                                         }
1137                                                         iax_destroy_nolock(f->callno);
1138                                                 }
1139                                         }
1140
1141                                 }
1142                                 freeme++;
1143                 } else {
1144                         /* Attempt transmission */
1145                         send_packet(f);
1146                         f->retries++;
1147                         /* Try again later after 10 times as long */
1148                         f->retrytime *= 10;
1149                         if (f->retrytime > MAX_RETRY_TIME)
1150                                 f->retrytime = MAX_RETRY_TIME;
1151                         /* Transfer messages max out at one second */
1152                         if (f->transfer && (f->retrytime > 1000))
1153                                 f->retrytime = 1000;
1154                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1155                 }
1156         } else {
1157                 /* Make sure it gets freed */
1158                 f->retries = -1;
1159                 freeme++;
1160         }
1161         if (callno > -1)
1162                 ast_mutex_unlock(&iaxsl[callno]);
1163         /* Do not try again */
1164         if (freeme) {
1165                 /* Don't attempt delivery, just remove it from the queue */
1166                 ast_mutex_lock(&iaxq.lock);
1167                 if (f->prev)
1168                         f->prev->next = f->next;
1169                 else
1170                         iaxq.head = f->next;
1171                 if (f->next)
1172                         f->next->prev = f->prev;
1173                 else
1174                         iaxq.tail = f->prev;
1175                 iaxq.count--;
1176                 ast_mutex_unlock(&iaxq.lock);
1177                 /* Free the frame */
1178                 ast_frfree(f->f);
1179                 f->retrans = -1;
1180                 ast_iax_frame_free(f);
1181         }
1182         return 0;
1183 }
1184
1185 static int iax_set_jitter(int fd, int argc, char *argv[])
1186 {
1187         if ((argc != 4) && (argc != 5))
1188                 return RESULT_SHOWUSAGE;
1189         if (argc == 4) {
1190                 max_jitter_buffer = atoi(argv[3]);
1191                 if (max_jitter_buffer < 0)
1192                         max_jitter_buffer = 0;
1193         } else {
1194                 if (argc == 5) {
1195                         if ((atoi(argv[3]) >= 0) && (atoi(argv[3]) < AST_IAX_MAX_CALLS)) {
1196                                 if (iaxs[atoi(argv[3])]) {
1197                                         iaxs[atoi(argv[3])]->jitterbuffer = atoi(argv[4]);
1198                                         if (iaxs[atoi(argv[3])]->jitterbuffer < 0)
1199                                                 iaxs[atoi(argv[3])]->jitterbuffer = 0;
1200                                 } else
1201                                         ast_cli(fd, "No such call '%d'\n", atoi(argv[3]));
1202                         } else
1203                                 ast_cli(fd, "%d is not a valid call number\n", atoi(argv[3]));
1204                 }
1205         }
1206         return RESULT_SUCCESS;
1207 }
1208
1209 static char jitter_usage[] =
1210 "Usage: iax set jitter [callid] <value>\n"
1211 "       If used with a callid, it sets the jitter buffer to the given static\n"
1212 "value (until its next calculation).  If used without a callid, the value is used\n"
1213 "to establish the maximum excess jitter buffer that is permitted before the jitter\n"
1214 "buffer size is reduced.";
1215
1216 static int iax_show_stats(int fd, int argc, char *argv[])
1217 {
1218         struct ast_iax_frame *cur;
1219         int cnt = 0, dead=0, final=0;
1220         if (argc != 3)
1221                 return RESULT_SHOWUSAGE;
1222         for (cur = iaxq.head; cur ; cur = cur->next) {
1223                 if (cur->retries < 0)
1224                         dead++;
1225                 if (cur->final)
1226                         final++;
1227                 cnt++;
1228         }
1229         ast_cli(fd, "    IAX Statistics\n");
1230         ast_cli(fd, "---------------------\n");
1231         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d outgress)\n", frames, iframes, oframes);
1232         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n", dead, final, cnt);
1233         return RESULT_SUCCESS;
1234 }
1235
1236 static int iax_show_cache(int fd, int argc, char *argv[])
1237 {
1238         struct iax_dpcache *dp;
1239         char tmp[1024], *pc;
1240         int s;
1241         int x,y;
1242         struct timeval tv;
1243         gettimeofday(&tv, NULL);
1244         ast_mutex_lock(&dpcache_lock);
1245         dp = dpcache;
1246         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
1247         while(dp) {
1248                 s = dp->expirey.tv_sec - tv.tv_sec;
1249                 strcpy(tmp, "");
1250                 if (dp->flags & CACHE_FLAG_EXISTS)
1251                         strcat(tmp, "EXISTS|");
1252                 if (dp->flags & CACHE_FLAG_NONEXISTANT)
1253                         strcat(tmp, "NONEXISTANT|");
1254                 if (dp->flags & CACHE_FLAG_CANEXIST)
1255                         strcat(tmp, "CANEXIST|");
1256                 if (dp->flags & CACHE_FLAG_PENDING)
1257                         strcat(tmp, "PENDING|");
1258                 if (dp->flags & CACHE_FLAG_TIMEOUT)
1259                         strcat(tmp, "TIMEOUT|");
1260                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
1261                         strcat(tmp, "TRANSMITTED|");
1262                 if (dp->flags & CACHE_FLAG_MATCHMORE)
1263                         strcat(tmp, "MATCHMORE|");
1264                 if (dp->flags & CACHE_FLAG_UNKNOWN)
1265                         strcat(tmp, "UNKNOWN|");
1266                 /* Trim trailing pipe */
1267                 if (strlen(tmp))
1268                         tmp[strlen(tmp) - 1] = '\0';
1269                 else
1270                         strcpy(tmp, "(none)");
1271                 y=0;
1272                 pc = strchr(dp->peercontext, '@');
1273                 if (!pc)
1274                         pc = dp->peercontext;
1275                 else
1276                         pc++;
1277                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
1278                         if (dp->waiters[x] > -1)
1279                                 y++;
1280                 if (s > 0)
1281                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
1282                 else
1283                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
1284                 dp = dp->next;
1285         }
1286         ast_mutex_unlock(&dpcache_lock);
1287         return RESULT_SUCCESS;
1288 }
1289
1290 static char show_stats_usage[] =
1291 "Usage: iax show stats\n"
1292 "       Display statistics on IAX channel driver.\n";
1293
1294
1295 static char show_cache_usage[] =
1296 "Usage: iax show cache\n"
1297 "       Display currently cached IAX Dialplan results.\n";
1298
1299 static struct ast_cli_entry cli_set_jitter =
1300 { { "iax", "set", "jitter", NULL }, iax_set_jitter, "Sets IAX jitter buffer", jitter_usage };
1301
1302 static struct ast_cli_entry cli_show_stats =
1303 { { "iax", "show", "stats", NULL }, iax_show_stats, "Display IAX statistics", show_stats_usage };
1304
1305 static struct ast_cli_entry cli_show_cache =
1306 { { "iax", "show", "cache", NULL }, iax_show_cache, "Display IAX cached dialplan", show_cache_usage };
1307
1308 static unsigned int calc_rxstamp(struct chan_iax_pvt *p);
1309
1310 #ifdef BRIDGE_OPTIMIZATION
1311 static unsigned int calc_fakestamp(struct chan_iax_pvt *from, struct chan_iax_pvt *to, unsigned int ts);
1312
1313 static int forward_delivery(struct ast_iax_frame *fr)
1314 {
1315         struct chan_iax_pvt *p1, *p2;
1316         p1 = iaxs[fr->callno];
1317         p2 = iaxs[p1->bridgecallno];
1318         if (!p1)
1319                 return -1;
1320         if (!p2)
1321                 return -1;
1322         /* Fix relative timestamp */
1323         fr->ts = calc_fakestamp(p1, p2, fr->ts);
1324         /* Now just send it send on the 2nd one
1325            with adjusted timestamp */
1326         return iax_send(p2, fr->f, fr->ts, -1, 0, 0, 0);
1327 }
1328 #endif
1329
1330 static int schedule_delivery(struct ast_iax_frame *fr, int reallydeliver)
1331 {
1332         int ms,x;
1333         int drops[MEMORY_SIZE];
1334         int min, max=0, maxone=0,y,z, match;
1335         /* ms is a measure of the "lateness" of the packet relative to the first
1336            packet we received, which always has a lateness of 1.  Called by
1337            IAX thread, with iaxsl lock held. */
1338         ms = calc_rxstamp(iaxs[fr->callno]) - fr->ts;
1339
1340         if (ms > 32767) {
1341                 /* What likely happened here is that our counter has circled but we haven't
1342                    gotten the update from the main packet.  We'll just pretend that we did, and
1343                    update the timestamp appropriately. */
1344                 ms -= 65536;
1345         }
1346
1347         if (ms < -32768) {
1348                 /* We got this packet out of order.  Lets add 65536 to it to bring it into our new
1349                    time frame */
1350                 ms += 65536;
1351         }
1352
1353         /* Rotate our history queue of "lateness".  Don't worry about those initial
1354            zeros because the first entry will always be zero */
1355         for (x=0;x<MEMORY_SIZE - 1;x++)
1356                 iaxs[fr->callno]->history[x] = iaxs[fr->callno]->history[x+1];
1357         /* Add a history entry for this one */
1358         iaxs[fr->callno]->history[x] = ms;
1359
1360         /* Initialize the minimum to reasonable values.  It's too much
1361            work to do the same for the maximum, repeatedly */
1362         min=iaxs[fr->callno]->history[0];
1363         for (z=0;z < iax_dropcount + 1;z++) {
1364                 /* Start very optimistic ;-) */
1365                 max=-999999999;
1366                 for (x=0;x<MEMORY_SIZE;x++) {
1367                         if (max < iaxs[fr->callno]->history[x]) {
1368                                 /* We have a candidate new maximum value.  Make
1369                                    sure it's not in our drop list */
1370                                 match = 0;
1371                                 for (y=0;!match && (y<z);y++)
1372                                         match |= (drops[y] == x);
1373                                 if (!match) {
1374                                         /* It's not in our list, use it as the new maximum */
1375                                         max = iaxs[fr->callno]->history[x];
1376                                         maxone = x;
1377                                 }
1378
1379                         }
1380                         if (!z) {
1381                                 /* On our first pass, find the minimum too */
1382                                 if (min > iaxs[fr->callno]->history[x])
1383                                         min = iaxs[fr->callno]->history[x];
1384                         }
1385                 }
1386 #if 1
1387                 drops[z] = maxone;
1388 #endif
1389         }
1390         /* Just for reference, keep the "jitter" value, the difference between the
1391            earliest and the latest. */
1392         iaxs[fr->callno]->jitter = max - min;
1393
1394         /* IIR filter for keeping track of historic jitter, but always increase
1395            historic jitter immediately for increase */
1396
1397         if (iaxs[fr->callno]->jitter > iaxs[fr->callno]->historicjitter )
1398                 iaxs[fr->callno]->historicjitter = iaxs[fr->callno]->jitter;
1399         else
1400                 iaxs[fr->callno]->historicjitter = GAMMA * (double)iaxs[fr->callno]->jitter + (1-GAMMA) *
1401                         iaxs[fr->callno]->historicjitter;
1402
1403         /* If our jitter buffer is too big (by a significant margin), then we slowly
1404            shrink it by about 1 ms each time to avoid letting the change be perceived */
1405         if (max < iaxs[fr->callno]->jitterbuffer - max_jitter_buffer)
1406                 iaxs[fr->callno]->jitterbuffer -= 2;
1407
1408
1409 #if 1
1410         /* Constrain our maximum jitter buffer appropriately */
1411         if (max > min + maxjitterbuffer) {
1412                 if (option_debug)
1413                         ast_log(LOG_DEBUG, "Constraining buffer from %d to %d + %d\n", max, min , maxjitterbuffer);
1414                 max = min + maxjitterbuffer;
1415         }
1416 #endif
1417
1418         /* If our jitter buffer is smaller than our maximum delay, grow the jitter
1419            buffer immediately to accomodate it (and a little more).  */
1420         if (max > iaxs[fr->callno]->jitterbuffer)
1421                 iaxs[fr->callno]->jitterbuffer = max
1422                         /* + ((float)iaxs[fr->callno]->jitter) * 0.1 */;
1423
1424
1425         if (option_debug)
1426                 ast_log(LOG_DEBUG, "min = %d, max = %d, jb = %d, lateness = %d\n", min, max, iaxs[fr->callno]->jitterbuffer, ms);
1427
1428         /* Subtract the lateness from our jitter buffer to know how long to wait
1429            before sending our packet.  */
1430         ms = iaxs[fr->callno]->jitterbuffer - ms;
1431
1432         if (!use_jitterbuffer)
1433                 ms = 0;
1434
1435         /* If the caller just wanted us to update, return now */
1436         if (!reallydeliver)
1437                 return 0;
1438
1439         if (ms < 1) {
1440                 if (option_debug)
1441                         ast_log(LOG_DEBUG, "Calculated ms is %d\n", ms);
1442                 /* Don't deliver it more than 4 ms late */
1443                 if ((ms > -4) || (fr->f->frametype != AST_FRAME_VOICE)) {
1444                         __do_deliver(fr);
1445                 } else {
1446                         if (option_debug)
1447                                 ast_log(LOG_DEBUG, "Dropping voice packet since %d ms is, too old\n", ms);
1448                         /* Free the packet */
1449                         ast_frfree(fr->f);
1450                         /* And our iax frame */
1451                         ast_iax_frame_free(fr);
1452                 }
1453         } else {
1454                 if (option_debug)
1455                         ast_log(LOG_DEBUG, "Scheduling delivery in %d ms\n", ms);
1456                 fr->retrans = ast_sched_add(sched, ms, do_deliver, fr);
1457         }
1458         return 0;
1459 }
1460
1461 static int iax_transmit(struct ast_iax_frame *fr)
1462 {
1463         /* Lock the queue and place this packet at the end */
1464         fr->next = NULL;
1465         fr->prev = NULL;
1466         /* By setting this to 0, the network thread will send it for us, and
1467            queue retransmission if necessary */
1468         fr->sentyet = 0;
1469         ast_mutex_lock(&iaxq.lock);
1470         if (!iaxq.head) {
1471                 /* Empty queue */
1472                 iaxq.head = fr;
1473                 iaxq.tail = fr;
1474         } else {
1475                 /* Double link */
1476                 iaxq.tail->next = fr;
1477                 fr->prev = iaxq.tail;
1478                 iaxq.tail = fr;
1479         }
1480         iaxq.count++;
1481         ast_mutex_unlock(&iaxq.lock);
1482         /* Wake up the network thread */
1483         pthread_kill(netthreadid, SIGURG);
1484         return 0;
1485 }
1486
1487
1488
1489 static int iax_digit(struct ast_channel *c, char digit)
1490 {
1491         return send_command(c->pvt->pvt, AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
1492 }
1493
1494 static int iax_sendtext(struct ast_channel *c, char *text)
1495 {
1496
1497         return send_command(c->pvt->pvt, AST_FRAME_TEXT,
1498                 0, 0, text, strlen(text) + 1, -1);
1499 }
1500
1501 static int iax_sendimage(struct ast_channel *c, struct ast_frame *img)
1502 {
1503         return send_command(c->pvt->pvt, AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
1504 }
1505
1506 static int iax_sendhtml(struct ast_channel *c, int subclass, char *data, int datalen)
1507 {
1508         return send_command(c->pvt->pvt, AST_FRAME_HTML, subclass, 0, data, datalen, -1);
1509 }
1510
1511 static int iax_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
1512 {
1513         struct chan_iax_pvt *pvt = newchan->pvt->pvt;
1514         pvt->owner = newchan;
1515         return 0;
1516 }
1517
1518 #ifdef MYSQL_FRIENDS
1519
1520 static void mysql_update_peer(char *peer, struct sockaddr_in *sin)
1521 {
1522         if (mysql && (strlen(peer) < 128)) {
1523                 char query[512];
1524                 char *name;
1525                 time_t nowtime;
1526                 name = alloca(strlen(peer) * 2 + 1);
1527                 time(&nowtime);
1528                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1529                 snprintf(query, sizeof(query), "UPDATE iax1friends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\" WHERE name=\"%s\"",
1530                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), nowtime, name);
1531                 ast_mutex_lock(&mysqllock);
1532                 if (mysql_real_query(mysql, query, strlen(query)))
1533                         ast_log(LOG_WARNING, "Unable to update database\n");
1534
1535                 ast_mutex_unlock(&mysqllock);
1536         }
1537 }
1538
1539 static struct iax_peer *mysql_peer(char *peer)
1540 {
1541         struct iax_peer *p;
1542         int success = 0;
1543
1544         p = malloc(sizeof(struct iax_peer));
1545         memset(p, 0, sizeof(struct iax_peer));
1546         if (mysql && (strlen(peer) < 128)) {
1547                 char query[512];
1548                 char *name;
1549                 int numfields, x;
1550                 int port;
1551                 time_t regseconds, nowtime;
1552                 MYSQL_RES *result;
1553                 MYSQL_FIELD *fields;
1554                 MYSQL_ROW rowval;
1555                 name = alloca(strlen(peer) * 2 + 1);
1556                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1557                 snprintf(query, sizeof(query), "SELECT * FROM iax1friends WHERE name=\"%s\"", name);
1558                 ast_mutex_lock(&mysqllock);
1559                 mysql_query(mysql, query);
1560                 if ((result = mysql_store_result(mysql))) {
1561                         if ((rowval = mysql_fetch_row(result))) {
1562                                 numfields = mysql_num_fields(result);
1563                                 fields = mysql_fetch_fields(result);
1564                                 success = 1;
1565                                 for (x=0;x<numfields;x++) {
1566                                         if (rowval[x]) {
1567                                                 if (!strcasecmp(fields[x].name, "secret")) {
1568                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1569                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1570                                                         strncpy(p->context, rowval[x], sizeof(p->context) - 1);
1571                                                 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
1572                                                         inet_aton(rowval[x], &p->addr.sin_addr);
1573                                                 } else if (!strcasecmp(fields[x].name, "port")) {
1574                                                         if (sscanf(rowval[x], "%i", &port) != 1)
1575                                                                 port = 0;
1576                                                         p->addr.sin_port = htons(port);
1577                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1578                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
1579                                                                 regseconds = 0;
1580                                                 }
1581                                         }
1582                                 }
1583                                 time(&nowtime);
1584                                 if ((nowtime - regseconds) > AST_DEFAULT_REG_EXPIRE)
1585                                         memset(&p->addr, 0, sizeof(p->addr));
1586                         }
1587                 }
1588                 ast_mutex_unlock(&mysqllock);
1589         }
1590         if (!success) {
1591                 free(p);
1592                 p = NULL;
1593         } else {
1594                 strncpy(p->name, peer, sizeof(p->name) - 1);
1595                 p->dynamic = 1;
1596                 p->delme = 1;
1597                 p->expire = -1;
1598                 p->capability = iax_capability;
1599                 strcpy(p->methods, "md5,plaintext");
1600         }
1601         return p;
1602 }
1603
1604 static struct iax_user *mysql_user(char *user)
1605 {
1606         struct iax_user *p;
1607         struct iax_context *con;
1608         int success = 0;
1609
1610         p = malloc(sizeof(struct iax_user));
1611         memset(p, 0, sizeof(struct iax_user));
1612         con = malloc(sizeof(struct iax_context));
1613         memset(con, 0, sizeof(struct iax_context));
1614         strcpy(con->context, "default");
1615         p->contexts = con;
1616         if (mysql && (strlen(user) < 128)) {
1617                 char query[512];
1618                 char *name;
1619                 int numfields, x;
1620                 MYSQL_RES *result;
1621                 MYSQL_FIELD *fields;
1622                 MYSQL_ROW rowval;
1623                 name = alloca(strlen(user) * 2 + 1);
1624                 mysql_real_escape_string(mysql, name, user, strlen(user));
1625                 snprintf(query, sizeof(query), "SELECT * FROM iax1friends WHERE name=\"%s\"", name);
1626                 ast_mutex_lock(&mysqllock);
1627                 mysql_query(mysql, query);
1628                 if ((result = mysql_store_result(mysql))) {
1629                         if ((rowval = mysql_fetch_row(result))) {
1630                                 numfields = mysql_num_fields(result);
1631                                 fields = mysql_fetch_fields(result);
1632                                 success = 1;
1633                                 for (x=0;x<numfields;x++) {
1634                                         if (rowval[x]) {
1635                                                 if (!strcasecmp(fields[x].name, "secret")) {
1636                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1637                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1638                                                         strncpy(p->contexts->context, rowval[x], sizeof(p->contexts->context) - 1);
1639                                                 }
1640                                         }
1641                                 }
1642                         }
1643                 }
1644                 ast_mutex_unlock(&mysqllock);
1645         }
1646         if (!success) {
1647                 if (p->contexts)
1648                         free(p->contexts);
1649                 free(p);
1650                 p = NULL;
1651         } else {
1652                 strncpy(p->name, user, sizeof(p->name) - 1);
1653                 p->delme = 1;
1654                 strcpy(p->methods, "md5,plaintext");
1655         }
1656         return p;
1657 }
1658 #endif /* MYSQL_FRIENDS */
1659
1660 static int create_addr(struct sockaddr_in *sin, int *capability, int *sendani, int *maxtime, char *peer, char *context)
1661 {
1662         struct hostent *hp;
1663         struct iax_peer *p;
1664         int found=0;
1665         if (sendani)
1666                 *sendani = 0;
1667         if (maxtime)
1668                 *maxtime = 0;
1669         sin->sin_family = AF_INET;
1670         ast_mutex_lock(&peerl.lock);
1671         p = peerl.peers;
1672         while(p) {
1673                 if (!strcasecmp(p->name, peer)) {
1674                         break;
1675                 }
1676                 p = p->next;
1677         }
1678 #ifdef MYSQL_FRIENDS
1679         if (!p)
1680                 p = mysql_peer(peer);
1681 #endif
1682         if (p) {
1683                 found++;
1684                 if (capability)
1685                         *capability = p->capability;
1686                 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1687                         (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
1688                         if (sendani)
1689                                 *sendani = p->sendani;          /* Whether we transmit ANI */
1690                         if (maxtime)
1691                                 *maxtime = p->maxms;            /* Max time they should take */
1692                         if (context)
1693                                 strncpy(context, p->context, AST_MAX_EXTENSION - 1);
1694                         if (p->addr.sin_addr.s_addr) {
1695                                 sin->sin_addr = p->addr.sin_addr;
1696                                 sin->sin_port = p->addr.sin_port;
1697                         } else {
1698                                 sin->sin_addr = p->defaddr.sin_addr;
1699                                 sin->sin_port = p->defaddr.sin_port;
1700                         }
1701                 } else {
1702                         if (p->delme)
1703                                 free(p);
1704                         p = NULL;
1705                 }
1706         }
1707         ast_mutex_unlock(&peerl.lock);
1708         if (!p && !found) {
1709                 hp = gethostbyname(peer);
1710                 if (hp) {
1711                         memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
1712                         sin->sin_port = htons(AST_DEFAULT_IAX_PORTNO);
1713                         return 0;
1714                 } else {
1715                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1716                         return -1;
1717                 }
1718         } else if (!p)
1719                 return -1;
1720         if (p->delme)
1721                 free(p);
1722         return 0;
1723 }
1724
1725 static int auto_congest(void *nothing)
1726 {
1727         int callno = (int)(long)(nothing);
1728         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
1729         ast_mutex_lock(&iaxsl[callno]);
1730         if (iaxs[callno]) {
1731                 iaxs[callno]->initid = -1;
1732                 iax_queue_frame(callno, &f);
1733                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
1734         }
1735         ast_mutex_unlock(&iaxsl[callno]);
1736         return 0;
1737 }
1738
1739 static int iax_call(struct ast_channel *c, char *dest, int timeout)
1740 {
1741         struct sockaddr_in sin;
1742         char host[256];
1743         char *rdest;
1744         char *rcontext;
1745         char *username;
1746         char *secret = NULL;
1747         char *hname;
1748         char requeststr[256] = "";
1749         char myrdest [5] = "s";
1750         char context[AST_MAX_EXTENSION] ="";
1751         char *portno = NULL;
1752         struct chan_iax_pvt *p = c->pvt->pvt;
1753         char *stringp=NULL;
1754         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
1755                 ast_log(LOG_WARNING, "Line is already in use (%s)?\n", c->name);
1756                 return -1;
1757         }
1758         strncpy(host, dest, sizeof(host)-1);
1759         stringp=host;
1760         strsep(&stringp, "/");
1761         /* If no destination extension specified, use 's' */
1762         rdest = strsep(&stringp, "/");
1763         if (!rdest)
1764                 rdest = myrdest;
1765         stringp=rdest;
1766         strsep(&stringp, "@");
1767         rcontext = strsep(&stringp, "@");
1768         stringp=host;
1769         strsep(&stringp, "@");
1770         username = strsep(&stringp, "@");
1771         if (username) {
1772                 /* Really the second argument is the host, not the username */
1773                 hname = username;
1774                 username = host;
1775         } else {
1776                 hname = host;
1777         }
1778         if (username) {
1779                 stringp=username;
1780                 username = strsep(&stringp, ":");
1781                 secret = strsep(&stringp, ":");
1782         }
1783         stringp=hname;
1784         if (strsep(&stringp, ":")) {
1785                 stringp=hname;
1786                 strsep(&stringp, ":");
1787                 portno = strsep(&stringp, ":");
1788         }
1789         if (create_addr(&sin, NULL, NULL, NULL, hname, context)) {
1790                 ast_log(LOG_WARNING, "No address associated with '%s'\n", hname);
1791                 return -1;
1792         }
1793         /* Keep track of the context for outgoing calls too */
1794         strncpy(c->context, context, sizeof(c->context) - 1);
1795         if (portno) {
1796                 sin.sin_port = htons(atoi(portno));
1797         }
1798         /* Now we build our request string */
1799 #define MYSNPRINTF snprintf(requeststr + strlen(requeststr), sizeof(requeststr) - strlen(requeststr),
1800 #define MYSNPRINTF2 snprintf(requeststr + strlen(requeststr), reqsize - strlen(requeststr),
1801         MYSNPRINTF "exten=%s;", rdest);
1802         if (c->callerid)
1803                 MYSNPRINTF "callerid=%s;", c->callerid);
1804         if (p->sendani && c->ani)
1805                 MYSNPRINTF "ani=%s;", c->ani);
1806         if (c->language && strlen(c->language))
1807                 MYSNPRINTF "language=%s;", c->language);
1808         if (c->dnid)
1809                 MYSNPRINTF "dnid=%s;", c->dnid);
1810         if (rcontext)
1811                 MYSNPRINTF "context=%s;", rcontext);
1812         if (username)
1813                 MYSNPRINTF "username=%s;", username);
1814         if (secret) {
1815                 if (secret[0] == '[') {
1816                         /* This is an RSA key, not a normal secret */
1817                         strncpy(p->outkey, secret + 1, sizeof(p->secret)-1);
1818                         if (strlen(p->outkey)) {
1819                                 p->outkey[strlen(p->outkey) - 1] = '\0';
1820                         }
1821                 } else
1822                         strncpy(p->secret, secret, sizeof(p->secret)-1);
1823         }
1824         MYSNPRINTF "formats=%d;", c->nativeformats);
1825         MYSNPRINTF "capability=%d;", p->capability);
1826         MYSNPRINTF "version=%d;", AST_IAX_PROTO_VERSION);
1827         MYSNPRINTF "adsicpe=%d;", c->adsicpe);
1828         /* Trim the trailing ";" */
1829         if (strlen(requeststr))
1830                 requeststr[strlen(requeststr) - 1] = '\0';
1831         /* Transmit the string in a "NEW" request */
1832         if (option_verbose > 2)
1833                 ast_verbose(VERBOSE_PREFIX_3 "Calling using options '%s'\n", requeststr);
1834         if (p->maxtime) {
1835                 /* Initialize pingtime and auto-congest time */
1836                 p->pingtime = p->maxtime / 2;
1837                 p->initid = ast_sched_add(sched, p->maxtime * 2, auto_congest, (void *)p->callno);
1838         }
1839         send_command(p, AST_FRAME_IAX,
1840                 AST_IAX_COMMAND_NEW, 0, requeststr, strlen(requeststr) + 1, -1);
1841         ast_setstate(c, AST_STATE_RINGING);
1842         return 0;
1843 }
1844
1845 static int iax_hangup(struct ast_channel *c)
1846 {
1847         struct chan_iax_pvt *pvt = c->pvt->pvt;
1848         int alreadygone;
1849         int callno;
1850         if (pvt) {
1851                 callno = pvt->callno;
1852                 ast_mutex_lock(&iaxsl[callno]);
1853                 ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
1854                 alreadygone = pvt->alreadygone;
1855                 /* Send the hangup unless we have had a transmission error or are already gone */
1856                 if (!pvt->error && !alreadygone)
1857                         send_command_final(pvt, AST_FRAME_IAX, AST_IAX_COMMAND_HANGUP, 0, NULL, 0, -1);
1858                 /* Explicitly predestroy it */
1859                 iax_predestroy_nolock(callno);
1860                 /* If we were already gone to begin with, destroy us now */
1861                 if (alreadygone) {
1862                         ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
1863                         iax_destroy_nolock(callno);
1864                 }
1865                 ast_mutex_unlock(&iaxsl[callno]);
1866         }
1867         if (option_verbose > 2)
1868                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
1869         return 0;
1870 }
1871
1872 static int iax_setoption(struct ast_channel *c, int option, void *data, int datalen)
1873 {
1874         struct ast_option_header *h;
1875         int res;
1876         h = malloc(datalen + sizeof(struct ast_option_header));
1877         if (h) {
1878                 h->flag = AST_OPTION_FLAG_REQUEST;
1879                 h->option = htons(option);
1880                 memcpy(h->data, data, datalen);
1881                 res = send_command((struct chan_iax_pvt *)c->pvt->pvt, AST_FRAME_CONTROL,
1882                         AST_CONTROL_OPTION, 0, (char *)h, datalen + sizeof(struct ast_option_header), -1);
1883                 free(h);
1884                 return res;
1885         } else
1886                 ast_log(LOG_WARNING, "Out of memory\n");
1887         return -1;
1888 }
1889 static struct ast_frame *iax_read(struct ast_channel *c)
1890 {
1891         static struct ast_frame f = { AST_FRAME_NULL, };
1892         ast_log(LOG_NOTICE, "I should never be called!\n");
1893         return &f;
1894 }
1895
1896 static int iax_start_transfer(struct ast_channel *c0, struct ast_channel *c1)
1897 {
1898         int res;
1899         char req0[256];
1900         char req1[256];
1901         struct chan_iax_pvt *p0 = c0->pvt->pvt;
1902         struct chan_iax_pvt *p1 = c1->pvt->pvt;
1903         snprintf(req0, sizeof(req0), "remip=%s;remport=%d;remcall=%d;", inet_ntoa(p1->addr.sin_addr), ntohs(p1->addr.sin_port), p1->peercallno);
1904         snprintf(req1, sizeof(req1), "remip=%s;remport=%d;remcall=%d;", inet_ntoa(p0->addr.sin_addr), ntohs(p0->addr.sin_port), p0->peercallno);
1905         res = send_command(p0, AST_FRAME_IAX, AST_IAX_COMMAND_TXREQ, 0, req0, strlen(req0) + 1, -1);
1906         if (res)
1907                 return -1;
1908         res = send_command(p1, AST_FRAME_IAX, AST_IAX_COMMAND_TXREQ, 0, req1, strlen(req1) + 1, -1);
1909         if (res)
1910                 return -1;
1911         p0->transferring = TRANSFER_BEGIN;
1912         p1->transferring = TRANSFER_BEGIN;
1913         return 0;
1914 }
1915
1916 static int iax_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1917 {
1918         struct ast_channel *cs[3];
1919         struct ast_channel *who;
1920         int to = -1;
1921         int res;
1922         int transferstarted=0;
1923         struct ast_frame *f;
1924         struct chan_iax_pvt *p0 = c0->pvt->pvt;
1925         struct chan_iax_pvt *p1 = c1->pvt->pvt;
1926
1927         /* Put them in native bridge mode */
1928         p0->bridgecallno = p1->callno;
1929         p1->bridgecallno = p0->callno;
1930
1931         /* If not, try to bridge until we can execute a transfer, if we can */
1932         cs[0] = c0;
1933         cs[1] = c1;
1934         for (/* ever */;;) {
1935                 /* Check in case we got masqueraded into */
1936                 if ((c0->type != type) || (c1->type != type)) {
1937                         if (option_verbose > 2)
1938                                 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
1939                         return -2;
1940                 }
1941                 if (c0->nativeformats != c1->nativeformats) {
1942                         ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs, can't native bridge...\n");
1943                         return -2;
1944                 }
1945                 if (!transferstarted) {
1946                         /* Try the transfer */
1947                         if (iax_start_transfer(c0, c1))
1948                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
1949                         transferstarted = 1;
1950                 }
1951
1952                 if ((p0->transferring == TRANSFER_RELEASED) && (p1->transferring == TRANSFER_RELEASED)) {
1953                         /* Call has been transferred.  We're no longer involved */
1954                         sleep(1);
1955                         c0->_softhangup |= AST_SOFTHANGUP_DEV;
1956                         c1->_softhangup |= AST_SOFTHANGUP_DEV;
1957                         *fo = NULL;
1958                         *rc = c0;
1959                         res = 0;
1960                         break;
1961                 }
1962                 to = 1000;
1963                 who = ast_waitfor_n(cs, 2, &to);
1964                 if (!who) {
1965                         continue;
1966                 }
1967                 f = ast_read(who);
1968                 if (!f) {
1969                         *fo = NULL;
1970                         *rc = who;
1971                         res = 0;
1972                         break;
1973                 }
1974                 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
1975                         *fo = f;
1976                         *rc = who;
1977                         res =  0;
1978                         break;
1979                 }
1980                 if ((f->frametype == AST_FRAME_VOICE) ||
1981                         (f->frametype == AST_FRAME_TEXT) ||
1982                         (f->frametype == AST_FRAME_VIDEO) ||
1983                         (f->frametype == AST_FRAME_IMAGE) ||
1984                         (f->frametype == AST_FRAME_DTMF)) {
1985                         if ((f->frametype == AST_FRAME_DTMF) &&
1986                                 (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
1987                                 if ((who == c0)) {
1988                                         if  ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
1989                                                 *rc = c0;
1990                                                 *fo = f;
1991                                                 /* Take out of conference mode */
1992                                                 res = 0;
1993                                                 break;
1994                                         } else
1995                                                 goto tackygoto;
1996                                 } else
1997                                 if ((who == c1)) {
1998                                         if (flags & AST_BRIDGE_DTMF_CHANNEL_1) {
1999                                                 *rc = c1;
2000                                                 *fo = f;
2001                                                 res =  0;
2002                                                 break;
2003                                         } else
2004                                                 goto tackygoto;
2005                                 }
2006                         } else {
2007 #if 0
2008                                 ast_log(LOG_DEBUG, "Read from %s\n", who->name);
2009                                 if (who == last)
2010                                         ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
2011                                 last = who;
2012 #endif
2013 tackygoto:
2014                                 if (who == c0)
2015                                         ast_write(c1, f);
2016                                 else
2017                                         ast_write(c0, f);
2018                         }
2019                         ast_frfree(f);
2020                 } else
2021                         ast_frfree(f);
2022                 /* Swap who gets priority */
2023                 cs[2] = cs[0];
2024                 cs[0] = cs[1];
2025                 cs[1] = cs[2];
2026         }
2027         p0->bridgecallno = -1;
2028         p1->bridgecallno = -1;
2029         return res;
2030 }
2031
2032 static int iax_answer(struct ast_channel *c)
2033 {
2034         struct chan_iax_pvt *pvt = c->pvt->pvt;
2035         if (option_debug)
2036                 ast_log(LOG_DEBUG, "Answering\n");
2037         return send_command(pvt, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
2038 }
2039
2040 static int iax_indicate(struct ast_channel *c, int condition)
2041 {
2042         struct chan_iax_pvt *pvt = c->pvt->pvt;
2043         if (option_debug)
2044                 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
2045         return send_command(pvt, AST_FRAME_CONTROL, condition, 0, NULL, 0, -1);
2046 }
2047
2048
2049 static int iax_write(struct ast_channel *c, struct ast_frame *f);
2050
2051 static int iax_getpeername(struct sockaddr_in sin, char *host, int len)
2052 {
2053         struct iax_peer *peer;
2054         int res = 0;
2055         ast_mutex_lock(&peerl.lock);
2056         peer = peerl.peers;
2057         while(peer) {
2058                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
2059                                 (peer->addr.sin_port == sin.sin_port)) {
2060                                         strncpy(host, peer->name, len-1);
2061                                         res = 1;
2062                                         break;
2063                 }
2064                 peer = peer->next;
2065         }
2066         ast_mutex_unlock(&peerl.lock);
2067         return res;
2068 }
2069
2070 static struct ast_channel *ast_iax_new(struct chan_iax_pvt *i, int state, int capability)
2071 {
2072         char host[256];
2073         struct ast_channel *tmp;
2074         tmp = ast_channel_alloc(1);
2075         if (tmp) {
2076                 if (!iax_getpeername(i->addr, host, sizeof(host)))
2077                         snprintf(host, sizeof(host), "%s:%d", inet_ntoa(i->addr.sin_addr), ntohs(i->addr.sin_port));
2078                 if (strlen(i->username))
2079                         snprintf(tmp->name, sizeof(tmp->name), "IAX[%s@%s]/%d", i->username, host, i->callno);
2080                 else
2081                         snprintf(tmp->name, sizeof(tmp->name), "IAX[%s]/%d", host, i->callno);
2082                 tmp->type = type;
2083                 /* We can support any format by default, until we get restricted */
2084                 tmp->nativeformats = capability;
2085                 tmp->readformat = 0;
2086                 tmp->writeformat = 0;
2087                 tmp->pvt->pvt = i;
2088                 tmp->pvt->send_digit = iax_digit;
2089                 tmp->pvt->send_text = iax_sendtext;
2090                 tmp->pvt->send_image = iax_sendimage;
2091                 tmp->pvt->send_html = iax_sendhtml;
2092                 tmp->pvt->call = iax_call;
2093                 tmp->pvt->hangup = iax_hangup;
2094                 tmp->pvt->answer = iax_answer;
2095                 tmp->pvt->read = iax_read;
2096                 tmp->pvt->write = iax_write;
2097                 tmp->pvt->indicate = iax_indicate;
2098                 tmp->pvt->setoption = iax_setoption;
2099                 tmp->pvt->bridge = iax_bridge;
2100                 if (strlen(i->callerid))
2101                         tmp->callerid = strdup(i->callerid);
2102                 if (strlen(i->ani))
2103                         tmp->ani = strdup(i->ani);
2104                 if (strlen(i->language))
2105                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2106                 if (strlen(i->dnid))
2107                         tmp->dnid = strdup(i->dnid);
2108                 if (strlen(i->accountcode))
2109                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2110                 if (i->amaflags)
2111                         tmp->amaflags = i->amaflags;
2112                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2113                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2114                 tmp->adsicpe = i->peeradsicpe;
2115                 tmp->pvt->fixup = iax_fixup;
2116                 i->owner = tmp;
2117                 i->capability = capability;
2118                 ast_setstate(tmp, state);
2119                 ast_mutex_lock(&usecnt_lock);
2120                 usecnt++;
2121                 ast_mutex_unlock(&usecnt_lock);
2122                 ast_update_use_count();
2123                 if (state != AST_STATE_DOWN) {
2124                         if (ast_pbx_start(tmp)) {
2125                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2126                                 ast_hangup(tmp);
2127                                 tmp = NULL;
2128                         }
2129                 }
2130         }
2131         return tmp;
2132 }
2133
2134 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts)
2135 {
2136         struct timeval tv;
2137         unsigned int ms;
2138         if (!p->offset.tv_sec && !p->offset.tv_usec)
2139                 gettimeofday(&p->offset, NULL);
2140         /* If the timestamp is specified, just send it as is */
2141         if (ts)
2142                 return ts;
2143         gettimeofday(&tv, NULL);
2144         ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
2145         /* We never send the same timestamp twice, so fudge a little if we must */
2146         if (ms <= p->lastsent)
2147                 ms = p->lastsent + 1;
2148         p->lastsent = ms;
2149         return ms;
2150 }
2151
2152 #ifdef BRIDGE_OPTIMIZATION
2153 static unsigned int calc_fakestamp(struct chan_iax_pvt *p1, struct chan_iax_pvt *p2, unsigned int fakets)
2154 {
2155         int ms;
2156         /* Receive from p1, send to p2 */
2157
2158         /* Setup rxcore if necessary on outgoing channel */
2159         if (!p1->rxcore.tv_sec && !p1->rxcore.tv_usec)
2160                 gettimeofday(&p1->rxcore, NULL);
2161
2162         /* Setup txcore if necessary on outgoing channel */
2163         if (!p2->offset.tv_sec && !p2->offset.tv_usec)
2164                 gettimeofday(&p2->offset, NULL);
2165
2166         /* Now, ts is the timestamp of the original packet in the orignal context.
2167            Adding rxcore to it gives us when we would want the packet to be delivered normally.
2168            Subtracting txcore of the outgoing channel gives us what we'd expect */
2169
2170         ms = (p1->rxcore.tv_sec - p2->offset.tv_sec) * 1000 + (p1->rxcore.tv_usec - p1->offset.tv_usec) / 1000;
2171         fakets += ms;
2172         if (fakets <= p2->lastsent)
2173                 fakets = p2->lastsent + 1;
2174         p2->lastsent = fakets;
2175         return fakets;
2176 }
2177 #endif
2178
2179 static unsigned int calc_rxstamp(struct chan_iax_pvt *p)
2180 {
2181         /* Returns where in "receive time" we are */
2182         struct timeval tv;
2183         unsigned int ms;
2184         /* Setup rxcore if necessary */
2185         if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
2186                 gettimeofday(&p->rxcore, NULL);
2187
2188         gettimeofday(&tv, NULL);
2189         ms = (tv.tv_sec - p->rxcore.tv_sec) * 1000 + (tv.tv_usec - p->rxcore.tv_usec) / 1000;
2190         return ms;
2191 }
2192
2193 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
2194 {
2195         /* Queue a packet for delivery on a given private structure.  Use "ts" for
2196            timestamp, or calculate if ts is 0.  Send immediately without retransmission
2197            or delayed, with retransmission */
2198         struct ast_iax_full_hdr *fh;
2199         struct ast_iax_mini_hdr *mh;
2200         struct ast_iax_frame *fr, fr2;
2201         int res;
2202         unsigned int lastsent;
2203         /* Allocate an ast_iax_frame */
2204         if (now)
2205                 fr = &fr2;
2206         else
2207                 fr = ast_iax_frame_new(DIRECTION_OUTGRESS);
2208         if (!fr) {
2209                 ast_log(LOG_WARNING, "Out of memory\n");
2210                 return -1;
2211         }
2212         if (!pvt) {
2213                 ast_log(LOG_WARNING, "No private structure for packet (%d)?\n", fr->callno);
2214                 if (!now)
2215                         ast_iax_frame_free(fr);
2216                 return -1;
2217         }
2218         /* Isolate our frame for transmission */
2219         fr->f = ast_frdup(f);
2220
2221         if (!fr->f) {
2222                 ast_log(LOG_WARNING, "Out of memory\n");
2223                 if (!now)
2224                         ast_iax_frame_free(fr);
2225                 return -1;
2226         }
2227         if (fr->f->offset < sizeof(struct ast_iax_full_hdr)) {
2228                 ast_log(LOG_WARNING, "Packet from '%s' not friendly\n", fr->f->src);
2229                 free(fr);
2230                 return -1;
2231         }
2232         lastsent = pvt->lastsent;
2233         fr->ts = calc_timestamp(pvt, ts);
2234         if (!fr->ts) {
2235                 ast_log(LOG_WARNING, "timestamp is 0?\n");
2236                 if (!now)
2237                         ast_iax_frame_free(fr);
2238                 return -1;
2239         }
2240         fr->callno = pvt->callno;
2241         fr->transfer = transfer;
2242         fr->final = final;
2243         if (((fr->ts & 0xFFFF0000L) != (lastsent & 0xFFFF0000L))
2244                 /* High two bits of timestamp differ */ ||
2245             (fr->f->frametype != AST_FRAME_VOICE)
2246                 /* or not a voice frame */ ||
2247                 (fr->f->subclass != pvt->svoiceformat)
2248                 /* or new voice format */ ) {
2249                 /* We need a full frame */
2250                 if (seqno > -1)
2251                         fr->seqno = seqno;
2252                 else
2253                         fr->seqno = pvt->oseqno++;
2254                 fh = (struct ast_iax_full_hdr *)(fr->f->data - sizeof(struct ast_iax_full_hdr));
2255                 fh->callno = htons(fr->callno | AST_FLAG_FULL);
2256                 fh->ts = htonl(fr->ts);
2257                 fh->seqno = htons(fr->seqno);
2258                 fh->type = fr->f->frametype & 0xFF;
2259                 fh->csub = compress_subclass(fr->f->subclass);
2260                 if (transfer) {
2261                         fh->dcallno = htons(pvt->transfercallno);
2262                 } else
2263                         fh->dcallno = htons(pvt->peercallno);
2264                 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_full_hdr);
2265                 fr->data = fh;
2266                 fr->retries = 0;
2267                 /* Retry after 2x the ping time has passed */
2268                 fr->retrytime = pvt->pingtime * 2;
2269                 if (fr->retrytime < MIN_RETRY_TIME)
2270                         fr->retrytime = MIN_RETRY_TIME;
2271                 if (fr->retrytime > MAX_RETRY_TIME)
2272                         fr->retrytime = MAX_RETRY_TIME;
2273                 /* Acks' don't get retried */
2274                 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == AST_IAX_COMMAND_ACK))
2275                         fr->retries = -1;
2276                 if (f->frametype == AST_FRAME_VOICE) {
2277                         pvt->svoiceformat = f->subclass;
2278                 }
2279                 if (now) {
2280                         res = send_packet(fr);
2281                         ast_frfree(fr->f);
2282                 } else
2283                         res = iax_transmit(fr);
2284         } else {
2285                 /* Mini-frames have no sequence number */
2286                 fr->seqno = -1;
2287                 /* Mini frame will do */
2288                 mh = (struct ast_iax_mini_hdr *)(fr->f->data - sizeof(struct ast_iax_mini_hdr));
2289                 mh->callno = htons(fr->callno);
2290                 mh->ts = htons(fr->ts & 0xFFFF);
2291                 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_mini_hdr);
2292                 fr->data = mh;
2293                 fr->retries = -1;
2294                 if (now) {
2295                         res = send_packet(fr);
2296                         ast_frfree(fr->f);
2297                 } else
2298                         res = iax_transmit(fr);
2299         }
2300         return res;
2301 }
2302
2303
2304
2305 static int iax_show_users(int fd, int argc, char *argv[])
2306 {
2307 #define FORMAT "%-15.15s  %-15.15s  %-15.15s  %-15.15s  %-5.5s\n"
2308         struct iax_user *user;
2309         if (argc != 3)
2310                 return RESULT_SHOWUSAGE;
2311         ast_mutex_lock(&userl.lock);
2312         ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
2313         for(user=userl.users;user;user=user->next) {
2314                 ast_cli(fd, FORMAT, user->name, user->secret, user->methods,
2315                                 user->contexts ? user->contexts->context : context,
2316                                 user->ha ? "Yes" : "No");
2317         }
2318         ast_mutex_unlock(&userl.lock);
2319         return RESULT_SUCCESS;
2320 #undef FORMAT
2321 }
2322
2323 static int iax_show_peers(int fd, int argc, char *argv[])
2324 {
2325 #define FORMAT2 "%-15.15s  %-15.15s %s  %-15.15s  %-8s  %-10s\n"
2326 #define FORMAT "%-15.15s  %-15.15s %s  %-15.15s  %-8d  %-10s\n"
2327         struct iax_peer *peer;
2328         char name[256] = "";
2329         if (argc != 3)
2330                 return RESULT_SHOWUSAGE;
2331         ast_mutex_lock(&peerl.lock);
2332         ast_cli(fd, FORMAT2, "Name/Username", "Host", "   ", "Mask", "Port", "Status");
2333         for (peer = peerl.peers;peer;peer = peer->next) {
2334                 char nm[20];
2335                 char status[20];
2336                 if (strlen(peer->username))
2337                         snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
2338                 else
2339                         strncpy(name, peer->name, sizeof(name) - 1);
2340                 if (peer->maxms) {
2341                         if (peer->lastms < 0)
2342                                 strcpy(status, "UNREACHABLE");
2343                         else if (peer->lastms > peer->maxms)
2344                                 snprintf(status, sizeof(status), "LAGGED (%d ms)", peer->lastms);
2345                         else if (peer->lastms)
2346                                 snprintf(status, sizeof(status), "OK (%d ms)", peer->lastms);
2347                         else
2348                                 strcpy(status, "UNKNOWN");
2349                 } else
2350                         strcpy(status, "Unmonitored");
2351                 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm)-1);
2352                 ast_cli(fd, FORMAT, name,
2353                                         peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Unspecified)",
2354                                         peer->dynamic ? "(D)" : "(S)",
2355                                         nm,
2356                                         ntohs(peer->addr.sin_port), status);
2357         }
2358         ast_mutex_unlock(&peerl.lock);
2359         return RESULT_SUCCESS;
2360 #undef FORMAT
2361 #undef FORMAT2
2362 }
2363
2364 /* JDG: callback to display iax peers in manager */
2365 static int manager_iax_show_peers( struct mansession *s, struct message *m )
2366 {
2367         char *a[] = { "iax", "show", "users" };
2368         int ret;
2369         ret = iax_show_peers( s->fd, 3, a );
2370         ast_cli( s->fd, "\r\n" );
2371         return ret;
2372 } /* /JDG */
2373
2374 static char *regstate2str(int regstate)
2375 {
2376         switch(regstate) {
2377         case REG_STATE_UNREGISTERED:
2378                 return "Unregistered";
2379         case REG_STATE_REGSENT:
2380                 return "Request Sent";
2381         case REG_STATE_AUTHSENT:
2382                 return "Auth. Sent";
2383         case REG_STATE_REGISTERED:
2384                 return "Registered";
2385         case REG_STATE_REJECTED:
2386                 return "Rejected";
2387         case REG_STATE_TIMEOUT:
2388                 return "Timeout";
2389         case REG_STATE_NOAUTH:
2390                 return "No Authentication";
2391         default:
2392                 return "Unknown";
2393         }
2394 }
2395
2396 static int iax_show_registry(int fd, int argc, char *argv[])
2397 {
2398 #define FORMAT2 "%-20.20s  %-10.10s  %-20.20s %8.8s  %s\n"
2399 #define FORMAT "%-20.20s  %-10.10s  %-20.20s %8d  %s\n"
2400         struct iax_registry *reg;
2401         char host[80];
2402         char perceived[80];
2403         if (argc != 3)
2404                 return RESULT_SHOWUSAGE;
2405         ast_mutex_lock(&peerl.lock);
2406         ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State");
2407         for (reg = registrations;reg;reg = reg->next) {
2408                 snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port));
2409                 if (reg->us.sin_addr.s_addr)
2410                         snprintf(perceived, sizeof(perceived), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
2411                 else
2412                         strcpy(perceived, "<Unregistered>");
2413                 ast_cli(fd, FORMAT, host,
2414                                         reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
2415         }
2416         ast_mutex_unlock(&peerl.lock);
2417         return RESULT_SUCCESS;
2418 #undef FORMAT
2419 #undef FORMAT2
2420 }
2421
2422 static int iax_show_channels(int fd, int argc, char *argv[])
2423 {
2424 #define FORMAT2 "%-15.15s  %-10.10s  %-11.11s  %-11.11s  %-7.7s  %-6.6s  %s\n"
2425 #define FORMAT  "%-15.15s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  %-5.5dms  %-4.4dms  %-6.6s\n"
2426         int x;
2427         int numchans = 0;
2428         if (argc != 3)
2429                 return RESULT_SHOWUSAGE;
2430         ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
2431         for (x=0;x<AST_IAX_MAX_CALLS;x++) {
2432                 ast_mutex_lock(&iaxsl[x]);
2433                 if (iaxs[x]) {
2434                         ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
2435                                                 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
2436                                                 iaxs[x]->callno, iaxs[x]->peercallno,
2437                                                 iaxs[x]->oseqno, iaxs[x]->iseqno,
2438                                                 iaxs[x]->lag,
2439                                                 iaxs[x]->jitter,
2440                                                 ast_getformatname(iaxs[x]->voiceformat) );
2441                         numchans++;
2442                 }
2443                 ast_mutex_unlock(&iaxsl[x]);
2444         }
2445         ast_cli(fd, "%d active IAX channel(s)\n", numchans);
2446         return RESULT_SUCCESS;
2447 #undef FORMAT
2448 #undef FORMAT2
2449 }
2450
2451 static int iax_do_debug(int fd, int argc, char *argv[])
2452 {
2453         if (argc != 2)
2454                 return RESULT_SHOWUSAGE;
2455         iaxdebug = 1;
2456         ast_cli(fd, "IAX Debugging Enabled\n");
2457         return RESULT_SUCCESS;
2458 }
2459
2460 static int iax_no_debug(int fd, int argc, char *argv[])
2461 {
2462         if (argc != 3)
2463                 return RESULT_SHOWUSAGE;
2464         iaxdebug = 0;
2465         ast_cli(fd, "IAX Debugging Disabled\n");
2466         return RESULT_SUCCESS;
2467 }
2468
2469
2470
2471 static char show_users_usage[] =
2472 "Usage: iax show users\n"
2473 "       Lists all users known to the IAX (Inter-Asterisk eXchange) subsystem.\n";
2474
2475 static char show_channels_usage[] =
2476 "Usage: iax show channels\n"
2477 "       Lists all currently active IAX channels.\n";
2478
2479 static char show_peers_usage[] =
2480 "Usage: iax show peers\n"
2481 "       Lists all known IAX peers.\n";
2482
2483 static char show_reg_usage[] =
2484 "Usage: iax show registry\n"
2485 "       Lists all registration requests and status.\n";
2486
2487 #ifdef DEBUG_SUPPORT
2488
2489 static char debug_usage[] =
2490 "Usage: iax debug\n"
2491 "       Enables dumping of IAX packets for debugging purposes\n";
2492
2493 static char no_debug_usage[] =
2494 "Usage: iax no debug\n"
2495 "       Disables dumping of IAX packets for debugging purposes\n";
2496
2497 #endif
2498
2499 static struct ast_cli_entry  cli_show_users =
2500         { { "iax", "show", "users", NULL }, iax_show_users, "Show defined IAX users", show_users_usage };
2501 static struct ast_cli_entry  cli_show_channels =
2502         { { "iax", "show", "channels", NULL }, iax_show_channels, "Show active IAX channels", show_channels_usage };
2503 static struct ast_cli_entry  cli_show_peers =
2504         { { "iax", "show", "peers", NULL }, iax_show_peers, "Show defined IAX peers", show_peers_usage };
2505 static struct ast_cli_entry  cli_show_registry =
2506         { { "iax", "show", "registry", NULL }, iax_show_registry, "Show IAX registration status", show_reg_usage };
2507 static struct ast_cli_entry  cli_debug =
2508         { { "iax", "debug", NULL }, iax_do_debug, "Enable IAX debugging", debug_usage };
2509 static struct ast_cli_entry  cli_no_debug =
2510         { { "iax", "no", "debug", NULL }, iax_no_debug, "Disable IAX debugging", no_debug_usage };
2511
2512 static int iax_write(struct ast_channel *c, struct ast_frame *f)
2513 {
2514         struct chan_iax_pvt *i = c->pvt->pvt;
2515         if (!i)
2516                 return -1;
2517         /* If there's an outstanding error, return failure now */
2518         if (i->error) {
2519                 ast_log(LOG_DEBUG, "Write error: %s\n", strerror(errno));
2520                 return -1;
2521         }
2522         /* If it's already gone, just return */
2523         if (i->alreadygone)
2524                 return 0;
2525         /* Don't waste bandwidth sending null frames */
2526         if (f->frametype == AST_FRAME_NULL)
2527                 return 0;
2528         /* If we're quelching voice, don't bother sending it */
2529         if ((f->frametype == AST_FRAME_VOICE) && i->quelch)
2530                 return 0;
2531         /* Simple, just queue for transmission */
2532         return iax_send(i, f, 0, -1, 0, 0, 0);
2533 }
2534
2535 static int __send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno,
2536                 int now, int transfer, int final)
2537 {
2538         struct ast_frame f;
2539         f.frametype = type;
2540         f.subclass = command;
2541         f.datalen = datalen;
2542         f.samples = 0;
2543         f.mallocd = 0;
2544         f.offset = 0;
2545         f.src = __FUNCTION__;
2546         f.data = data;
2547         return iax_send(i, &f, ts, seqno, now, transfer, final);
2548 }
2549
2550 static int send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2551 {
2552         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
2553 }
2554
2555 #ifdef BRIDGE_OPTIMIZATION
2556 static int forward_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2557 {
2558         return __send_command(iaxs[i->bridgecallno], type, command, ts, data, datalen, seqno, 0, 0, 0);
2559 }
2560 #endif
2561
2562 static int send_command_final(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2563 {
2564         /* It is assumed that the callno has already been locked */
2565         iax_predestroy_nolock(i->callno);
2566         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
2567 }
2568
2569 static int send_command_immediate(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2570 {
2571         return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
2572 }
2573
2574 static int send_command_transfer(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen)
2575 {
2576         return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
2577 }
2578
2579 static int apply_context(struct iax_context *con, char *context)
2580 {
2581         while(con) {
2582                 if (!strcmp(con->context, context))
2583                         return -1;
2584                 con = con->next;
2585         }
2586         return 0;
2587 }
2588
2589 static int iax_getformats(int callno, char *orequest)
2590 {
2591         char *var, *value;
2592         char request[256];
2593         char *stringp=NULL;
2594         strncpy(request, orequest, sizeof(request)-1);
2595         stringp=request;
2596         var = strsep(&stringp, ";");
2597         while(var) {
2598                 value = strchr(var, '=');
2599                 if (value) {
2600                         *value='\0';
2601                         value++;
2602                         if (!strcmp(var, "formats")) {
2603                                 iaxs[callno]->peerformat = atoi(value);
2604                         } else
2605                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2606                 }
2607                 var = strsep(&stringp, ";");
2608         }
2609         return 0;
2610 }
2611
2612
2613 static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int requestl)
2614 {
2615         /* Start pessimistic */
2616         int res = -1;
2617         int version = 1;
2618         char *var, *value;
2619         struct iax_user *user;
2620         char request[256];
2621         int gotcapability=0;
2622         char *stringp=NULL;
2623         strncpy(request, orequest, sizeof(request)-1);
2624         if (!iaxs[callno])
2625                 return res;
2626         stringp=request;
2627         var = strsep(&stringp, ";");
2628         while(var) {
2629                 value = strchr(var, '=');
2630                 if (value) {
2631                         *value='\0';
2632                         value++;
2633                         if (!strcmp(var, "exten"))
2634                                 strncpy(iaxs[callno]->exten, value, sizeof(iaxs[callno]->exten)-1);
2635                         else if (!strcmp(var, "callerid"))
2636                                 strncpy(iaxs[callno]->callerid, value, sizeof(iaxs[callno]->callerid)-1);
2637                         else if (!strcmp(var, "ani"))
2638                                 strncpy(iaxs[callno]->ani, value, sizeof(iaxs[callno]->ani) - 1);
2639                         else if (!strcmp(var, "dnid"))
2640                                 strncpy(iaxs[callno]->dnid, value, sizeof(iaxs[callno]->dnid)-1);
2641                         else if (!strcmp(var, "context"))
2642                                 strncpy(iaxs[callno]->context, value, sizeof(iaxs[callno]->context)-1);
2643                         else if (!strcmp(var, "language"))
2644                                 strncpy(iaxs[callno]->language, value, sizeof(iaxs[callno]->language)-1);
2645                         else if (!strcmp(var, "username"))
2646                                 strncpy(iaxs[callno]->username, value, sizeof(iaxs[callno]->username)-1);
2647                         else if (!strcmp(var, "formats"))
2648                                 iaxs[callno]->peerformat = atoi(value);
2649                         else if (!strcmp(var, "adsicpe"))
2650                                 iaxs[callno]->peeradsicpe = atoi(value);
2651                         else if (!strcmp(var, "capability")) {
2652                                 gotcapability = 1;
2653                                 iaxs[callno]->peercapability = atoi(value);
2654                         } else if (!strcmp(var, "version"))
2655                                 version = atoi(value);
2656                         else
2657                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2658                 }
2659                 var = strsep(&stringp, ";");
2660         }
2661         if (!gotcapability)
2662                 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
2663         if (version > AST_IAX_PROTO_VERSION) {
2664                 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
2665                         inet_ntoa(sin->sin_addr), version);
2666                 return res;
2667         }
2668         ast_mutex_lock(&userl.lock);
2669         /* Search the userlist for a compatible entry, and fill in the rest */
2670         user = userl.users;
2671         while(user) {
2672                 if ((!strlen(iaxs[callno]->username) ||                         /* No username specified */
2673                         !strcmp(iaxs[callno]->username, user->name))    /* Or this username specified */
2674                         && ast_apply_ha(user->ha, sin)  /* Access is permitted from this IP */
2675                         && (!strlen(iaxs[callno]->context) ||                   /* No context specified */
2676                              apply_context(user->contexts, iaxs[callno]->context))) {                   /* Context is permitted */
2677                         break;
2678                 }
2679                 user = user->next;
2680         }
2681 #ifdef MYSQL_FRIENDS
2682         if (!user && mysql && strlen(iaxs[callno]->username) && (strlen(iaxs[callno]->username) < 128)) {
2683                 user = mysql_user(iaxs[callno]->username);
2684                 if (user && strlen(iaxs[callno]->context) &&                    /* No context specified */
2685                              !apply_context(user->contexts, iaxs[callno]->context)) {                   /* Context is permitted */
2686                         if (user->contexts)
2687                                 free(user->contexts);
2688                         free(user);
2689                         user = NULL;
2690                 }
2691         }
2692 #endif
2693         ast_mutex_unlock(&userl.lock);
2694         if (user) {
2695                 /* We found our match (use the first) */
2696
2697                 /* Store the requested username if not specified */
2698                 if (!strlen(iaxs[callno]->username))
2699                         strncpy(iaxs[callno]->username, user->name, sizeof(iaxs[callno]->username)-1);
2700                 /* And use the default context */
2701                 if (!strlen(iaxs[callno]->context)) {
2702                         if (user->contexts)
2703                                 strncpy(iaxs[callno]->context, user->contexts->context, sizeof(iaxs[callno]->context)-1);
2704                         else
2705                                 strncpy(iaxs[callno]->context, context, sizeof(iaxs[callno]->context)-1);
2706                 }
2707                 /* Copy the secret */
2708                 strncpy(iaxs[callno]->secret, user->secret, sizeof(iaxs[callno]->secret)-1);
2709                 /* And any input keys */
2710                 strncpy(iaxs[callno]->inkeys, user->inkeys, sizeof(iaxs[callno]->inkeys));
2711                 /* And the permitted authentication methods */
2712                 strncpy(iaxs[callno]->methods, user->methods, sizeof(iaxs[callno]->methods)-1);
2713                 /* If they have callerid, override the given caller id.  Always store the ANI */
2714                 if (strlen(iaxs[callno]->callerid)) {
2715                         if (user->hascallerid)
2716                                 strncpy(iaxs[callno]->callerid, user->callerid, sizeof(iaxs[callno]->callerid)-1);
2717                         strncpy(iaxs[callno]->ani, user->callerid, sizeof(iaxs[callno]->ani)-1);
2718                 }
2719                 if (strlen(user->accountcode))
2720                         strncpy(iaxs[callno]->accountcode, user->accountcode, sizeof(iaxs[callno]->accountcode)-1);
2721                 if (user->amaflags)
2722                         iaxs[callno]->amaflags = user->amaflags;
2723                 res = 0;
2724         }
2725         return res;
2726 }
2727
2728 static int raw_hangup(struct sockaddr_in *sin, short src, short dst)
2729 {
2730         struct ast_iax_full_hdr fh;
2731         fh.callno = htons(src | AST_FLAG_FULL);
2732         fh.dcallno = htons(dst);
2733         fh.ts = 0;
2734         fh.seqno = 0;
2735         fh.type = AST_FRAME_IAX;
2736         fh.csub = compress_subclass(AST_IAX_COMMAND_INVAL);
2737 #if 0
2738         if (option_debug)
2739 #endif
2740                 ast_log(LOG_DEBUG, "Raw Hangup %s:%d, src=%d, dst=%d\n",
2741                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), src, dst);
2742         return sendto(netsocket, &fh, sizeof(fh), 0, (struct sockaddr *)sin, sizeof(*sin));
2743 }
2744
2745 static int authenticate_request(struct chan_iax_pvt *p)
2746 {
2747         char requeststr[256] = "";
2748         MYSNPRINTF "methods=%s;", p->methods);
2749         if (strstr(p->methods, "md5") || strstr(p->methods, "rsa")) {
2750                 /* Build the challenge */
2751                 snprintf(p->challenge, sizeof(p->challenge), "%d", rand());
2752                 MYSNPRINTF "challenge=%s;", p->challenge);
2753         }
2754         MYSNPRINTF "username=%s;", p->username);
2755         if (strlen(requeststr))
2756                 requeststr[strlen(requeststr) - 1] = '\0';
2757         return send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREQ, 0, requeststr, strlen(requeststr) + 1, -1);
2758 }
2759
2760 static int authenticate_verify(struct chan_iax_pvt *p, char *orequest)
2761 {
2762         char requeststr[256] = "";
2763         char *var, *value, request[256];
2764         char md5secret[256] = "";
2765         char secret[256] = "";
2766         char rsasecret[256] = "";
2767         int res = -1;
2768         int x;
2769         char *stringp=NULL;
2770
2771         if (!(p->state & IAX_STATE_AUTHENTICATED))
2772                 return res;
2773         strncpy(request, orequest, sizeof(request)-1);
2774         stringp=request;
2775         var = strsep(&stringp, ";");
2776         while(var) {
2777                 value = strchr(var, '=');
2778                 if (value) {
2779                         *value='\0';
2780                         value++;
2781                         if (!strcmp(var, "secret"))
2782                                 strncpy(secret, value, sizeof(secret)-1);
2783                         else if (!strcmp(var, "md5secret"))
2784                                 strncpy(md5secret, value, sizeof(md5secret)-1);
2785                         else if (!strcmp(var, "rsasecret"))
2786                                 strncpy(rsasecret, value, sizeof(rsasecret)-1);
2787                         else
2788                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2789                 }
2790                 var = strsep(&stringp, ";");
2791         }
2792         if (strstr(p->methods, "rsa") && strlen(rsasecret) && strlen(p->inkeys)) {
2793                 struct ast_key *key;
2794                 char *keyn;
2795                 char tmpkey[256];
2796                 char *stringp=NULL;
2797                 strncpy(tmpkey, p->inkeys, sizeof(tmpkey));
2798                 stringp=tmpkey;
2799                 keyn = strsep(&stringp, ":");
2800                 while(keyn) {
2801                         key = ast_key_get(keyn, AST_KEY_PUBLIC);
2802                         if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
2803                                 res = 0;
2804                                 break;
2805                         } else if (!key)
2806                                 ast_log(LOG_WARNING, "requested inkey '%s' for RSA authentication does not exist\n", keyn);
2807                         keyn = strsep(&stringp, ":");
2808                 }
2809         } else if (strstr(p->methods, "md5")) {
2810                 struct MD5Context md5;
2811                 unsigned char digest[16];
2812                 MD5Init(&md5);
2813                 MD5Update(&md5, p->challenge, strlen(p->challenge));
2814                 MD5Update(&md5, p->secret, strlen(p->secret));
2815                 MD5Final(digest, &md5);
2816                 /* If they support md5, authenticate with it.  */
2817                 for (x=0;x<16;x++)
2818                         MYSNPRINTF "%2.2x", digest[x]);
2819                 if (!strcasecmp(requeststr, md5secret))
2820                         res = 0;
2821         } else if (strstr(p->methods, "plaintext")) {
2822                 if (!strcmp(secret, p->secret))
2823                         res = 0;
2824         }
2825         return res;
2826 }
2827
2828 static int register_verify(int callno, struct sockaddr_in *sin, char *orequest)
2829 {
2830         char request[256];
2831         char requeststr[256] = "";
2832         char peer[256] = "";
2833         char md5secret[256] = "";
2834         char rsasecret[256] = "";
2835         char secret[256] = "";
2836         struct iax_peer *p;
2837         struct ast_key *key;
2838         char *var;
2839         char *value;
2840         char *keyn;
2841         int x;
2842         int expire = 0;
2843         char *stringp=NULL;
2844
2845         iaxs[callno]->state &= ~IAX_STATE_AUTHENTICATED;
2846         strcpy(iaxs[callno]->peer, "");
2847         if (!orequest)
2848                 return -1;
2849         strncpy(request, orequest, sizeof(request)-1);
2850         stringp=request;
2851         var = strsep(&stringp, ";");
2852         while(var) {
2853                 value = strchr(var, '=');
2854                 if (value) {
2855                         *value='\0';
2856                         value++;
2857                         if (!strcmp(var, "peer"))
2858                                 strncpy(peer, value, sizeof(peer)-1);
2859                         else if (!strcmp(var, "md5secret"))
2860                                 strncpy(md5secret, value, sizeof(md5secret)-1);
2861                         else if (!strcmp(var, "rsasecret"))
2862                                 strncpy(rsasecret, value, sizeof(rsasecret)-1);
2863                         else if (!strcmp(var, "secret"))
2864                                 strncpy(secret, value, sizeof(secret)-1);
2865                         else if (!strcmp(var, "refresh"))
2866                                 expire = atoi(value);
2867                         else
2868                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2869                 }
2870                 var = strsep(&stringp, ";");
2871         }
2872
2873         if (!strlen(peer)) {
2874                 ast_log(LOG_NOTICE, "Empty registration from %s\n", inet_ntoa(sin->sin_addr));
2875                 return -1;
2876         }
2877
2878         for (p = peerl.peers; p ; p = p->next)
2879                 if (!strcasecmp(p->name, peer))
2880                         break;
2881
2882 #ifdef MYSQL_FRIENDS
2883         if (!p)
2884                 p = mysql_peer(peer);
2885 #endif
2886         if (!p) {
2887                 ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, inet_ntoa(sin->sin_addr));
2888                 return -1;
2889         }
2890
2891         if (!p->dynamic) {
2892                 ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, inet_ntoa(sin->sin_addr));
2893                 if (p->delme)
2894                         free(p);
2895                 return -1;
2896         }
2897
2898         if (!ast_apply_ha(p->ha, sin)) {
2899                 ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", inet_ntoa(sin->sin_addr), p->name);
2900                 if (p->delme)
2901                         free(p);
2902                 return -1;
2903         }
2904         strncpy(iaxs[callno]->secret, p->secret, sizeof(iaxs[callno]->secret)-1);
2905         strncpy(iaxs[callno]->inkeys, p->inkeys, sizeof(iaxs[callno]->inkeys)-1);
2906         /* Check secret against what we have on file */
2907         if (strlen(rsasecret) && strstr(p->methods, "rsa") && strlen(iaxs[callno]->challenge)) {
2908                 if (strlen(p->inkeys)) {
2909                         char tmpkeys[256];
2910                         char *stringp=NULL;
2911                         strncpy(tmpkeys, p->inkeys, sizeof(tmpkeys));
2912                         stringp=tmpkeys;
2913                         keyn = strsep(&stringp, ":");
2914                         while(keyn) {
2915                                 key = ast_key_get(keyn, AST_KEY_PUBLIC);
2916                                 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
2917                                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2918                                         break;
2919                                 } else if (!key)
2920                                         ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
2921                                 keyn = strsep(&stringp, ":");
2922                         }
2923                         if (!keyn) {
2924                                 ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
2925                                 if (p->delme)
2926                                         free(p);
2927                                 return -1;
2928                         }
2929                 } else {
2930                         ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
2931                         if (p->delme)
2932                                 free(p);
2933                         return -1;
2934                 }
2935         } else if (strlen(secret) && strstr(p->methods, "plaintext")) {
2936                 /* They've provided a plain text password and we support that */
2937                 if (strcmp(secret, p->secret)) {
2938                         ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", inet_ntoa(sin->sin_addr), p->name);
2939                         if (p->delme)
2940                                 free(p);
2941                         return -1;
2942                 } else
2943                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2944         } else if (strlen(md5secret) && strstr(p->methods, "md5") && strlen(iaxs[callno]->challenge)) {
2945                 struct MD5Context md5;
2946                 unsigned char digest[16];
2947                 MD5Init(&md5);
2948                 MD5Update(&md5, iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
2949                 MD5Update(&md5, p->secret, strlen(p->secret));
2950                 MD5Final(digest, &md5);
2951                 for (x=0;x<16;x++)
2952                         MYSNPRINTF "%2.2x", digest[x]);
2953                 if (strcasecmp(requeststr, md5secret)) {
2954                         ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", inet_ntoa(sin->sin_addr), p->name, requeststr, md5secret);
2955                         if (p->delme)
2956                                 free(p);
2957                         return -1;
2958                 } else
2959                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2960         } else if (strlen(md5secret) || strlen(secret)) {
2961                 ast_log(LOG_NOTICE, "Inappropriate authentication received\n");
2962                 if (p->delme)
2963                         free(p);
2964                 return -1;
2965         }
2966         strncpy(iaxs[callno]->peer, peer, sizeof(iaxs[callno]->peer)-1);
2967         /* Choose lowest expirey number */
2968         if (expire && (expire < iaxs[callno]->expirey))
2969                 iaxs[callno]->expirey = expire;
2970         if (p->delme)
2971                 free(p);
2972         return 0;
2973
2974 }
2975
2976 static int authenticate(char *challenge, char *secret, char *keyn, char *methods, char *requeststr, int reqsize, struct sockaddr_in *sin)
2977 {
2978         int res = -1;
2979         int x;
2980         if (keyn && strlen(keyn)) {
2981                 if (!strstr(methods, "rsa")) {
2982                         if (!secret || !strlen(secret))
2983                                 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));
2984                 } else if (!strlen(challenge)) {
2985                         ast_log(LOG_NOTICE, "No challenge provided for RSA authentication to %s\n", inet_ntoa(sin->sin_addr));
2986                 } else {
2987                         char sig[256];
2988                         struct ast_key *key;
2989                         key = ast_key_get(keyn, AST_KEY_PRIVATE);
2990                         if (!key) {
2991                                 ast_log(LOG_NOTICE, "Unable to find private key '%s'\n", keyn);
2992                         } else {
2993                                 if (ast_sign(key, challenge, sig)) {
2994                                         ast_log(LOG_NOTICE, "Unable to sign challenge withy key\n");
2995                                         res = -1;
2996                                 } else {
2997                                         MYSNPRINTF2 "rsasecret=%s;", sig);
2998                                         res = 0;
2999                                 }
3000                         }
3001                 }
3002         }
3003         /* Fall back */
3004         if (res && secret && strlen(secret)) {
3005                 if (strstr(methods, "md5") && strlen(challenge)) {
3006                         struct MD5Context md5;
3007                         unsigned char digest[16];
3008                         MD5Init(&md5);
3009                         MD5Update(&md5, challenge, strlen(challenge));
3010                         MD5Update(&md5, secret, strlen(secret));
3011                         MD5Final(digest, &md5);
3012                         /* If they support md5, authenticate with it.  */
3013                         MYSNPRINTF2 "md5secret=");
3014                         for (x=0;x<16;x++)
3015                                 MYSNPRINTF2 "%2.2x", digest[x]);
3016                         MYSNPRINTF2 ";");
3017                         res = 0;
3018                 } else if (strstr(methods, "plaintext")) {
3019                         MYSNPRINTF2 "secret=%s;", secret);
3020                         res = 0;
3021                 } else
3022                         ast_log(LOG_NOTICE, "No way to send secret to peer '%s' (their methods: %s)\n", inet_ntoa(sin->sin_addr), methods);
3023         }
3024         return res;
3025 }
3026
3027 static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, char *orequest, char *override, char *okey)
3028 {
3029         struct iax_peer *peer;
3030         /* Start pessimistic */
3031         int res = -1;
3032         char request[256];
3033         char methods[80] = "";
3034         char requeststr[256] = "";
3035         char *var, *value;
3036         char *stringp=NULL;
3037
3038         strncpy(request, orequest, sizeof(request)-1);
3039         stringp=request;
3040         var = strsep(&stringp, ";");
3041         while(var) {
3042                 value = strchr(var, '=');
3043                 if (value) {
3044                         *value='\0';
3045                         value++;
3046                         if (!strcmp(var, "username"))
3047                                 strncpy(p->username, value, sizeof(p->username)-1);
3048                         else if (!strcmp(var, "challenge"))
3049                                 strncpy(p->challenge, value, sizeof(p->challenge)-1);
3050                         else if (!strcmp(var, "methods"))
3051                                 strncpy(methods, value, sizeof(methods)-1);
3052                         else
3053                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3054                 }
3055                 var = strsep(&stringp, ";");
3056         }
3057
3058         /* Check for override RSA authentication first */
3059         if ((override && strlen(override)) || (okey && strlen(okey))) {
3060                 /* Normal password authentication */
3061                 res = authenticate(p->challenge, override, okey, methods, requeststr, sizeof(requeststr), sin);
3062         } else {
3063                 ast_mutex_lock(&peerl.lock);
3064                 peer = peerl.peers;
3065                 while(peer) {
3066                         if ((!strlen(p->peer) || !strcmp(p->peer, peer->name))
3067                                                                 /* No peer specified at our end, or this is the peer */
3068                          && (!strlen(peer->username) || (!strcmp(peer->username, p->username)))
3069                                                                 /* No username specified in peer rule, or this is the right username */
3070                          && (!peer->addr.sin_addr.s_addr || ((sin->sin_addr.s_addr & peer->mask.s_addr) == (peer->addr.sin_addr.s_addr & peer->mask.s_addr)))
3071                                                                 /* No specified host, or this is our host */
3072                         ) {
3073                                 res = authenticate(p->challenge, peer->secret, peer->outkey, methods, requeststr, sizeof(requeststr), sin);
3074                                 if (!res)
3075                                         break;
3076                         }
3077                         peer = peer->next;
3078                 }
3079                 ast_mutex_unlock(&peerl.lock);
3080         }
3081         if (strlen(requeststr))
3082                 requeststr[strlen(requeststr)-1] = '\0';
3083         if (!res)
3084                 res = send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREP, 0, requeststr, strlen(requeststr) + 1, -1);
3085         return res;
3086 }
3087
3088 static int iax_do_register(struct iax_registry *reg);
3089
3090 static int iax_do_register_s(void *data)
3091 {
3092         struct iax_registry *reg = data;
3093         reg->expire = -1;
3094         iax_do_register(reg);
3095         return 0;
3096 }
3097
3098 static int try_transfer(struct chan_iax_pvt *pvt, char *orequest)
3099 {
3100         int newport = 0;
3101         int newcall = 0;
3102         char newip[256] = "";
3103         char request[256] = "";
3104         char *var, *value;
3105
3106         struct sockaddr_in new;
3107         char *stringp=NULL;
3108
3109         if (!orequest)
3110                 return -1;
3111
3112         strncpy(request, orequest, sizeof(request)-1);
3113         stringp=request;
3114         var = strsep(&stringp, ";");
3115         while(var) {
3116                 value = strchr(var, '=');
3117                 if (value) {
3118                         *value='\0';
3119                         value++;
3120                         if (!strcmp(var, "remip"))
3121                                 strncpy(newip, value, sizeof(newip)-1);
3122                         else if (!strcmp(var, "remport"))
3123                                 newport = atoi(value);
3124                         else if (!strcmp(var, "remcall"))
3125                                 newcall = atoi(value);
3126                         else
3127                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3128                 }
3129                 var = strsep(&stringp, ";");
3130         }
3131         if (!newcall || !inet_aton(newip, &new.sin_addr) || !newport) {
3132                 ast_log(LOG_WARNING, "Invalid transfer request\n");
3133                 return -1;
3134         }
3135         pvt->transfercallno = newcall;
3136         inet_aton(newip, &pvt->transfer.sin_addr);
3137         pvt->transfer.sin_port = htons(newport);
3138         pvt->transfer.sin_family = AF_INET;
3139         pvt->transferring = TRANSFER_BEGIN;
3140         send_command_transfer(pvt, AST_FRAME_IAX, AST_IAX_COMMAND_TXCNT, 0, NULL, 0);
3141         return 0;
3142 }
3143
3144 static int complete_dpreply(struct chan_iax_pvt *pvt, char *orequest)
3145 {
3146         char *var, *value;
3147         char request[256] = "";
3148         char exten[256] = "";
3149         int status = CACHE_FLAG_UNKNOWN;
3150         int expirey = iaxdefaultdpcache;
3151         int x;
3152         int matchmore = 0;
3153         struct iax_dpcache *dp, *prev;
3154         char *stringp=NULL;
3155
3156         strncpy(request, orequest, sizeof(request)-1);
3157         stringp=request;
3158         var = strsep(&stringp, ";");
3159         while(var) {
3160                 value = strchr(var, '=');
3161                 if (value) {
3162                         *value='\0';
3163                         value++;
3164                         if (!strcmp(var, "number"))
3165                                 strncpy(exten, value, sizeof(exten)-1);
3166                         else if (!strcmp(var, "status")) {
3167                                 if (!strcasecmp(value, "exists"))
3168                                         status = CACHE_FLAG_EXISTS;
3169                                 else if (!strcasecmp(value, "nonexistant"))
3170                                         status = CACHE_FLAG_NONEXISTANT;
3171                                 else if (!strcasecmp(value, "canexist"))
3172                                         status = CACHE_FLAG_CANEXIST;
3173                                 else
3174                                         ast_log(LOG_WARNING, "Unknown status '%s'\n", value);
3175                         } else if (!strcmp(var, "expirey"))
3176                                 expirey = atoi(value);
3177                         else if (!strcmp(var, "ignorepat")) {
3178                                 /* Don' really do much with it */
3179                         } else if (!strcmp(var, "matchmore")) {
3180                                 matchmore = CACHE_FLAG_MATCHMORE;
3181                         } else
3182                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3183                 }
3184                 var = strsep(&stringp, ";");
3185         }
3186         ast_mutex_lock(&dpcache_lock);
3187         prev = NULL;
3188         dp = pvt->dpentries;
3189         while(dp) {
3190                 if (!strcmp(dp->exten, exten)) {
3191                         /* Let them go */
3192                         if (prev)
3193                                 prev->peer = dp->peer;
3194                         else
3195                                 pvt->dpentries = dp->peer;
3196                         dp->peer = NULL;
3197                         dp->callno = -1;
3198                         dp->expirey.tv_sec = dp->orig.tv_sec + expirey;
3199                         if (dp->flags & CACHE_FLAG_PENDING) {
3200                                 dp->flags &= ~CACHE_FLAG_PENDING;
3201                                 dp->flags |= status;
3202                                 dp->flags |= CACHE_FLAG_MATCHMORE;
3203                         }
3204                         /* Wake up waiters */
3205                         for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
3206                                 if (dp->waiters[x] > -1)
3207                                         write(dp->waiters[x], "asdf", 4);
3208                 }
3209                 prev = dp;
3210                 dp = dp->peer;
3211         }
3212         ast_mutex_unlock(&dpcache_lock);
3213         return 0;
3214 }
3215
3216 static int complete_transfer(int callno, char *orequest)
3217 {
3218         int peercallno = -1;
3219         char request[256] = "";
3220         char *var, *value;
3221         struct chan_iax_pvt *pvt = iaxs[callno];
3222         struct ast_iax_frame *cur;
3223         char *stringp=NULL;
3224         if (!orequest)
3225                 return -1;
3226
3227         strncpy(request, orequest, sizeof(request)-1);
3228         stringp=request;
3229         var = strsep(&stringp, ";");
3230         while(var) {
3231                 value = strchr(var, '=');
3232                 if (value) {
3233                         *value='\0';
3234                         value++;
3235                         if (!strcmp(var, "peercallno"))
3236                                 peercallno = atoi(value);
3237                         else
3238                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3239                 }
3240                 var = strsep(&stringp, ";");
3241         }
3242         if (peercallno < 0) {
3243                 ast_log(LOG_WARNING, "Invalid transfer request\n");
3244                 return -1;
3245         }
3246         memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
3247         memset(&pvt->transfer, 0, sizeof(pvt->transfer));
3248         /* Reset sequence numbers */
3249         pvt->oseqno = 0;
3250         pvt->iseqno = 0;
3251         pvt->peercallno = peercallno;
3252         pvt->transferring = TRANSFER_NONE;
3253         pvt->svoiceformat = -1;
3254         pvt->voiceformat = 0;
3255         pvt->transfercallno = -1;
3256         memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
3257         memset(&pvt->offset, 0, sizeof(pvt->offset));
3258         memset(&pvt->history, 0, sizeof(pvt->history));
3259         pvt->jitterbuffer = 0;
3260         pvt->jitter = 0;
3261         pvt->historicjitter = 0;
3262         pvt->lag = 0;
3263         pvt->last = 0;
3264         pvt->lastsent = 0;
3265         pvt->pingtime = DEFAULT_RETRY_TIME;
3266         ast_mutex_lock(&iaxq.lock);
3267         for (cur = iaxq.head; cur ; cur = cur->next) {
3268                 /* We must cancel any packets that would have been transmitted
3269                    because now we're talking to someone new.  It's okay, they
3270                    were transmitted to someone that didn't care anyway. */
3271                 if (callno == cur->callno)
3272                         cur->retries = -1;
3273         }
3274         ast_mutex_unlock(&iaxq.lock);
3275         return 0;
3276 }
3277
3278 static int iax_ack_registry(char *orequest, struct sockaddr_in *sin, int callno)
3279 {
3280         struct iax_registry *reg;
3281         /* Start pessimistic */
3282         char request[256] = "";
3283         char peer[256] = "";
3284         int ourport = 0;
3285         int refresh = 0;
3286         char ourip[256] = "<Unspecified>";
3287         struct sockaddr_in oldus;
3288         char *var, *value;
3289         char *stringp=NULL;
3290
3291         if (!orequest)
3292                 return -1;
3293
3294         strncpy(request, orequest, sizeof(request)-1);
3295         stringp=request;
3296         var = strsep(&stringp, ";");
3297         while(var) {
3298                 value = strchr(var, '=');
3299                 if (value) {
3300                         *value='\0';
3301                         value++;
3302                         if (!strcmp(var, "yourip"))
3303                                 strncpy(ourip, value, sizeof(ourip)-1);
3304                         else if (!strcmp(var, "peer"))
3305                                 strncpy(peer, value, sizeof(peer)-1);
3306                         else if (!strcmp(var, "yourport"))
3307                                 ourport = atoi(value);
3308                         else if (!strcmp(var, "refresh"))
3309                                 refresh = atoi(value);
3310                         else if (!strcmp(var, "callerid")) {
3311                                 /* We don't really care about suggested Caller*ID, that's more for phones */
3312                         } else
3313                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3314                 }
3315                 var = strsep(&stringp, ";");
3316         }
3317         reg = iaxs[callno]->reg;
3318                         memcpy(&oldus, &reg->us, sizeof(oldus));
3319                         if (memcmp(&reg->addr, sin, sizeof(&reg->addr))) {
3320                                 ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", inet_ntoa(sin->sin_addr));
3321                                 return -1;
3322                         }
3323                         if (!inet_aton(ourip, &reg->us.sin_addr)) {
3324                                 ast_log(LOG_WARNING, "Registry ack from '%s' contains invalid IP '%s'\n", inet_ntoa(sin->sin_addr), ourip);
3325                                 return -1;
3326                         }
3327                         reg->us.sin_port = htons(ourport);
3328                         if (refresh && (reg->refresh < refresh)) {
3329                                 /* Refresh faster if necessary */
3330                                 reg->refresh = refresh;
3331                                 if (reg->expire > -1)
3332                                         ast_sched_del(sched, reg->expire);
3333                                 reg->expire = ast_sched_add(sched, (5 * reg->refresh / 6) * 1000, iax_do_register_s, reg);
3334                         }
3335                         if (memcmp(&oldus, &reg->us, sizeof(oldus)) && (option_verbose > 2)) {
3336                                 snprintf(ourip, sizeof(ourip), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
3337                                 ast_verbose(VERBOSE_PREFIX_3 "Registered to '%s', who sees us as %s\n", inet_ntoa(sin->sin_addr), ourip);
3338                         }
3339                         reg->regstate = REG_STATE_REGISTERED;
3340                         return 0;
3341         ast_log(LOG_WARNING, "Registry acknowledge on unknown registery '%s'\n", peer);
3342         return -1;
3343 }
3344
3345 static int iax_register(char *value, int lineno)
3346 {
3347         struct iax_registry *reg;
3348         char copy[256];
3349         char *username, *hostname, *secret;
3350         char *porta;
3351         char *stringp=NULL;
3352
3353         struct hostent *hp;
3354         if (!value)
3355                 return -1;
3356         strncpy(copy, value, sizeof(copy)-1);
3357         stringp=copy;
3358         username = strsep(&stringp, "@");
3359         hostname = strsep(&stringp, "@");
3360         if (!hostname) {
3361                 ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d", lineno);
3362                 return -1;
3363         }
3364         stringp=username;
3365         username = strsep(&stringp, ":");
3366         secret = strsep(&stringp, ":");
3367         stringp=hostname;
3368         hostname = strsep(&stringp, ":");
3369         porta = strsep(&stringp, ":");
3370
3371         if (porta && !atoi(porta)) {
3372                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
3373                 return -1;
3374         }
3375         hp = gethostbyname(hostname);
3376         if (!hp) {
3377                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
3378                 return -1;
3379         }
3380         reg = malloc(sizeof(struct iax_registry));
3381         if (reg) {
3382                 memset(reg, 0, sizeof(struct iax_registry));
3383                 strncpy(reg->username, username, sizeof(reg->username)-1);
3384                 if (secret)
3385                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
3386                 reg->expire = -1;
3387                 reg->refresh = AST_DEFAULT_REG_EXPIRE;
3388                 reg->addr.sin_family = AF_INET;
3389                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
3390                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(AST_DEFAULT_IAX_PORTNO);
3391                 reg->next = registrations;
3392                 reg->callno = -1;
3393                 registrations = reg;
3394         } else {
3395                 ast_log(LOG_ERROR, "Out of memory\n");
3396                 return -1;
3397         }
3398         return 0;
3399 }
3400
3401 static int expire_registry(void *data)
3402 {
3403         struct iax_peer *p = data;
3404         /* Reset the address */
3405         memset(&p->addr, 0, sizeof(p->addr));
3406         /* Reset expire notice */
3407         p->expire = -1;
3408         /* Reset expirey value */
3409         p->expirey = expirey;
3410         if (iax_regfunk)
3411                 iax_regfunk(p->name, 0);
3412         return 0;
3413 }
3414
3415
3416 static int iax_poke_peer(struct iax_peer *peer);
3417
3418
3419 static int update_registry(char *name, struct sockaddr_in *sin, int callno)
3420 {
3421         /* Called from IAX thread only, with proper iaxsl lock */
3422         char requeststr[256] = "";
3423         struct iax_peer *p;
3424         for (p = peerl.peers;p;p = p->next) {
3425                 if (!strcasecmp(name, p->name)) {
3426                         break;
3427                 }
3428         }
3429 #ifdef MYSQL_FRIENDS
3430         if (!p)
3431                 p = mysql_peer(name);
3432 #endif
3433         if (p) {
3434 #ifdef MYSQL_FRIENDS
3435                 if (p->delme)
3436                         mysql_update_peer(name, sin);
3437 #endif
3438                 if (memcmp(&p->addr, sin, sizeof(p->addr))) {
3439                         if (iax_regfunk)
3440                                 iax_regfunk(p->name, 1);
3441                         if  (option_verbose > 2)
3442                                 ast_verbose(VERBOSE_PREFIX_3 "Registered '%s' (%s) at %s:%d\n", p->name,
3443                                         iaxs[callno]->state & IAX_STATE_AUTHENTICATED ? "AUTHENTICATED" : "UNAUTHENTICATED", inet_ntoa(sin->sin_addr), htons(sin->sin_port));
3444                         iax_poke_peer(p);
3445                 }
3446                 /* Update the host */
3447                 memcpy(&p->addr, sin, sizeof(p->addr));
3448                 /* Setup the expirey */
3449                 if (p->expire > -1)
3450                         ast_sched_del(sched, p->expire);
3451                 if (p->expirey)
3452                         p->expire = ast_sched_add(sched, p->expirey * 1000, expire_registry, (void *)p);
3453                 MYSNPRINTF "peer=%s;yourip=%s;yourport=%d;refresh=%d;",
3454                         p->name, inet_ntoa(p->addr.sin_addr), ntohs(p->addr.sin_port), p->expirey);
3455                 if (p->hascallerid)
3456                         MYSNPRINTF "callerid=%s;", p->callerid);
3457                 requeststr[strlen(requeststr)-1] = '\0';
3458                 if (p->delme)
3459                         free(p);
3460                 return send_command_final(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_REGACK, 0, requeststr, strlen(requeststr) + 1, -1);;
3461         }
3462         ast_log(LOG_WARNING, "No such peer '%s'\n", name);
3463         return -1;
3464 }
3465
3466 static int registry_authrequest(char *name, int callno)
3467 {
3468         char requeststr[256] = "";
3469         struct iax_peer *p;
3470         for (p = peerl.peers;p;p = p->next) {
3471                 if (!strcasecmp(name, p->name)) {
3472                         break;
3473                 }
3474         }
3475 #ifdef MYSQL_FRIENDS
3476         if (!p)
3477                 p = mysql_peer(name);
3478 #endif
3479         if (p) {
3480                 MYSNPRINTF "methods=%s;", p->methods);
3481                 if (strstr(p->methods, "md5") || strstr(p->methods, "rsa")) {
3482                         /* Build the challenge */
3483                         snprintf(iaxs[callno]->challenge, sizeof(iaxs[callno]->challenge), "%d", rand());
3484                         MYSNPRINTF "challenge=%s;", iaxs[callno]->challenge);
3485                 }
3486                 MYSNPRINTF "peer=%s;", name);
3487                 requeststr[strlen(requeststr)-1] = '\0';
3488                 if (p->delme)
3489                         free(p);
3490                 return send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_REGAUTH, 0, requeststr, strlen(requeststr) + 1, -1);
3491         }