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                         if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
1966                                 res = 0;
1967                                 break;
1968                         }
1969                         continue;
1970                 }
1971                 f = ast_read(who);
1972                 if (!f) {
1973                         *fo = NULL;
1974                         *rc = who;
1975                         res = 0;
1976                         break;
1977                 }
1978                 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
1979                         *fo = f;
1980                         *rc = who;
1981                         res =  0;
1982                         break;
1983                 }
1984                 if ((f->frametype == AST_FRAME_VOICE) ||
1985                         (f->frametype == AST_FRAME_TEXT) ||
1986                         (f->frametype == AST_FRAME_VIDEO) ||
1987                         (f->frametype == AST_FRAME_IMAGE) ||
1988                         (f->frametype == AST_FRAME_DTMF)) {
1989                         if ((f->frametype == AST_FRAME_DTMF) &&
1990                                 (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
1991                                 if ((who == c0)) {
1992                                         if  ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
1993                                                 *rc = c0;
1994                                                 *fo = f;
1995                                                 /* Take out of conference mode */
1996                                                 res = 0;
1997                                                 break;
1998                                         } else
1999                                                 goto tackygoto;
2000                                 } else
2001                                 if ((who == c1)) {
2002                                         if (flags & AST_BRIDGE_DTMF_CHANNEL_1) {
2003                                                 *rc = c1;
2004                                                 *fo = f;
2005                                                 res =  0;
2006                                                 break;
2007                                         } else
2008                                                 goto tackygoto;
2009                                 }
2010                         } else {
2011 #if 0
2012                                 ast_log(LOG_DEBUG, "Read from %s\n", who->name);
2013                                 if (who == last)
2014                                         ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
2015                                 last = who;
2016 #endif
2017 tackygoto:
2018                                 if (who == c0)
2019                                         ast_write(c1, f);
2020                                 else
2021                                         ast_write(c0, f);
2022                         }
2023                         ast_frfree(f);
2024                 } else
2025                         ast_frfree(f);
2026                 /* Swap who gets priority */
2027                 cs[2] = cs[0];
2028                 cs[0] = cs[1];
2029                 cs[1] = cs[2];
2030         }
2031         p0->bridgecallno = -1;
2032         p1->bridgecallno = -1;
2033         return res;
2034 }
2035
2036 static int iax_answer(struct ast_channel *c)
2037 {
2038         struct chan_iax_pvt *pvt = c->pvt->pvt;
2039         if (option_debug)
2040                 ast_log(LOG_DEBUG, "Answering\n");
2041         return send_command(pvt, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
2042 }
2043
2044 static int iax_indicate(struct ast_channel *c, int condition)
2045 {
2046         struct chan_iax_pvt *pvt = c->pvt->pvt;
2047         if (option_debug)
2048                 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
2049         return send_command(pvt, AST_FRAME_CONTROL, condition, 0, NULL, 0, -1);
2050 }
2051
2052
2053 static int iax_write(struct ast_channel *c, struct ast_frame *f);
2054
2055 static int iax_getpeername(struct sockaddr_in sin, char *host, int len)
2056 {
2057         struct iax_peer *peer;
2058         int res = 0;
2059         ast_mutex_lock(&peerl.lock);
2060         peer = peerl.peers;
2061         while(peer) {
2062                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
2063                                 (peer->addr.sin_port == sin.sin_port)) {
2064                                         strncpy(host, peer->name, len-1);
2065                                         res = 1;
2066                                         break;
2067                 }
2068                 peer = peer->next;
2069         }
2070         ast_mutex_unlock(&peerl.lock);
2071         return res;
2072 }
2073
2074 static struct ast_channel *ast_iax_new(struct chan_iax_pvt *i, int state, int capability)
2075 {
2076         char host[256];
2077         struct ast_channel *tmp;
2078         tmp = ast_channel_alloc(1);
2079         if (tmp) {
2080                 if (!iax_getpeername(i->addr, host, sizeof(host)))
2081                         snprintf(host, sizeof(host), "%s:%d", inet_ntoa(i->addr.sin_addr), ntohs(i->addr.sin_port));
2082                 if (strlen(i->username))
2083                         snprintf(tmp->name, sizeof(tmp->name), "IAX[%s@%s]/%d", i->username, host, i->callno);
2084                 else
2085                         snprintf(tmp->name, sizeof(tmp->name), "IAX[%s]/%d", host, i->callno);
2086                 tmp->type = type;
2087                 /* We can support any format by default, until we get restricted */
2088                 tmp->nativeformats = capability;
2089                 tmp->readformat = 0;
2090                 tmp->writeformat = 0;
2091                 tmp->pvt->pvt = i;
2092                 tmp->pvt->send_digit = iax_digit;
2093                 tmp->pvt->send_text = iax_sendtext;
2094                 tmp->pvt->send_image = iax_sendimage;
2095                 tmp->pvt->send_html = iax_sendhtml;
2096                 tmp->pvt->call = iax_call;
2097                 tmp->pvt->hangup = iax_hangup;
2098                 tmp->pvt->answer = iax_answer;
2099                 tmp->pvt->read = iax_read;
2100                 tmp->pvt->write = iax_write;
2101                 tmp->pvt->indicate = iax_indicate;
2102                 tmp->pvt->setoption = iax_setoption;
2103                 tmp->pvt->bridge = iax_bridge;
2104                 if (strlen(i->callerid))
2105                         tmp->callerid = strdup(i->callerid);
2106                 if (strlen(i->ani))
2107                         tmp->ani = strdup(i->ani);
2108                 if (strlen(i->language))
2109                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2110                 if (strlen(i->dnid))
2111                         tmp->dnid = strdup(i->dnid);
2112                 if (strlen(i->accountcode))
2113                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2114                 if (i->amaflags)
2115                         tmp->amaflags = i->amaflags;
2116                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2117                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2118                 tmp->adsicpe = i->peeradsicpe;
2119                 tmp->pvt->fixup = iax_fixup;
2120                 i->owner = tmp;
2121                 i->capability = capability;
2122                 ast_setstate(tmp, state);
2123                 ast_mutex_lock(&usecnt_lock);
2124                 usecnt++;
2125                 ast_mutex_unlock(&usecnt_lock);
2126                 ast_update_use_count();
2127                 if (state != AST_STATE_DOWN) {
2128                         if (ast_pbx_start(tmp)) {
2129                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2130                                 ast_hangup(tmp);
2131                                 tmp = NULL;
2132                         }
2133                 }
2134         }
2135         return tmp;
2136 }
2137
2138 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts)
2139 {
2140         struct timeval tv;
2141         unsigned int ms;
2142         if (!p->offset.tv_sec && !p->offset.tv_usec)
2143                 gettimeofday(&p->offset, NULL);
2144         /* If the timestamp is specified, just send it as is */
2145         if (ts)
2146                 return ts;
2147         gettimeofday(&tv, NULL);
2148         ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
2149         /* We never send the same timestamp twice, so fudge a little if we must */
2150         if (ms <= p->lastsent)
2151                 ms = p->lastsent + 1;
2152         p->lastsent = ms;
2153         return ms;
2154 }
2155
2156 #ifdef BRIDGE_OPTIMIZATION
2157 static unsigned int calc_fakestamp(struct chan_iax_pvt *p1, struct chan_iax_pvt *p2, unsigned int fakets)
2158 {
2159         int ms;
2160         /* Receive from p1, send to p2 */
2161
2162         /* Setup rxcore if necessary on outgoing channel */
2163         if (!p1->rxcore.tv_sec && !p1->rxcore.tv_usec)
2164                 gettimeofday(&p1->rxcore, NULL);
2165
2166         /* Setup txcore if necessary on outgoing channel */
2167         if (!p2->offset.tv_sec && !p2->offset.tv_usec)
2168                 gettimeofday(&p2->offset, NULL);
2169
2170         /* Now, ts is the timestamp of the original packet in the orignal context.
2171            Adding rxcore to it gives us when we would want the packet to be delivered normally.
2172            Subtracting txcore of the outgoing channel gives us what we'd expect */
2173
2174         ms = (p1->rxcore.tv_sec - p2->offset.tv_sec) * 1000 + (p1->rxcore.tv_usec - p1->offset.tv_usec) / 1000;
2175         fakets += ms;
2176         if (fakets <= p2->lastsent)
2177                 fakets = p2->lastsent + 1;
2178         p2->lastsent = fakets;
2179         return fakets;
2180 }
2181 #endif
2182
2183 static unsigned int calc_rxstamp(struct chan_iax_pvt *p)
2184 {
2185         /* Returns where in "receive time" we are */
2186         struct timeval tv;
2187         unsigned int ms;
2188         /* Setup rxcore if necessary */
2189         if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
2190                 gettimeofday(&p->rxcore, NULL);
2191
2192         gettimeofday(&tv, NULL);
2193         ms = (tv.tv_sec - p->rxcore.tv_sec) * 1000 + (tv.tv_usec - p->rxcore.tv_usec) / 1000;
2194         return ms;
2195 }
2196
2197 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final)
2198 {
2199         /* Queue a packet for delivery on a given private structure.  Use "ts" for
2200            timestamp, or calculate if ts is 0.  Send immediately without retransmission
2201            or delayed, with retransmission */
2202         struct ast_iax_full_hdr *fh;
2203         struct ast_iax_mini_hdr *mh;
2204         struct ast_iax_frame *fr, fr2;
2205         int res;
2206         unsigned int lastsent;
2207         /* Allocate an ast_iax_frame */
2208         if (now)
2209                 fr = &fr2;
2210         else
2211                 fr = ast_iax_frame_new(DIRECTION_OUTGRESS);
2212         if (!fr) {
2213                 ast_log(LOG_WARNING, "Out of memory\n");
2214                 return -1;
2215         }
2216         if (!pvt) {
2217                 ast_log(LOG_WARNING, "No private structure for packet (%d)?\n", fr->callno);
2218                 if (!now)
2219                         ast_iax_frame_free(fr);
2220                 return -1;
2221         }
2222         /* Isolate our frame for transmission */
2223         fr->f = ast_frdup(f);
2224
2225         if (!fr->f) {
2226                 ast_log(LOG_WARNING, "Out of memory\n");
2227                 if (!now)
2228                         ast_iax_frame_free(fr);
2229                 return -1;
2230         }
2231         if (fr->f->offset < sizeof(struct ast_iax_full_hdr)) {
2232                 ast_log(LOG_WARNING, "Packet from '%s' not friendly\n", fr->f->src);
2233                 free(fr);
2234                 return -1;
2235         }
2236         lastsent = pvt->lastsent;
2237         fr->ts = calc_timestamp(pvt, ts);
2238         if (!fr->ts) {
2239                 ast_log(LOG_WARNING, "timestamp is 0?\n");
2240                 if (!now)
2241                         ast_iax_frame_free(fr);
2242                 return -1;
2243         }
2244         fr->callno = pvt->callno;
2245         fr->transfer = transfer;
2246         fr->final = final;
2247         if (((fr->ts & 0xFFFF0000L) != (lastsent & 0xFFFF0000L))
2248                 /* High two bits of timestamp differ */ ||
2249             (fr->f->frametype != AST_FRAME_VOICE)
2250                 /* or not a voice frame */ ||
2251                 (fr->f->subclass != pvt->svoiceformat)
2252                 /* or new voice format */ ) {
2253                 /* We need a full frame */
2254                 if (seqno > -1)
2255                         fr->seqno = seqno;
2256                 else
2257                         fr->seqno = pvt->oseqno++;
2258                 fh = (struct ast_iax_full_hdr *)(fr->f->data - sizeof(struct ast_iax_full_hdr));
2259                 fh->callno = htons(fr->callno | AST_FLAG_FULL);
2260                 fh->ts = htonl(fr->ts);
2261                 fh->seqno = htons(fr->seqno);
2262                 fh->type = fr->f->frametype & 0xFF;
2263                 fh->csub = compress_subclass(fr->f->subclass);
2264                 if (transfer) {
2265                         fh->dcallno = htons(pvt->transfercallno);
2266                 } else
2267                         fh->dcallno = htons(pvt->peercallno);
2268                 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_full_hdr);
2269                 fr->data = fh;
2270                 fr->retries = 0;
2271                 /* Retry after 2x the ping time has passed */
2272                 fr->retrytime = pvt->pingtime * 2;
2273                 if (fr->retrytime < MIN_RETRY_TIME)
2274                         fr->retrytime = MIN_RETRY_TIME;
2275                 if (fr->retrytime > MAX_RETRY_TIME)
2276                         fr->retrytime = MAX_RETRY_TIME;
2277                 /* Acks' don't get retried */
2278                 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == AST_IAX_COMMAND_ACK))
2279                         fr->retries = -1;
2280                 if (f->frametype == AST_FRAME_VOICE) {
2281                         pvt->svoiceformat = f->subclass;
2282                 }
2283                 if (now) {
2284                         res = send_packet(fr);
2285                         ast_frfree(fr->f);
2286                 } else
2287                         res = iax_transmit(fr);
2288         } else {
2289                 /* Mini-frames have no sequence number */
2290                 fr->seqno = -1;
2291                 /* Mini frame will do */
2292                 mh = (struct ast_iax_mini_hdr *)(fr->f->data - sizeof(struct ast_iax_mini_hdr));
2293                 mh->callno = htons(fr->callno);
2294                 mh->ts = htons(fr->ts & 0xFFFF);
2295                 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_mini_hdr);
2296                 fr->data = mh;
2297                 fr->retries = -1;
2298                 if (now) {
2299                         res = send_packet(fr);
2300                         ast_frfree(fr->f);
2301                 } else
2302                         res = iax_transmit(fr);
2303         }
2304         return res;
2305 }
2306
2307
2308
2309 static int iax_show_users(int fd, int argc, char *argv[])
2310 {
2311 #define FORMAT "%-15.15s  %-15.15s  %-15.15s  %-15.15s  %-5.5s\n"
2312         struct iax_user *user;
2313         if (argc != 3)
2314                 return RESULT_SHOWUSAGE;
2315         ast_mutex_lock(&userl.lock);
2316         ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
2317         for(user=userl.users;user;user=user->next) {
2318                 ast_cli(fd, FORMAT, user->name, user->secret, user->methods,
2319                                 user->contexts ? user->contexts->context : context,
2320                                 user->ha ? "Yes" : "No");
2321         }
2322         ast_mutex_unlock(&userl.lock);
2323         return RESULT_SUCCESS;
2324 #undef FORMAT
2325 }
2326
2327 static int iax_show_peers(int fd, int argc, char *argv[])
2328 {
2329 #define FORMAT2 "%-15.15s  %-15.15s %s  %-15.15s  %-8s  %-10s\n"
2330 #define FORMAT "%-15.15s  %-15.15s %s  %-15.15s  %-8d  %-10s\n"
2331         struct iax_peer *peer;
2332         char name[256] = "";
2333         if (argc != 3)
2334                 return RESULT_SHOWUSAGE;
2335         ast_mutex_lock(&peerl.lock);
2336         ast_cli(fd, FORMAT2, "Name/Username", "Host", "   ", "Mask", "Port", "Status");
2337         for (peer = peerl.peers;peer;peer = peer->next) {
2338                 char nm[20];
2339                 char status[20];
2340                 if (strlen(peer->username))
2341                         snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
2342                 else
2343                         strncpy(name, peer->name, sizeof(name) - 1);
2344                 if (peer->maxms) {
2345                         if (peer->lastms < 0)
2346                                 strcpy(status, "UNREACHABLE");
2347                         else if (peer->lastms > peer->maxms)
2348                                 snprintf(status, sizeof(status), "LAGGED (%d ms)", peer->lastms);
2349                         else if (peer->lastms)
2350                                 snprintf(status, sizeof(status), "OK (%d ms)", peer->lastms);
2351                         else
2352                                 strcpy(status, "UNKNOWN");
2353                 } else
2354                         strcpy(status, "Unmonitored");
2355                 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm)-1);
2356                 ast_cli(fd, FORMAT, name,
2357                                         peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Unspecified)",
2358                                         peer->dynamic ? "(D)" : "(S)",
2359                                         nm,
2360                                         ntohs(peer->addr.sin_port), status);
2361         }
2362         ast_mutex_unlock(&peerl.lock);
2363         return RESULT_SUCCESS;
2364 #undef FORMAT
2365 #undef FORMAT2
2366 }
2367
2368 /* JDG: callback to display iax peers in manager */
2369 static int manager_iax_show_peers( struct mansession *s, struct message *m )
2370 {
2371         char *a[] = { "iax", "show", "users" };
2372         int ret;
2373         ret = iax_show_peers( s->fd, 3, a );
2374         ast_cli( s->fd, "\r\n" );
2375         return ret;
2376 } /* /JDG */
2377
2378 static char *regstate2str(int regstate)
2379 {
2380         switch(regstate) {
2381         case REG_STATE_UNREGISTERED:
2382                 return "Unregistered";
2383         case REG_STATE_REGSENT:
2384                 return "Request Sent";
2385         case REG_STATE_AUTHSENT:
2386                 return "Auth. Sent";
2387         case REG_STATE_REGISTERED:
2388                 return "Registered";
2389         case REG_STATE_REJECTED:
2390                 return "Rejected";
2391         case REG_STATE_TIMEOUT:
2392                 return "Timeout";
2393         case REG_STATE_NOAUTH:
2394                 return "No Authentication";
2395         default:
2396                 return "Unknown";
2397         }
2398 }
2399
2400 static int iax_show_registry(int fd, int argc, char *argv[])
2401 {
2402 #define FORMAT2 "%-20.20s  %-10.10s  %-20.20s %8.8s  %s\n"
2403 #define FORMAT "%-20.20s  %-10.10s  %-20.20s %8d  %s\n"
2404         struct iax_registry *reg;
2405         char host[80];
2406         char perceived[80];
2407         if (argc != 3)
2408                 return RESULT_SHOWUSAGE;
2409         ast_mutex_lock(&peerl.lock);
2410         ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State");
2411         for (reg = registrations;reg;reg = reg->next) {
2412                 snprintf(host, sizeof(host), "%s:%d", inet_ntoa(reg->addr.sin_addr), ntohs(reg->addr.sin_port));
2413                 if (reg->us.sin_addr.s_addr)
2414                         snprintf(perceived, sizeof(perceived), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
2415                 else
2416                         strcpy(perceived, "<Unregistered>");
2417                 ast_cli(fd, FORMAT, host,
2418                                         reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
2419         }
2420         ast_mutex_unlock(&peerl.lock);
2421         return RESULT_SUCCESS;
2422 #undef FORMAT
2423 #undef FORMAT2
2424 }
2425
2426 static int iax_show_channels(int fd, int argc, char *argv[])
2427 {
2428 #define FORMAT2 "%-15.15s  %-10.10s  %-11.11s  %-11.11s  %-7.7s  %-6.6s  %s\n"
2429 #define FORMAT  "%-15.15s  %-10.10s  %5.5d/%5.5d  %5.5d/%5.5d  %-5.5dms  %-4.4dms  %-6.6s\n"
2430         int x;
2431         int numchans = 0;
2432         if (argc != 3)
2433                 return RESULT_SHOWUSAGE;
2434         ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
2435         for (x=0;x<AST_IAX_MAX_CALLS;x++) {
2436                 ast_mutex_lock(&iaxsl[x]);
2437                 if (iaxs[x]) {
2438                         ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
2439                                                 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
2440                                                 iaxs[x]->callno, iaxs[x]->peercallno,
2441                                                 iaxs[x]->oseqno, iaxs[x]->iseqno,
2442                                                 iaxs[x]->lag,
2443                                                 iaxs[x]->jitter,
2444                                                 ast_getformatname(iaxs[x]->voiceformat) );
2445                         numchans++;
2446                 }
2447                 ast_mutex_unlock(&iaxsl[x]);
2448         }
2449         ast_cli(fd, "%d active IAX channel(s)\n", numchans);
2450         return RESULT_SUCCESS;
2451 #undef FORMAT
2452 #undef FORMAT2
2453 }
2454
2455 static int iax_do_debug(int fd, int argc, char *argv[])
2456 {
2457         if (argc != 2)
2458                 return RESULT_SHOWUSAGE;
2459         iaxdebug = 1;
2460         ast_cli(fd, "IAX Debugging Enabled\n");
2461         return RESULT_SUCCESS;
2462 }
2463
2464 static int iax_no_debug(int fd, int argc, char *argv[])
2465 {
2466         if (argc != 3)
2467                 return RESULT_SHOWUSAGE;
2468         iaxdebug = 0;
2469         ast_cli(fd, "IAX Debugging Disabled\n");
2470         return RESULT_SUCCESS;
2471 }
2472
2473
2474
2475 static char show_users_usage[] =
2476 "Usage: iax show users\n"
2477 "       Lists all users known to the IAX (Inter-Asterisk eXchange) subsystem.\n";
2478
2479 static char show_channels_usage[] =
2480 "Usage: iax show channels\n"
2481 "       Lists all currently active IAX channels.\n";
2482
2483 static char show_peers_usage[] =
2484 "Usage: iax show peers\n"
2485 "       Lists all known IAX peers.\n";
2486
2487 static char show_reg_usage[] =
2488 "Usage: iax show registry\n"
2489 "       Lists all registration requests and status.\n";
2490
2491 #ifdef DEBUG_SUPPORT
2492
2493 static char debug_usage[] =
2494 "Usage: iax debug\n"
2495 "       Enables dumping of IAX packets for debugging purposes\n";
2496
2497 static char no_debug_usage[] =
2498 "Usage: iax no debug\n"
2499 "       Disables dumping of IAX packets for debugging purposes\n";
2500
2501 #endif
2502
2503 static struct ast_cli_entry  cli_show_users =
2504         { { "iax", "show", "users", NULL }, iax_show_users, "Show defined IAX users", show_users_usage };
2505 static struct ast_cli_entry  cli_show_channels =
2506         { { "iax", "show", "channels", NULL }, iax_show_channels, "Show active IAX channels", show_channels_usage };
2507 static struct ast_cli_entry  cli_show_peers =
2508         { { "iax", "show", "peers", NULL }, iax_show_peers, "Show defined IAX peers", show_peers_usage };
2509 static struct ast_cli_entry  cli_show_registry =
2510         { { "iax", "show", "registry", NULL }, iax_show_registry, "Show IAX registration status", show_reg_usage };
2511 static struct ast_cli_entry  cli_debug =
2512         { { "iax", "debug", NULL }, iax_do_debug, "Enable IAX debugging", debug_usage };
2513 static struct ast_cli_entry  cli_no_debug =
2514         { { "iax", "no", "debug", NULL }, iax_no_debug, "Disable IAX debugging", no_debug_usage };
2515
2516 static int iax_write(struct ast_channel *c, struct ast_frame *f)
2517 {
2518         struct chan_iax_pvt *i = c->pvt->pvt;
2519         if (!i)
2520                 return -1;
2521         /* If there's an outstanding error, return failure now */
2522         if (i->error) {
2523                 ast_log(LOG_DEBUG, "Write error: %s\n", strerror(errno));
2524                 return -1;
2525         }
2526         /* If it's already gone, just return */
2527         if (i->alreadygone)
2528                 return 0;
2529         /* Don't waste bandwidth sending null frames */
2530         if (f->frametype == AST_FRAME_NULL)
2531                 return 0;
2532         /* If we're quelching voice, don't bother sending it */
2533         if ((f->frametype == AST_FRAME_VOICE) && i->quelch)
2534                 return 0;
2535         /* Simple, just queue for transmission */
2536         return iax_send(i, f, 0, -1, 0, 0, 0);
2537 }
2538
2539 static int __send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno,
2540                 int now, int transfer, int final)
2541 {
2542         struct ast_frame f;
2543         f.frametype = type;
2544         f.subclass = command;
2545         f.datalen = datalen;
2546         f.samples = 0;
2547         f.mallocd = 0;
2548         f.offset = 0;
2549         f.src = __FUNCTION__;
2550         f.data = data;
2551         return iax_send(i, &f, ts, seqno, now, transfer, final);
2552 }
2553
2554 static int send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2555 {
2556         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0);
2557 }
2558
2559 #ifdef BRIDGE_OPTIMIZATION
2560 static int forward_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2561 {
2562         return __send_command(iaxs[i->bridgecallno], type, command, ts, data, datalen, seqno, 0, 0, 0);
2563 }
2564 #endif
2565
2566 static int send_command_final(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2567 {
2568         /* It is assumed that the callno has already been locked */
2569         iax_predestroy_nolock(i->callno);
2570         return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1);
2571 }
2572
2573 static int send_command_immediate(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
2574 {
2575         return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0);
2576 }
2577
2578 static int send_command_transfer(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen)
2579 {
2580         return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0);
2581 }
2582
2583 static int apply_context(struct iax_context *con, char *context)
2584 {
2585         while(con) {
2586                 if (!strcmp(con->context, context))
2587                         return -1;
2588                 con = con->next;
2589         }
2590         return 0;
2591 }
2592
2593 static int iax_getformats(int callno, char *orequest)
2594 {
2595         char *var, *value;
2596         char request[256];
2597         char *stringp=NULL;
2598         strncpy(request, orequest, sizeof(request)-1);
2599         stringp=request;
2600         var = strsep(&stringp, ";");
2601         while(var) {
2602                 value = strchr(var, '=');
2603                 if (value) {
2604                         *value='\0';
2605                         value++;
2606                         if (!strcmp(var, "formats")) {
2607                                 iaxs[callno]->peerformat = atoi(value);
2608                         } else
2609                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2610                 }
2611                 var = strsep(&stringp, ";");
2612         }
2613         return 0;
2614 }
2615
2616
2617 static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int requestl)
2618 {
2619         /* Start pessimistic */
2620         int res = -1;
2621         int version = 1;
2622         char *var, *value;
2623         struct iax_user *user;
2624         char request[256];
2625         int gotcapability=0;
2626         char *stringp=NULL;
2627         strncpy(request, orequest, sizeof(request)-1);
2628         if (!iaxs[callno])
2629                 return res;
2630         stringp=request;
2631         var = strsep(&stringp, ";");
2632         while(var) {
2633                 value = strchr(var, '=');
2634                 if (value) {
2635                         *value='\0';
2636                         value++;
2637                         if (!strcmp(var, "exten"))
2638                                 strncpy(iaxs[callno]->exten, value, sizeof(iaxs[callno]->exten)-1);
2639                         else if (!strcmp(var, "callerid"))
2640                                 strncpy(iaxs[callno]->callerid, value, sizeof(iaxs[callno]->callerid)-1);
2641                         else if (!strcmp(var, "ani"))
2642                                 strncpy(iaxs[callno]->ani, value, sizeof(iaxs[callno]->ani) - 1);
2643                         else if (!strcmp(var, "dnid"))
2644                                 strncpy(iaxs[callno]->dnid, value, sizeof(iaxs[callno]->dnid)-1);
2645                         else if (!strcmp(var, "context"))
2646                                 strncpy(iaxs[callno]->context, value, sizeof(iaxs[callno]->context)-1);
2647                         else if (!strcmp(var, "language"))
2648                                 strncpy(iaxs[callno]->language, value, sizeof(iaxs[callno]->language)-1);
2649                         else if (!strcmp(var, "username"))
2650                                 strncpy(iaxs[callno]->username, value, sizeof(iaxs[callno]->username)-1);
2651                         else if (!strcmp(var, "formats"))
2652                                 iaxs[callno]->peerformat = atoi(value);
2653                         else if (!strcmp(var, "adsicpe"))
2654                                 iaxs[callno]->peeradsicpe = atoi(value);
2655                         else if (!strcmp(var, "capability")) {
2656                                 gotcapability = 1;
2657                                 iaxs[callno]->peercapability = atoi(value);
2658                         } else if (!strcmp(var, "version"))
2659                                 version = atoi(value);
2660                         else
2661                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2662                 }
2663                 var = strsep(&stringp, ";");
2664         }
2665         if (!gotcapability)
2666                 iaxs[callno]->peercapability = iaxs[callno]->peerformat;
2667         if (version > AST_IAX_PROTO_VERSION) {
2668                 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
2669                         inet_ntoa(sin->sin_addr), version);
2670                 return res;
2671         }
2672         ast_mutex_lock(&userl.lock);
2673         /* Search the userlist for a compatible entry, and fill in the rest */
2674         user = userl.users;
2675         while(user) {
2676                 if ((!strlen(iaxs[callno]->username) ||                         /* No username specified */
2677                         !strcmp(iaxs[callno]->username, user->name))    /* Or this username specified */
2678                         && ast_apply_ha(user->ha, sin)  /* Access is permitted from this IP */
2679                         && (!strlen(iaxs[callno]->context) ||                   /* No context specified */
2680                              apply_context(user->contexts, iaxs[callno]->context))) {                   /* Context is permitted */
2681                         break;
2682                 }
2683                 user = user->next;
2684         }
2685 #ifdef MYSQL_FRIENDS
2686         if (!user && mysql && strlen(iaxs[callno]->username) && (strlen(iaxs[callno]->username) < 128)) {
2687                 user = mysql_user(iaxs[callno]->username);
2688                 if (user && strlen(iaxs[callno]->context) &&                    /* No context specified */
2689                              !apply_context(user->contexts, iaxs[callno]->context)) {                   /* Context is permitted */
2690                         if (user->contexts)
2691                                 free(user->contexts);
2692                         free(user);
2693                         user = NULL;
2694                 }
2695         }
2696 #endif
2697         ast_mutex_unlock(&userl.lock);
2698         if (user) {
2699                 /* We found our match (use the first) */
2700
2701                 /* Store the requested username if not specified */
2702                 if (!strlen(iaxs[callno]->username))
2703                         strncpy(iaxs[callno]->username, user->name, sizeof(iaxs[callno]->username)-1);
2704                 /* And use the default context */
2705                 if (!strlen(iaxs[callno]->context)) {
2706                         if (user->contexts)
2707                                 strncpy(iaxs[callno]->context, user->contexts->context, sizeof(iaxs[callno]->context)-1);
2708                         else
2709                                 strncpy(iaxs[callno]->context, context, sizeof(iaxs[callno]->context)-1);
2710                 }
2711                 /* Copy the secret */
2712                 strncpy(iaxs[callno]->secret, user->secret, sizeof(iaxs[callno]->secret)-1);
2713                 /* And any input keys */
2714                 strncpy(iaxs[callno]->inkeys, user->inkeys, sizeof(iaxs[callno]->inkeys));
2715                 /* And the permitted authentication methods */
2716                 strncpy(iaxs[callno]->methods, user->methods, sizeof(iaxs[callno]->methods)-1);
2717                 /* If they have callerid, override the given caller id.  Always store the ANI */
2718                 if (strlen(iaxs[callno]->callerid)) {
2719                         if (user->hascallerid)
2720                                 strncpy(iaxs[callno]->callerid, user->callerid, sizeof(iaxs[callno]->callerid)-1);
2721                         strncpy(iaxs[callno]->ani, user->callerid, sizeof(iaxs[callno]->ani)-1);
2722                 }
2723                 if (strlen(user->accountcode))
2724                         strncpy(iaxs[callno]->accountcode, user->accountcode, sizeof(iaxs[callno]->accountcode)-1);
2725                 if (user->amaflags)
2726                         iaxs[callno]->amaflags = user->amaflags;
2727                 res = 0;
2728         }
2729         return res;
2730 }
2731
2732 static int raw_hangup(struct sockaddr_in *sin, short src, short dst)
2733 {
2734         struct ast_iax_full_hdr fh;
2735         fh.callno = htons(src | AST_FLAG_FULL);
2736         fh.dcallno = htons(dst);
2737         fh.ts = 0;
2738         fh.seqno = 0;
2739         fh.type = AST_FRAME_IAX;
2740         fh.csub = compress_subclass(AST_IAX_COMMAND_INVAL);
2741 #if 0
2742         if (option_debug)
2743 #endif
2744                 ast_log(LOG_DEBUG, "Raw Hangup %s:%d, src=%d, dst=%d\n",
2745                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), src, dst);
2746         return sendto(netsocket, &fh, sizeof(fh), 0, (struct sockaddr *)sin, sizeof(*sin));
2747 }
2748
2749 static int authenticate_request(struct chan_iax_pvt *p)
2750 {
2751         char requeststr[256] = "";
2752         MYSNPRINTF "methods=%s;", p->methods);
2753         if (strstr(p->methods, "md5") || strstr(p->methods, "rsa")) {
2754                 /* Build the challenge */
2755                 snprintf(p->challenge, sizeof(p->challenge), "%d", rand());
2756                 MYSNPRINTF "challenge=%s;", p->challenge);
2757         }
2758         MYSNPRINTF "username=%s;", p->username);
2759         if (strlen(requeststr))
2760                 requeststr[strlen(requeststr) - 1] = '\0';
2761         return send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREQ, 0, requeststr, strlen(requeststr) + 1, -1);
2762 }
2763
2764 static int authenticate_verify(struct chan_iax_pvt *p, char *orequest)
2765 {
2766         char requeststr[256] = "";
2767         char *var, *value, request[256];
2768         char md5secret[256] = "";
2769         char secret[256] = "";
2770         char rsasecret[256] = "";
2771         int res = -1;
2772         int x;
2773         char *stringp=NULL;
2774
2775         if (!(p->state & IAX_STATE_AUTHENTICATED))
2776                 return res;
2777         strncpy(request, orequest, sizeof(request)-1);
2778         stringp=request;
2779         var = strsep(&stringp, ";");
2780         while(var) {
2781                 value = strchr(var, '=');
2782                 if (value) {
2783                         *value='\0';
2784                         value++;
2785                         if (!strcmp(var, "secret"))
2786                                 strncpy(secret, value, sizeof(secret)-1);
2787                         else if (!strcmp(var, "md5secret"))
2788                                 strncpy(md5secret, value, sizeof(md5secret)-1);
2789                         else if (!strcmp(var, "rsasecret"))
2790                                 strncpy(rsasecret, value, sizeof(rsasecret)-1);
2791                         else
2792                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2793                 }
2794                 var = strsep(&stringp, ";");
2795         }
2796         if (strstr(p->methods, "rsa") && strlen(rsasecret) && strlen(p->inkeys)) {
2797                 struct ast_key *key;
2798                 char *keyn;
2799                 char tmpkey[256];
2800                 char *stringp=NULL;
2801                 strncpy(tmpkey, p->inkeys, sizeof(tmpkey));
2802                 stringp=tmpkey;
2803                 keyn = strsep(&stringp, ":");
2804                 while(keyn) {
2805                         key = ast_key_get(keyn, AST_KEY_PUBLIC);
2806                         if (key && !ast_check_signature(key, p->challenge, rsasecret)) {
2807                                 res = 0;
2808                                 break;
2809                         } else if (!key)
2810                                 ast_log(LOG_WARNING, "requested inkey '%s' for RSA authentication does not exist\n", keyn);
2811                         keyn = strsep(&stringp, ":");
2812                 }
2813         } else if (strstr(p->methods, "md5")) {
2814                 struct MD5Context md5;
2815                 unsigned char digest[16];
2816                 MD5Init(&md5);
2817                 MD5Update(&md5, p->challenge, strlen(p->challenge));
2818                 MD5Update(&md5, p->secret, strlen(p->secret));
2819                 MD5Final(digest, &md5);
2820                 /* If they support md5, authenticate with it.  */
2821                 for (x=0;x<16;x++)
2822                         MYSNPRINTF "%2.2x", digest[x]);
2823                 if (!strcasecmp(requeststr, md5secret))
2824                         res = 0;
2825         } else if (strstr(p->methods, "plaintext")) {
2826                 if (!strcmp(secret, p->secret))
2827                         res = 0;
2828         }
2829         return res;
2830 }
2831
2832 static int register_verify(int callno, struct sockaddr_in *sin, char *orequest)
2833 {
2834         char request[256];
2835         char requeststr[256] = "";
2836         char peer[256] = "";
2837         char md5secret[256] = "";
2838         char rsasecret[256] = "";
2839         char secret[256] = "";
2840         struct iax_peer *p;
2841         struct ast_key *key;
2842         char *var;
2843         char *value;
2844         char *keyn;
2845         int x;
2846         int expire = 0;
2847         char *stringp=NULL;
2848
2849         iaxs[callno]->state &= ~IAX_STATE_AUTHENTICATED;
2850         strcpy(iaxs[callno]->peer, "");
2851         if (!orequest)
2852                 return -1;
2853         strncpy(request, orequest, sizeof(request)-1);
2854         stringp=request;
2855         var = strsep(&stringp, ";");
2856         while(var) {
2857                 value = strchr(var, '=');
2858                 if (value) {
2859                         *value='\0';
2860                         value++;
2861                         if (!strcmp(var, "peer"))
2862                                 strncpy(peer, value, sizeof(peer)-1);
2863                         else if (!strcmp(var, "md5secret"))
2864                                 strncpy(md5secret, value, sizeof(md5secret)-1);
2865                         else if (!strcmp(var, "rsasecret"))
2866                                 strncpy(rsasecret, value, sizeof(rsasecret)-1);
2867                         else if (!strcmp(var, "secret"))
2868                                 strncpy(secret, value, sizeof(secret)-1);
2869                         else if (!strcmp(var, "refresh"))
2870                                 expire = atoi(value);
2871                         else
2872                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
2873                 }
2874                 var = strsep(&stringp, ";");
2875         }
2876
2877         if (!strlen(peer)) {
2878                 ast_log(LOG_NOTICE, "Empty registration from %s\n", inet_ntoa(sin->sin_addr));
2879                 return -1;
2880         }
2881
2882         for (p = peerl.peers; p ; p = p->next)
2883                 if (!strcasecmp(p->name, peer))
2884                         break;
2885
2886 #ifdef MYSQL_FRIENDS
2887         if (!p)
2888                 p = mysql_peer(peer);
2889 #endif
2890         if (!p) {
2891                 ast_log(LOG_NOTICE, "No registration for peer '%s' (from %s)\n", peer, inet_ntoa(sin->sin_addr));
2892                 return -1;
2893         }
2894
2895         if (!p->dynamic) {
2896                 ast_log(LOG_NOTICE, "Peer '%s' is not dynamic (from %s)\n", peer, inet_ntoa(sin->sin_addr));
2897                 if (p->delme)
2898                         free(p);
2899                 return -1;
2900         }
2901
2902         if (!ast_apply_ha(p->ha, sin)) {
2903                 ast_log(LOG_NOTICE, "Host %s denied access to register peer '%s'\n", inet_ntoa(sin->sin_addr), p->name);
2904                 if (p->delme)
2905                         free(p);
2906                 return -1;
2907         }
2908         strncpy(iaxs[callno]->secret, p->secret, sizeof(iaxs[callno]->secret)-1);
2909         strncpy(iaxs[callno]->inkeys, p->inkeys, sizeof(iaxs[callno]->inkeys)-1);
2910         /* Check secret against what we have on file */
2911         if (strlen(rsasecret) && strstr(p->methods, "rsa") && strlen(iaxs[callno]->challenge)) {
2912                 if (strlen(p->inkeys)) {
2913                         char tmpkeys[256];
2914                         char *stringp=NULL;
2915                         strncpy(tmpkeys, p->inkeys, sizeof(tmpkeys));
2916                         stringp=tmpkeys;
2917                         keyn = strsep(&stringp, ":");
2918                         while(keyn) {
2919                                 key = ast_key_get(keyn, AST_KEY_PUBLIC);
2920                                 if (key && !ast_check_signature(key, iaxs[callno]->challenge, rsasecret)) {
2921                                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2922                                         break;
2923                                 } else if (!key)
2924                                         ast_log(LOG_WARNING, "requested inkey '%s' does not exist\n", keyn);
2925                                 keyn = strsep(&stringp, ":");
2926                         }
2927                         if (!keyn) {
2928                                 ast_log(LOG_NOTICE, "Host %s failed RSA authentication with inkeys '%s'\n", peer, p->inkeys);
2929                                 if (p->delme)
2930                                         free(p);
2931                                 return -1;
2932                         }
2933                 } else {
2934                         ast_log(LOG_NOTICE, "Host '%s' trying to do RSA authentication, but we have no inkeys\n", peer);
2935                         if (p->delme)
2936                                 free(p);
2937                         return -1;
2938                 }
2939         } else if (strlen(secret) && strstr(p->methods, "plaintext")) {
2940                 /* They've provided a plain text password and we support that */
2941                 if (strcmp(secret, p->secret)) {
2942                         ast_log(LOG_NOTICE, "Host %s did not provide proper plaintext password for '%s'\n", inet_ntoa(sin->sin_addr), p->name);
2943                         if (p->delme)
2944                                 free(p);
2945                         return -1;
2946                 } else
2947                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2948         } else if (strlen(md5secret) && strstr(p->methods, "md5") && strlen(iaxs[callno]->challenge)) {
2949                 struct MD5Context md5;
2950                 unsigned char digest[16];
2951                 MD5Init(&md5);
2952                 MD5Update(&md5, iaxs[callno]->challenge, strlen(iaxs[callno]->challenge));
2953                 MD5Update(&md5, p->secret, strlen(p->secret));
2954                 MD5Final(digest, &md5);
2955                 for (x=0;x<16;x++)
2956                         MYSNPRINTF "%2.2x", digest[x]);
2957                 if (strcasecmp(requeststr, md5secret)) {
2958                         ast_log(LOG_NOTICE, "Host %s failed MD5 authentication for '%s' (%s != %s)\n", inet_ntoa(sin->sin_addr), p->name, requeststr, md5secret);
2959                         if (p->delme)
2960                                 free(p);
2961                         return -1;
2962                 } else
2963                         iaxs[callno]->state |= IAX_STATE_AUTHENTICATED;
2964         } else if (strlen(md5secret) || strlen(secret)) {
2965                 ast_log(LOG_NOTICE, "Inappropriate authentication received\n");
2966                 if (p->delme)
2967                         free(p);
2968                 return -1;
2969         }
2970         strncpy(iaxs[callno]->peer, peer, sizeof(iaxs[callno]->peer)-1);
2971         /* Choose lowest expirey number */
2972         if (expire && (expire < iaxs[callno]->expirey))
2973                 iaxs[callno]->expirey = expire;
2974         if (p->delme)
2975                 free(p);
2976         return 0;
2977
2978 }
2979
2980 static int authenticate(char *challenge, char *secret, char *keyn, char *methods, char *requeststr, int reqsize, struct sockaddr_in *sin)
2981 {
2982         int res = -1;
2983         int x;
2984         if (keyn && strlen(keyn)) {
2985                 if (!strstr(methods, "rsa")) {
2986                         if (!secret || !strlen(secret))
2987                                 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));
2988                 } else if (!strlen(challenge)) {
2989                         ast_log(LOG_NOTICE, "No challenge provided for RSA authentication to %s\n", inet_ntoa(sin->sin_addr));
2990                 } else {
2991                         char sig[256];
2992                         struct ast_key *key;
2993                         key = ast_key_get(keyn, AST_KEY_PRIVATE);
2994                         if (!key) {
2995                                 ast_log(LOG_NOTICE, "Unable to find private key '%s'\n", keyn);
2996                         } else {
2997                                 if (ast_sign(key, challenge, sig)) {
2998                                         ast_log(LOG_NOTICE, "Unable to sign challenge withy key\n");
2999                                         res = -1;
3000                                 } else {
3001                                         MYSNPRINTF2 "rsasecret=%s;", sig);
3002                                         res = 0;
3003                                 }
3004                         }
3005                 }
3006         }
3007         /* Fall back */
3008         if (res && secret && strlen(secret)) {
3009                 if (strstr(methods, "md5") && strlen(challenge)) {
3010                         struct MD5Context md5;
3011                         unsigned char digest[16];
3012                         MD5Init(&md5);
3013                         MD5Update(&md5, challenge, strlen(challenge));
3014                         MD5Update(&md5, secret, strlen(secret));
3015                         MD5Final(digest, &md5);
3016                         /* If they support md5, authenticate with it.  */
3017                         MYSNPRINTF2 "md5secret=");
3018                         for (x=0;x<16;x++)
3019                                 MYSNPRINTF2 "%2.2x", digest[x]);
3020                         MYSNPRINTF2 ";");
3021                         res = 0;
3022                 } else if (strstr(methods, "plaintext")) {
3023                         MYSNPRINTF2 "secret=%s;", secret);
3024                         res = 0;
3025                 } else
3026                         ast_log(LOG_NOTICE, "No way to send secret to peer '%s' (their methods: %s)\n", inet_ntoa(sin->sin_addr), methods);
3027         }
3028         return res;
3029 }
3030
3031 static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, char *orequest, char *override, char *okey)
3032 {
3033         struct iax_peer *peer;
3034         /* Start pessimistic */
3035         int res = -1;
3036         char request[256];
3037         char methods[80] = "";
3038         char requeststr[256] = "";
3039         char *var, *value;
3040         char *stringp=NULL;
3041
3042         strncpy(request, orequest, sizeof(request)-1);
3043         stringp=request;
3044         var = strsep(&stringp, ";");
3045         while(var) {
3046                 value = strchr(var, '=');
3047                 if (value) {
3048                         *value='\0';
3049                         value++;
3050                         if (!strcmp(var, "username"))
3051                                 strncpy(p->username, value, sizeof(p->username)-1);
3052                         else if (!strcmp(var, "challenge"))
3053                                 strncpy(p->challenge, value, sizeof(p->challenge)-1);
3054                         else if (!strcmp(var, "methods"))
3055                                 strncpy(methods, value, sizeof(methods)-1);
3056                         else
3057                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3058                 }
3059                 var = strsep(&stringp, ";");
3060         }
3061
3062         /* Check for override RSA authentication first */
3063         if ((override && strlen(override)) || (okey && strlen(okey))) {
3064                 /* Normal password authentication */
3065                 res = authenticate(p->challenge, override, okey, methods, requeststr, sizeof(requeststr), sin);
3066         } else {
3067                 ast_mutex_lock(&peerl.lock);
3068                 peer = peerl.peers;
3069                 while(peer) {
3070                         if ((!strlen(p->peer) || !strcmp(p->peer, peer->name))
3071                                                                 /* No peer specified at our end, or this is the peer */
3072                          && (!strlen(peer->username) || (!strcmp(peer->username, p->username)))
3073                                                                 /* No username specified in peer rule, or this is the right username */
3074                          && (!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)))
3075                                                                 /* No specified host, or this is our host */
3076                         ) {
3077                                 res = authenticate(p->challenge, peer->secret, peer->outkey, methods, requeststr, sizeof(requeststr), sin);
3078                                 if (!res)
3079                                         break;
3080                         }
3081                         peer = peer->next;
3082                 }
3083                 ast_mutex_unlock(&peerl.lock);
3084         }
3085         if (strlen(requeststr))
3086                 requeststr[strlen(requeststr)-1] = '\0';
3087         if (!res)
3088                 res = send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREP, 0, requeststr, strlen(requeststr) + 1, -1);
3089         return res;
3090 }
3091
3092 static int iax_do_register(struct iax_registry *reg);
3093
3094 static int iax_do_register_s(void *data)
3095 {
3096         struct iax_registry *reg = data;
3097         reg->expire = -1;
3098         iax_do_register(reg);
3099         return 0;
3100 }
3101
3102 static int try_transfer(struct chan_iax_pvt *pvt, char *orequest)
3103 {
3104         int newport = 0;
3105         int newcall = 0;
3106         char newip[256] = "";
3107         char request[256] = "";
3108         char *var, *value;
3109
3110         struct sockaddr_in new;
3111         char *stringp=NULL;
3112
3113         if (!orequest)
3114                 return -1;
3115
3116         strncpy(request, orequest, sizeof(request)-1);
3117         stringp=request;
3118         var = strsep(&stringp, ";");
3119         while(var) {
3120                 value = strchr(var, '=');
3121                 if (value) {
3122                         *value='\0';
3123                         value++;
3124                         if (!strcmp(var, "remip"))
3125                                 strncpy(newip, value, sizeof(newip)-1);
3126                         else if (!strcmp(var, "remport"))
3127                                 newport = atoi(value);
3128                         else if (!strcmp(var, "remcall"))
3129                                 newcall = atoi(value);
3130                         else
3131                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3132                 }
3133                 var = strsep(&stringp, ";");
3134         }
3135         if (!newcall || !inet_aton(newip, &new.sin_addr) || !newport) {
3136                 ast_log(LOG_WARNING, "Invalid transfer request\n");
3137                 return -1;
3138         }
3139         pvt->transfercallno = newcall;
3140         inet_aton(newip, &pvt->transfer.sin_addr);
3141         pvt->transfer.sin_port = htons(newport);
3142         pvt->transfer.sin_family = AF_INET;
3143         pvt->transferring = TRANSFER_BEGIN;
3144         send_command_transfer(pvt, AST_FRAME_IAX, AST_IAX_COMMAND_TXCNT, 0, NULL, 0);
3145         return 0;
3146 }
3147
3148 static int complete_dpreply(struct chan_iax_pvt *pvt, char *orequest)
3149 {
3150         char *var, *value;
3151         char request[256] = "";
3152         char exten[256] = "";
3153         int status = CACHE_FLAG_UNKNOWN;
3154         int expirey = iaxdefaultdpcache;
3155         int x;
3156         int matchmore = 0;
3157         struct iax_dpcache *dp, *prev;
3158         char *stringp=NULL;
3159
3160         strncpy(request, orequest, sizeof(request)-1);
3161         stringp=request;
3162         var = strsep(&stringp, ";");
3163         while(var) {
3164                 value = strchr(var, '=');
3165                 if (value) {
3166                         *value='\0';
3167                         value++;
3168                         if (!strcmp(var, "number"))
3169                                 strncpy(exten, value, sizeof(exten)-1);
3170                         else if (!strcmp(var, "status")) {
3171                                 if (!strcasecmp(value, "exists"))
3172                                         status = CACHE_FLAG_EXISTS;
3173                                 else if (!strcasecmp(value, "nonexistant"))
3174                                         status = CACHE_FLAG_NONEXISTANT;
3175                                 else if (!strcasecmp(value, "canexist"))
3176                                         status = CACHE_FLAG_CANEXIST;
3177                                 else
3178                                         ast_log(LOG_WARNING, "Unknown status '%s'\n", value);
3179                         } else if (!strcmp(var, "expirey"))
3180                                 expirey = atoi(value);
3181                         else if (!strcmp(var, "ignorepat")) {
3182                                 /* Don' really do much with it */
3183                         } else if (!strcmp(var, "matchmore")) {
3184                                 matchmore = CACHE_FLAG_MATCHMORE;
3185                         } else
3186                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3187                 }
3188                 var = strsep(&stringp, ";");
3189         }
3190         ast_mutex_lock(&dpcache_lock);
3191         prev = NULL;
3192         dp = pvt->dpentries;
3193         while(dp) {
3194                 if (!strcmp(dp->exten, exten)) {
3195                         /* Let them go */
3196                         if (prev)
3197                                 prev->peer = dp->peer;
3198                         else
3199                                 pvt->dpentries = dp->peer;
3200                         dp->peer = NULL;
3201                         dp->callno = -1;
3202                         dp->expirey.tv_sec = dp->orig.tv_sec + expirey;
3203                         if (dp->flags & CACHE_FLAG_PENDING) {
3204                                 dp->flags &= ~CACHE_FLAG_PENDING;
3205                                 dp->flags |= status;
3206                                 dp->flags |= CACHE_FLAG_MATCHMORE;
3207                         }
3208                         /* Wake up waiters */
3209                         for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
3210                                 if (dp->waiters[x] > -1)
3211                                         write(dp->waiters[x], "asdf", 4);
3212                 }
3213                 prev = dp;
3214                 dp = dp->peer;
3215         }
3216         ast_mutex_unlock(&dpcache_lock);
3217         return 0;
3218 }
3219
3220 static int complete_transfer(int callno, char *orequest)
3221 {
3222         int peercallno = -1;
3223         char request[256] = "";
3224         char *var, *value;
3225         struct chan_iax_pvt *pvt = iaxs[callno];
3226         struct ast_iax_frame *cur;
3227         char *stringp=NULL;
3228         if (!orequest)
3229                 return -1;
3230
3231         strncpy(request, orequest, sizeof(request)-1);
3232         stringp=request;
3233         var = strsep(&stringp, ";");
3234         while(var) {
3235                 value = strchr(var, '=');
3236                 if (value) {
3237                         *value='\0';
3238                         value++;
3239                         if (!strcmp(var, "peercallno"))
3240                                 peercallno = atoi(value);
3241                         else
3242                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3243                 }
3244                 var = strsep(&stringp, ";");
3245         }
3246         if (peercallno < 0) {
3247                 ast_log(LOG_WARNING, "Invalid transfer request\n");
3248                 return -1;
3249         }
3250         memcpy(&pvt->addr, &pvt->transfer, sizeof(pvt->addr));
3251         memset(&pvt->transfer, 0, sizeof(pvt->transfer));
3252         /* Reset sequence numbers */
3253         pvt->oseqno = 0;
3254         pvt->iseqno = 0;
3255         pvt->peercallno = peercallno;
3256         pvt->transferring = TRANSFER_NONE;
3257         pvt->svoiceformat = -1;
3258         pvt->voiceformat = 0;
3259         pvt->transfercallno = -1;
3260         memset(&pvt->rxcore, 0, sizeof(pvt->rxcore));
3261         memset(&pvt->offset, 0, sizeof(pvt->offset));
3262         memset(&pvt->history, 0, sizeof(pvt->history));
3263         pvt->jitterbuffer = 0;
3264         pvt->jitter = 0;
3265         pvt->historicjitter = 0;
3266         pvt->lag = 0;
3267         pvt->last = 0;
3268         pvt->lastsent = 0;
3269         pvt->pingtime = DEFAULT_RETRY_TIME;
3270         ast_mutex_lock(&iaxq.lock);
3271         for (cur = iaxq.head; cur ; cur = cur->next) {
3272                 /* We must cancel any packets that would have been transmitted
3273                    because now we're talking to someone new.  It's okay, they
3274                    were transmitted to someone that didn't care anyway. */
3275                 if (callno == cur->callno)
3276                         cur->retries = -1;
3277         }
3278         ast_mutex_unlock(&iaxq.lock);
3279         return 0;
3280 }
3281
3282 static int iax_ack_registry(char *orequest, struct sockaddr_in *sin, int callno)
3283 {
3284         struct iax_registry *reg;
3285         /* Start pessimistic */
3286         char request[256] = "";
3287         char peer[256] = "";
3288         int ourport = 0;
3289         int refresh = 0;
3290         char ourip[256] = "<Unspecified>";
3291         struct sockaddr_in oldus;
3292         char *var, *value;
3293         char *stringp=NULL;
3294
3295         if (!orequest)
3296                 return -1;
3297
3298         strncpy(request, orequest, sizeof(request)-1);
3299         stringp=request;
3300         var = strsep(&stringp, ";");
3301         while(var) {
3302                 value = strchr(var, '=');
3303                 if (value) {
3304                         *value='\0';
3305                         value++;
3306                         if (!strcmp(var, "yourip"))
3307                                 strncpy(ourip, value, sizeof(ourip)-1);
3308                         else if (!strcmp(var, "peer"))
3309                                 strncpy(peer, value, sizeof(peer)-1);
3310                         else if (!strcmp(var, "yourport"))
3311                                 ourport = atoi(value);
3312                         else if (!strcmp(var, "refresh"))
3313                                 refresh = atoi(value);
3314                         else if (!strcmp(var, "callerid")) {
3315                                 /* We don't really care about suggested Caller*ID, that's more for phones */
3316                         } else
3317                                 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
3318                 }
3319                 var = strsep(&stringp, ";");
3320         }
3321         reg = iaxs[callno]->reg;
3322                         memcpy(&oldus, &reg->us, sizeof(oldus));
3323                         if (memcmp(&reg->addr, sin, sizeof(&reg->addr))) {
3324                                 ast_log(LOG_WARNING, "Received unsolicited registry ack from '%s'\n", inet_ntoa(sin->sin_addr));
3325                                 return -1;
3326                         }
3327                         if (!inet_aton(ourip, &reg->us.sin_addr)) {
3328                                 ast_log(LOG_WARNING, "Registry ack from '%s' contains invalid IP '%s'\n", inet_ntoa(sin->sin_addr), ourip);
3329                                 return -1;
3330                         }
3331                         reg->us.sin_port = htons(ourport);
3332                         if (refresh && (reg->refresh < refresh)) {
3333                                 /* Refresh faster if necessary */
3334                                 reg->refresh = refresh;
3335                                 if (reg->expire > -1)
3336                                         ast_sched_del(sched, reg->expire);
3337                                 reg->expire = ast_sched_add(sched, (5 * reg->refresh / 6) * 1000, iax_do_register_s, reg);
3338                         }
3339                         if (memcmp(&oldus, &reg->us, sizeof(oldus)) && (option_verbose > 2)) {
3340                                 snprintf(ourip, sizeof(ourip), "%s:%d", inet_ntoa(reg->us.sin_addr), ntohs(reg->us.sin_port));
3341                                 ast_verbose(VERBOSE_PREFIX_3 "Registered to '%s', who sees us as %s\n", inet_ntoa(sin->sin_addr), ourip);
3342                         }
3343                         reg->regstate = REG_STATE_REGISTERED;
3344                         return 0;
3345         ast_log(LOG_WARNING, "Registry acknowledge on unknown registery '%s'\n", peer);
3346         return -1;
3347 }
3348
3349 static int iax_register(char *value, int lineno)
3350 {
3351         struct iax_registry *reg;
3352         char copy[256];
3353         char *username, *hostname, *secret;
3354         char *porta;
3355         char *stringp=NULL;
3356
3357         struct hostent *hp;
3358         if (!value)
3359                 return -1;
3360         strncpy(copy, value, sizeof(copy)-1);
3361         stringp=copy;
3362         username = strsep(&stringp, "@");
3363         hostname = strsep(&stringp, "@");
3364         if (!hostname) {
3365                 ast_log(LOG_WARNING, "Format for registration is user[:secret]@host[:port] at line %d", lineno);
3366                 return -1;
3367         }
3368         stringp=username;
3369         username = strsep(&stringp, ":");
3370         secret = strsep(&stringp, ":");
3371         stringp=hostname;
3372         hostname = strsep(&stringp, ":");
3373         porta = strsep(&stringp, ":");
3374
3375         if (porta && !atoi(porta)) {
3376                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
3377                 return -1;
3378         }
3379         hp = gethostbyname(hostname);
3380         if (!hp) {
3381                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
3382                 return -1;
3383         }
3384         reg = malloc(sizeof(struct iax_registry));
3385         if (reg) {
3386                 memset(reg, 0, sizeof(struct iax_registry));
3387                 strncpy(reg->username, username, sizeof(reg->username)-1);
3388                 if (secret)
3389                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
3390                 reg->expire = -1;
3391                 reg->refresh = AST_DEFAULT_REG_EXPIRE;
3392                 reg->addr.sin_family = AF_INET;
3393                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
3394                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(AST_DEFAULT_IAX_PORTNO);
3395                 reg->next = registrations;
3396                 reg->callno = -1;
3397                 registrations = reg;
3398         } else {
3399                 ast_log(LOG_ERROR, "Out of memory\n");
3400                 return -1;
3401         }
3402         return 0;
3403 }
3404
3405 static int expire_registry(void *data)
3406 {
3407         struct iax_peer *p = data;
3408         /* Reset the address */
3409         memset(&p->addr, 0, sizeof(p->addr));
3410         /* Reset expire notice */
3411         p->expire = -1;
3412         /* Reset expirey value */
3413         p->expirey = expirey;
3414         if (iax_regfunk)
3415                 iax_regfunk(p->name, 0);
3416         return 0;
3417 }
3418
3419
3420 static int iax_poke_peer(struct iax_peer *peer);
3421
3422
3423 static int update_registry(char *name, struct sockaddr_in *sin, int callno)
3424 {
3425         /* Called from IAX thread only, with proper iaxsl lock */
3426         char requeststr[256] = "";
3427         struct iax_peer *p;
3428         for (p = peerl.peers;p;p = p->next) {
3429                 if (!strcasecmp(name, p->name)) {
3430                         break;
3431                 }
3432         }
3433 #ifdef MYSQL_FRIENDS
3434         if (!p)
3435                 p = mysql_peer(name);
3436 #endif
3437         if (p) {
3438 #ifdef MYSQL_FRIENDS
3439                 if (p->delme)
3440                         mysql_update_peer(name, sin);
3441 #endif
3442                 if (memcmp(&p->addr, sin, sizeof(p->addr))) {
3443                         if (iax_regfunk)
3444                                 iax_regfunk(p->name, 1);
3445                         if  (option_verbose > 2)
3446                                 ast_verbose(VERBOSE_PREFIX_3 "Registered '%s' (%s) at %s:%d\n", p->name,
3447                                         iaxs[callno]->state & IAX_STATE_AUTHENTICATED ? "AUTHENTICATED" : "UNAUTHENTICATED", inet_ntoa(sin->sin_addr), htons(sin->sin_port));
3448                         iax_poke_peer(p);
3449                 }
3450                 /* Update the host */
3451                 memcpy(&p->addr, sin, sizeof(p->addr));
3452                 /* Setup the expirey */
3453                 if (p->expire > -1)
3454                         ast_sched_del(sched, p->expire);
3455                 if (p->expirey)
3456                         p->expire = ast_sched_add(sched, p->expirey * 1000, expire_registry, (void *)p);
3457                 MYSNPRINTF "peer=%s;yourip=%s;yourport=%d;refresh=%d;",
3458                         p->name, inet_ntoa(p->addr.sin_addr), ntohs(p->addr.sin_port), p->expirey);
3459                 if (p->hascallerid)
3460                         MYSNPRINTF "callerid=%s;", p->callerid);
3461                 requeststr[strlen(requeststr)-1] = '\0';
3462                 if (p->delme)
3463                         free(p);
3464                 return send_command_final(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_REGACK, 0, requeststr, strlen(requeststr) + 1, -1);;
3465         }
3466         ast_log(LOG_WARNING, "No such peer '%s'\n", name);
3467         return -1;
3468 }
3469
3470 static int registry_authrequest(char *name, int callno)
3471 {
3472         char requeststr[256] = "";
3473         struct iax_peer *p;
3474         for (p = peerl.peers;p;p = p->next) {
3475                 if (!strcasecmp(name, p->name)) {
3476                         break;
3477                 }
3478         }
3479 #ifdef MYSQL_FRIENDS
3480         if (!p)
3481                 p = mysql_peer(name);
3482 #endif
3483         if (p) {
3484                 MYSNPRINTF "methods=%s;", p->methods);
3485                 if (strstr(p->methods, "md5") || strstr(p->methods, "rsa")) {
3486                         /* Build the challenge */
3487                         snprintf(iaxs[callno]->challenge, sizeof(iaxs[callno]->challenge), "%d", rand());
3488                         MYSNPRINTF "challenge=%s;", iaxs[callno]->challenge);
3489                 }
3490                 MYSNPRINTF "peer=%s;", name);
3491