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