d2707bc4d1b7e5e6a210fc5f03c272e4b1f0d8fe
[asterisk/asterisk.git] / channels / chan_iax2.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Implementation of Inter-Asterisk eXchange Version 2
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \par See also
26  * \arg \ref Config_iax
27  *
28  * \ingroup channel_drivers
29  */
30
31 /*** MODULEINFO
32         <use>zaptel</use>
33         <use>crypto</use>
34  ***/
35
36 #include "asterisk.h"
37
38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
39
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <sys/types.h>
43 #include <sys/mman.h>
44 #include <dirent.h>
45 #include <sys/socket.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <netinet/in_systm.h>
49 #include <netinet/ip.h>
50 #include <sys/time.h>
51 #include <sys/signal.h>
52 #include <signal.h>
53 #include <string.h>
54 #include <strings.h>
55 #include <errno.h>
56 #include <unistd.h>
57 #include <netdb.h>
58 #include <fcntl.h>
59 #include <sys/stat.h>
60 #include <regex.h>
61
62 #include "asterisk/zapata.h"
63
64 #include "asterisk/lock.h"
65 #include "asterisk/frame.h" 
66 #include "asterisk/channel.h"
67 #include "asterisk/logger.h"
68 #include "asterisk/module.h"
69 #include "asterisk/pbx.h"
70 #include "asterisk/sched.h"
71 #include "asterisk/io.h"
72 #include "asterisk/config.h"
73 #include "asterisk/options.h"
74 #include "asterisk/cli.h"
75 #include "asterisk/translate.h"
76 #include "asterisk/md5.h"
77 #include "asterisk/cdr.h"
78 #include "asterisk/crypto.h"
79 #include "asterisk/acl.h"
80 #include "asterisk/manager.h"
81 #include "asterisk/callerid.h"
82 #include "asterisk/app.h"
83 #include "asterisk/astdb.h"
84 #include "asterisk/musiconhold.h"
85 #include "asterisk/features.h"
86 #include "asterisk/utils.h"
87 #include "asterisk/causes.h"
88 #include "asterisk/localtime.h"
89 #include "asterisk/aes.h"
90 #include "asterisk/dnsmgr.h"
91 #include "asterisk/devicestate.h"
92 #include "asterisk/netsock.h"
93 #include "asterisk/stringfields.h"
94 #include "asterisk/linkedlists.h"
95 #include "asterisk/event.h"
96 #include "asterisk/astobj2.h"
97
98 #include "iax2.h"
99 #include "iax2-parser.h"
100 #include "iax2-provision.h"
101 #include "jitterbuf.h"
102
103 /* Define SCHED_MULTITHREADED to run the scheduler in a special
104    multithreaded mode. */
105 #define SCHED_MULTITHREADED
106
107 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
108    thread is actually doing. */
109 #define DEBUG_SCHED_MULTITHREAD
110
111
112 #ifdef SO_NO_CHECK
113 static int nochecksums = 0;
114 #endif
115
116
117 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
118 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
119
120 #define DEFAULT_THREAD_COUNT 10
121 #define DEFAULT_MAX_THREAD_COUNT 100
122 #define DEFAULT_RETRY_TIME 1000
123 #define MEMORY_SIZE 100
124 #define DEFAULT_DROP 3
125 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
126    but keeps the division between trunked and non-trunked better. */
127 #define TRUNK_CALL_START        0x4000
128
129 #define DEBUG_SUPPORT
130
131 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
132
133 /* Sample over last 100 units to determine historic jitter */
134 #define GAMMA (0.01)
135
136 static struct ast_codec_pref prefs;
137
138 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
139
140
141 /*! \brief Maximum transmission unit for the UDP packet in the trunk not to be
142     fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240 */
143 #define MAX_TRUNK_MTU 1240 
144
145 static int global_max_trunk_mtu;        /*!< Maximum MTU, 0 if not used */
146 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ;    /*!< Trunk MTU statistics */
147
148
149 static char context[80] = "default";
150
151 static char language[MAX_LANGUAGE] = "";
152 static char regcontext[AST_MAX_CONTEXT] = "";
153
154 static int maxauthreq = 3;
155 static int max_retries = 4;
156 static int ping_time = 21;
157 static int lagrq_time = 10;
158 static int maxtrunkcall = TRUNK_CALL_START;
159 static int maxnontrunkcall = 1;
160 static int maxjitterbuffer=1000;
161 static int resyncthreshold=1000;
162 static int maxjitterinterps=10;
163 static int jittertargetextra = 40; /* number of milliseconds the new jitter buffer adds on to its size */
164
165 #define MAX_TRUNKDATA           640 * 200       /*!< 40ms, uncompressed linear * 200 channels */
166
167 static int trunkfreq = 20;
168 static int trunkmaxsize = MAX_TRUNKDATA;
169
170 static int authdebug = 1;
171 static int autokill = 0;
172 static int iaxcompat = 0;
173
174 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
175
176 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
177
178 static unsigned int tos = 0;
179
180 static unsigned int cos = 0;
181
182 static int min_reg_expire;
183 static int max_reg_expire;
184
185 static int srvlookup = 0;
186
187 static int timingfd = -1;                               /* Timing file descriptor */
188
189 static struct ast_netsock_list *netsock;
190 static struct ast_netsock_list *outsock;                /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
191 static int defaultsockfd = -1;
192
193 int (*iax2_regfunk)(const char *username, int onoff) = NULL;
194
195 /* Ethernet, etc */
196 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
197 /* T1, maybe ISDN */
198 #define IAX_CAPABILITY_MEDBANDWIDTH     (IAX_CAPABILITY_FULLBANDWIDTH &         \
199                                          ~AST_FORMAT_SLINEAR &                  \
200                                          ~AST_FORMAT_ULAW &                     \
201                                          ~AST_FORMAT_ALAW &                     \
202                                          ~AST_FORMAT_G722) 
203 /* A modem */
204 #define IAX_CAPABILITY_LOWBANDWIDTH     (IAX_CAPABILITY_MEDBANDWIDTH &          \
205                                          ~AST_FORMAT_G726 &                     \
206                                          ~AST_FORMAT_G726_AAL2 &                \
207                                          ~AST_FORMAT_ADPCM)
208
209 #define IAX_CAPABILITY_LOWFREE          (IAX_CAPABILITY_LOWBANDWIDTH &          \
210                                          ~AST_FORMAT_G723_1)
211
212
213 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
214 #define DEFAULT_FREQ_OK         60 * 1000       /* How often to check for the host to be up */
215 #define DEFAULT_FREQ_NOTOK      10 * 1000       /* How often to check, if the host is down... */
216
217 static  struct io_context *io;
218 static  struct sched_context *sched;
219
220 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
221
222 static int iaxdebug = 0;
223
224 static int iaxtrunkdebug = 0;
225
226 static int test_losspct = 0;
227 #ifdef IAXTESTS
228 static int test_late = 0;
229 static int test_resync = 0;
230 static int test_jit = 0;
231 static int test_jitpct = 0;
232 #endif /* IAXTESTS */
233
234 static char accountcode[AST_MAX_ACCOUNT_CODE];
235 static char mohinterpret[MAX_MUSICCLASS];
236 static char mohsuggest[MAX_MUSICCLASS];
237 static int amaflags = 0;
238 static int adsi = 0;
239 static int delayreject = 0;
240 static int iax2_encryption = 0;
241
242 static struct ast_flags globalflags = { 0 };
243
244 static pthread_t netthreadid = AST_PTHREADT_NULL;
245 static pthread_t schedthreadid = AST_PTHREADT_NULL;
246 AST_MUTEX_DEFINE_STATIC(sched_lock);
247 static ast_cond_t sched_cond;
248
249 enum iax2_state {
250         IAX_STATE_STARTED =             (1 << 0),
251         IAX_STATE_AUTHENTICATED =       (1 << 1),
252         IAX_STATE_TBD =                 (1 << 2),
253         IAX_STATE_UNCHANGED =           (1 << 3),
254 };
255
256 struct iax2_context {
257         char context[AST_MAX_CONTEXT];
258         struct iax2_context *next;
259 };
260
261 enum iax2_flags {
262         IAX_HASCALLERID =       (1 << 0),       /*!< CallerID has been specified */
263         IAX_DELME =             (1 << 1),       /*!< Needs to be deleted */
264         IAX_TEMPONLY =          (1 << 2),       /*!< Temporary (realtime) */
265         IAX_TRUNK =             (1 << 3),       /*!< Treat as a trunk */
266         IAX_NOTRANSFER =        (1 << 4),       /*!< Don't native bridge */
267         IAX_USEJITTERBUF =      (1 << 5),       /*!< Use jitter buffer */
268         IAX_DYNAMIC =           (1 << 6),       /*!< dynamic peer */
269         IAX_SENDANI =           (1 << 7),       /*!< Send ANI along with CallerID */
270         /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
271         IAX_ALREADYGONE =       (1 << 9),       /*!< Already disconnected */
272         IAX_PROVISION =         (1 << 10),      /*!< This is a provisioning request */
273         IAX_QUELCH =            (1 << 11),      /*!< Whether or not we quelch audio */
274         IAX_ENCRYPTED =         (1 << 12),      /*!< Whether we should assume encrypted tx/rx */
275         IAX_KEYPOPULATED =      (1 << 13),      /*!< Whether we have a key populated */
276         IAX_CODEC_USER_FIRST =  (1 << 14),      /*!< are we willing to let the other guy choose the codec? */
277         IAX_CODEC_NOPREFS =     (1 << 15),      /*!< Force old behaviour by turning off prefs */
278         IAX_CODEC_NOCAP =       (1 << 16),      /*!< only consider requested format and ignore capabilities*/
279         IAX_RTCACHEFRIENDS =    (1 << 17),      /*!< let realtime stay till your reload */
280         IAX_RTUPDATE =          (1 << 18),      /*!< Send a realtime update */
281         IAX_RTAUTOCLEAR =       (1 << 19),      /*!< erase me on expire */ 
282         IAX_FORCEJITTERBUF =    (1 << 20),      /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */ 
283         IAX_RTIGNOREREGEXPIRE = (1 << 21),      /*!< When using realtime, ignore registration expiration */
284         IAX_TRUNKTIMESTAMPS =   (1 << 22),      /*!< Send trunk timestamps */
285         IAX_TRANSFERMEDIA =     (1 << 23),      /*!< When doing IAX2 transfers, transfer media only */
286         IAX_MAXAUTHREQ =        (1 << 24),      /*!< Maximum outstanding AUTHREQ restriction is in place */
287         IAX_DELAYPBXSTART =     (1 << 25),      /*!< Don't start a PBX on the channel until the peer sends us a
288                                                      response, so that we've achieved a three-way handshake with
289                                                      them before sending voice or anything else*/
290 };
291
292 static int global_rtautoclear = 120;
293
294 static int reload_config(void);
295
296 struct iax2_user {
297         AST_DECLARE_STRING_FIELDS(
298                 AST_STRING_FIELD(name);
299                 AST_STRING_FIELD(secret);
300                 AST_STRING_FIELD(dbsecret);
301                 AST_STRING_FIELD(accountcode);
302                 AST_STRING_FIELD(mohinterpret);
303                 AST_STRING_FIELD(mohsuggest);
304                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this user can use to authenticate to us */
305                 AST_STRING_FIELD(language);
306                 AST_STRING_FIELD(cid_num);
307                 AST_STRING_FIELD(cid_name);
308         );
309         
310         int authmethods;
311         int encmethods;
312         int amaflags;
313         int adsi;
314         unsigned int flags;
315         int capability;
316         int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
317         int curauthreq; /*!< Current number of outstanding AUTHREQs */
318         struct ast_codec_pref prefs;
319         struct ast_ha *ha;
320         struct iax2_context *contexts;
321         struct ast_variable *vars;
322 };
323
324 struct iax2_peer {
325         AST_DECLARE_STRING_FIELDS(
326                 AST_STRING_FIELD(name);
327                 AST_STRING_FIELD(username);
328                 AST_STRING_FIELD(secret);
329                 AST_STRING_FIELD(dbsecret);
330                 AST_STRING_FIELD(outkey);           /*!< What key we use to talk to this peer */
331
332                 AST_STRING_FIELD(regexten);     /*!< Extension to register (if regcontext is used) */
333                 AST_STRING_FIELD(context);      /*!< For transfers only */
334                 AST_STRING_FIELD(peercontext);  /*!< Context to pass to peer */
335                 AST_STRING_FIELD(mailbox);          /*!< Mailbox */
336                 AST_STRING_FIELD(mohinterpret);
337                 AST_STRING_FIELD(mohsuggest);
338                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this peer can use to authenticate to us */
339                 /* Suggested caller id if registering */
340                 AST_STRING_FIELD(cid_num);              /*!< Default context (for transfer really) */
341                 AST_STRING_FIELD(cid_name);             /*!< Default context (for transfer really) */
342                 AST_STRING_FIELD(zonetag);              /*!< Time Zone */
343         );
344         struct ast_codec_pref prefs;
345         struct ast_dnsmgr_entry *dnsmgr;                /*!< DNS refresh manager */
346         struct sockaddr_in addr;
347         int formats;
348         int sockfd;                                     /*!< Socket to use for transmission */
349         struct in_addr mask;
350         int adsi;
351         unsigned int flags;
352
353         /* Dynamic Registration fields */
354         struct sockaddr_in defaddr;                     /*!< Default address if there is one */
355         int authmethods;                                /*!< Authentication methods (IAX_AUTH_*) */
356         int encmethods;                                 /*!< Encryption methods (IAX_ENCRYPT_*) */
357
358         int expire;                                     /*!< Schedule entry for expiry */
359         int expiry;                                     /*!< How soon to expire */
360         int capability;                                 /*!< Capability */
361
362         /* Qualification */
363         int callno;                                     /*!< Call number of POKE request */
364         int pokeexpire;                                 /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
365         int lastms;                                     /*!< How long last response took (in ms), or -1 for no response */
366         int maxms;                                      /*!< Max ms we will accept for the host to be up, 0 to not monitor */
367
368         int pokefreqok;                                 /*!< How often to check if the host is up */
369         int pokefreqnotok;                              /*!< How often to check when the host has been determined to be down */
370         int historicms;                                 /*!< How long recent average responses took */
371         int smoothing;                                  /*!< Sample over how many units to determine historic ms */
372
373         struct ast_event_sub *mwi_event_sub;
374
375         struct ast_ha *ha;
376 };
377
378 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
379
380 struct iax2_trunk_peer {
381         ast_mutex_t lock;
382         int sockfd;
383         struct sockaddr_in addr;
384         struct timeval txtrunktime;             /*!< Transmit trunktime */
385         struct timeval rxtrunktime;             /*!< Receive trunktime */
386         struct timeval lasttxtime;              /*!< Last transmitted trunktime */
387         struct timeval trunkact;                /*!< Last trunk activity */
388         unsigned int lastsent;                  /*!< Last sent time */
389         /* Trunk data and length */
390         unsigned char *trunkdata;
391         unsigned int trunkdatalen;
392         unsigned int trunkdataalloc;
393         int trunkmaxmtu;
394         int trunkerror;
395         int calls;
396         AST_LIST_ENTRY(iax2_trunk_peer) list;
397 };
398
399 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
400
401 struct iax_firmware {
402         AST_LIST_ENTRY(iax_firmware) list;
403         int fd;
404         int mmaplen;
405         int dead;
406         struct ast_iax2_firmware_header *fwh;
407         unsigned char *buf;
408 };
409
410 enum iax_reg_state {
411         REG_STATE_UNREGISTERED = 0,
412         REG_STATE_REGSENT,
413         REG_STATE_AUTHSENT,
414         REG_STATE_REGISTERED,
415         REG_STATE_REJECTED,
416         REG_STATE_TIMEOUT,
417         REG_STATE_NOAUTH
418 };
419
420 enum iax_transfer_state {
421         TRANSFER_NONE = 0,
422         TRANSFER_BEGIN,
423         TRANSFER_READY,
424         TRANSFER_RELEASED,
425         TRANSFER_PASSTHROUGH,
426         TRANSFER_MBEGIN,
427         TRANSFER_MREADY,
428         TRANSFER_MRELEASED,
429         TRANSFER_MPASSTHROUGH,
430         TRANSFER_MEDIA,
431         TRANSFER_MEDIAPASS
432 };
433
434 struct iax2_registry {
435         struct sockaddr_in addr;                /*!< Who we connect to for registration purposes */
436         char username[80];
437         char secret[80];                        /*!< Password or key name in []'s */
438         int expire;                             /*!< Sched ID of expiration */
439         int refresh;                            /*!< How often to refresh */
440         enum iax_reg_state regstate;
441         int messages;                           /*!< Message count, low 8 bits = new, high 8 bits = old */
442         int callno;                             /*!< Associated call number if applicable */
443         struct sockaddr_in us;                  /*!< Who the server thinks we are */
444         struct ast_dnsmgr_entry *dnsmgr;        /*!< DNS refresh manager */
445         AST_LIST_ENTRY(iax2_registry) entry;
446 };
447
448 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
449
450 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
451 #define MIN_RETRY_TIME          100
452 #define MAX_RETRY_TIME          10000
453
454 #define MAX_JITTER_BUFFER       50
455 #define MIN_JITTER_BUFFER       10
456
457 #define DEFAULT_TRUNKDATA       640 * 10        /*!< 40ms, uncompressed linear * 10 channels */
458
459 #define MAX_TIMESTAMP_SKEW      160             /*!< maximum difference between actual and predicted ts for sending */
460
461 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
462 #define TS_GAP_FOR_JB_RESYNC    5000
463
464 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
465 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
466 static int iaxdynamicthreadcount = 0;
467 static int iaxactivethreadcount = 0;
468
469 struct iax_rr {
470         int jitter;
471         int losspct;
472         int losscnt;
473         int packets;
474         int delay;
475         int dropped;
476         int ooo;
477 };
478
479 struct iax2_pvt_ref;
480
481 struct chan_iax2_pvt {
482         /*! Socket to send/receive on for this call */
483         int sockfd;
484         /*! Last received voice format */
485         int voiceformat;
486         /*! Last received video format */
487         int videoformat;
488         /*! Last sent voice format */
489         int svoiceformat;
490         /*! Last sent video format */
491         int svideoformat;
492         /*! What we are capable of sending */
493         int capability;
494         /*! Last received timestamp */
495         unsigned int last;
496         /*! Last sent timestamp - never send the same timestamp twice in a single call */
497         unsigned int lastsent;
498         /*! Next outgoing timestamp if everything is good */
499         unsigned int nextpred;
500         /*! True if the last voice we transmitted was not silence/CNG */
501         unsigned int notsilenttx:1;
502         /*! Ping time */
503         unsigned int pingtime;
504         /*! Max time for initial response */
505         int maxtime;
506         /*! Peer Address */
507         struct sockaddr_in addr;
508         /*! Actual used codec preferences */
509         struct ast_codec_pref prefs;
510         /*! Requested codec preferences */
511         struct ast_codec_pref rprefs;
512         /*! Our call number */
513         unsigned short callno;
514         /*! Peer callno */
515         unsigned short peercallno;
516         /*! Negotiated format, this is only used to remember what format was
517             chosen for an unauthenticated call so that the channel can get
518             created later using the right format */
519         int chosenformat;
520         /*! Peer selected format */
521         int peerformat;
522         /*! Peer capability */
523         int peercapability;
524         /*! timeval that we base our transmission on */
525         struct timeval offset;
526         /*! timeval that we base our delivery on */
527         struct timeval rxcore;
528         /*! The jitterbuffer */
529         jitterbuf *jb;
530         /*! active jb read scheduler id */
531         int jbid;                       
532         /*! LAG */
533         int lag;
534         /*! Error, as discovered by the manager */
535         int error;
536         /*! Owner if we have one */
537         struct ast_channel *owner;
538         /*! What's our state? */
539         struct ast_flags state;
540         /*! Expiry (optional) */
541         int expiry;
542         /*! Next outgoing sequence number */
543         unsigned char oseqno;
544         /*! Next sequence number they have not yet acknowledged */
545         unsigned char rseqno;
546         /*! Next incoming sequence number */
547         unsigned char iseqno;
548         /*! Last incoming sequence number we have acknowledged */
549         unsigned char aseqno;
550
551         AST_DECLARE_STRING_FIELDS(
552                 /*! Peer name */
553                 AST_STRING_FIELD(peer);
554                 /*! Default Context */
555                 AST_STRING_FIELD(context);
556                 /*! Caller ID if available */
557                 AST_STRING_FIELD(cid_num);
558                 AST_STRING_FIELD(cid_name);
559                 /*! Hidden Caller ID (i.e. ANI) if appropriate */
560                 AST_STRING_FIELD(ani);
561                 /*! DNID */
562                 AST_STRING_FIELD(dnid);
563                 /*! RDNIS */
564                 AST_STRING_FIELD(rdnis);
565                 /*! Requested Extension */
566                 AST_STRING_FIELD(exten);
567                 /*! Expected Username */
568                 AST_STRING_FIELD(username);
569                 /*! Expected Secret */
570                 AST_STRING_FIELD(secret);
571                 /*! MD5 challenge */
572                 AST_STRING_FIELD(challenge);
573                 /*! Public keys permitted keys for incoming authentication */
574                 AST_STRING_FIELD(inkeys);
575                 /*! Private key for outgoing authentication */
576                 AST_STRING_FIELD(outkey);
577                 /*! Preferred language */
578                 AST_STRING_FIELD(language);
579                 /*! Hostname/peername for naming purposes */
580                 AST_STRING_FIELD(host);
581
582                 AST_STRING_FIELD(dproot);
583                 AST_STRING_FIELD(accountcode);
584                 AST_STRING_FIELD(mohinterpret);
585                 AST_STRING_FIELD(mohsuggest);
586                 /*! received OSP token */
587                 AST_STRING_FIELD(osptoken);
588         );
589         
590         /*! permitted authentication methods */
591         int authmethods;
592         /*! permitted encryption methods */
593         int encmethods;
594         /*! Encryption AES-128 Key */
595         ast_aes_encrypt_key ecx;
596         /*! Decryption AES-128 Key */
597         ast_aes_decrypt_key dcx;
598         /*! 32 bytes of semi-random data */
599         unsigned char semirand[32];
600         /*! Associated registry */
601         struct iax2_registry *reg;
602         /*! Associated peer for poking */
603         struct iax2_peer *peerpoke;
604         /*! IAX_ flags */
605         unsigned int flags;
606         int adsi;
607
608         /*! Transferring status */
609         enum iax_transfer_state transferring;
610         /*! Transfer identifier */
611         int transferid;
612         /*! Who we are IAX transferring to */
613         struct sockaddr_in transfer;
614         /*! What's the new call number for the transfer */
615         unsigned short transfercallno;
616         /*! Transfer encrypt AES-128 Key */
617         ast_aes_encrypt_key tdcx;
618
619         /*! Status of knowledge of peer ADSI capability */
620         int peeradsicpe;
621
622         /*! Who we are bridged to */
623         unsigned short bridgecallno;
624         
625         int pingid;                     /*!< Transmit PING request */
626         int lagid;                      /*!< Retransmit lag request */
627         int autoid;                     /*!< Auto hangup for Dialplan requestor */
628         int authid;                     /*!< Authentication rejection ID */
629         int authfail;                   /*!< Reason to report failure */
630         int initid;                     /*!< Initial peer auto-congest ID (based on qualified peers) */
631         int calling_ton;
632         int calling_tns;
633         int calling_pres;
634         int amaflags;
635         AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
636         struct ast_variable *vars;
637         /*! last received remote rr */
638         struct iax_rr remote_rr;
639         /*! Current base time: (just for stats) */
640         int min;
641         /*! Dropped frame count: (just for stats) */
642         int frames_dropped;
643         /*! received frame count: (just for stats) */
644         int frames_received;
645 };
646
647 /*!
648  * \brief a list of frames that may need to be retransmitted
649  *
650  * \note The contents of this list do not need to be explicitly destroyed
651  * on module unload.  This is because all active calls are destroyed, and
652  * all frames in this queue will get destroyed as a part of that process.
653  */
654 static AST_LIST_HEAD_STATIC(frame_queue, iax_frame);
655
656 /*!
657  * This module will get much higher performance when doing a lot of
658  * user and peer lookups if the number of buckets is increased from 1.
659  * However, to maintain old behavior for Asterisk 1.4, these are set to
660  * 1 by default.  When using multiple buckets, search order through these
661  * containers is considered random, so you will not be able to depend on
662  * the order the entires are specified in iax.conf for matching order. */
663 #ifdef LOW_MEMORY
664 #define MAX_PEER_BUCKETS 17
665 #else
666 #define MAX_PEER_BUCKETS 563
667 #endif
668 static struct ao2_container *peers;
669
670 #define MAX_USER_BUCKETS MAX_PEER_BUCKETS
671 static struct ao2_container *users;
672
673 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
674
675 enum {
676         /*! Extension exists */
677         CACHE_FLAG_EXISTS      = (1 << 0),
678         /*! Extension is nonexistent */
679         CACHE_FLAG_NONEXISTENT = (1 << 1),
680         /*! Extension can exist */
681         CACHE_FLAG_CANEXIST    = (1 << 2),
682         /*! Waiting to hear back response */
683         CACHE_FLAG_PENDING     = (1 << 3),
684         /*! Timed out */
685         CACHE_FLAG_TIMEOUT     = (1 << 4),
686         /*! Request transmitted */
687         CACHE_FLAG_TRANSMITTED = (1 << 5),
688         /*! Timeout */
689         CACHE_FLAG_UNKNOWN     = (1 << 6),
690         /*! Matchmore */
691         CACHE_FLAG_MATCHMORE   = (1 << 7),
692 };
693
694 struct iax2_dpcache {
695         char peercontext[AST_MAX_CONTEXT];
696         char exten[AST_MAX_EXTENSION];
697         struct timeval orig;
698         struct timeval expiry;
699         int flags;
700         unsigned short callno;
701         int waiters[256];
702         AST_LIST_ENTRY(iax2_dpcache) cache_list;
703         AST_LIST_ENTRY(iax2_dpcache) peer_list;
704 };
705
706 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
707
708 static void reg_source_db(struct iax2_peer *p);
709 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
710
711 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
712 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state);
713 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
714
715 enum iax2_thread_iostate {
716         IAX_IOSTATE_IDLE,
717         IAX_IOSTATE_READY,
718         IAX_IOSTATE_PROCESSING,
719         IAX_IOSTATE_SCHEDREADY,
720 };
721
722 enum iax2_thread_type {
723         IAX_THREAD_TYPE_POOL,
724         IAX_THREAD_TYPE_DYNAMIC,
725 };
726
727 struct iax2_pkt_buf {
728         AST_LIST_ENTRY(iax2_pkt_buf) entry;
729         size_t len;
730         unsigned char buf[1];
731 };
732
733 struct iax2_thread {
734         AST_LIST_ENTRY(iax2_thread) list;
735         enum iax2_thread_type type;
736         enum iax2_thread_iostate iostate;
737 #ifdef SCHED_MULTITHREADED
738         void (*schedfunc)(const void *);
739         const void *scheddata;
740 #endif
741 #ifdef DEBUG_SCHED_MULTITHREAD
742         char curfunc[80];
743 #endif  
744         int actions;
745         pthread_t threadid;
746         int threadnum;
747         struct sockaddr_in iosin;
748         unsigned char readbuf[4096]; 
749         unsigned char *buf;
750         ssize_t buf_len;
751         size_t buf_size;
752         int iofd;
753         time_t checktime;
754         ast_mutex_t lock;
755         ast_cond_t cond;
756         unsigned int ready_for_signal:1;
757         /*! if this thread is processing a full frame,
758           some information about that frame will be stored
759           here, so we can avoid dispatching any more full
760           frames for that callno to other threads */
761         struct {
762                 unsigned short callno;
763                 struct sockaddr_in sin;
764                 unsigned char type;
765                 unsigned char csub;
766         } ffinfo;
767         /*! Queued up full frames for processing.  If more full frames arrive for
768          *  a call which this thread is already processing a full frame for, they
769          *  are queued up here. */
770         AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
771 };
772
773 /* Thread lists */
774 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
775 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
776 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
777
778 static void *iax2_process_thread(void *data);
779
780 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
781 {
782         ast_mutex_lock(lock);
783         ast_cond_signal(cond);
784         ast_mutex_unlock(lock);
785 }
786
787 static void iax_debug_output(const char *data)
788 {
789         if (iaxdebug)
790                 ast_verbose("%s", data);
791 }
792
793 static void iax_error_output(const char *data)
794 {
795         ast_log(LOG_WARNING, "%s", data);
796 }
797
798 static void jb_error_output(const char *fmt, ...)
799 {
800         va_list args;
801         char buf[1024];
802
803         va_start(args, fmt);
804         vsnprintf(buf, sizeof(buf), fmt, args);
805         va_end(args);
806
807         ast_log(LOG_ERROR, buf);
808 }
809
810 static void jb_warning_output(const char *fmt, ...)
811 {
812         va_list args;
813         char buf[1024];
814
815         va_start(args, fmt);
816         vsnprintf(buf, sizeof(buf), fmt, args);
817         va_end(args);
818
819         ast_log(LOG_WARNING, buf);
820 }
821
822 static void jb_debug_output(const char *fmt, ...)
823 {
824         va_list args;
825         char buf[1024];
826
827         va_start(args, fmt);
828         vsnprintf(buf, sizeof(buf), fmt, args);
829         va_end(args);
830
831         ast_verbose(buf);
832 }
833
834 /*!
835  * \brief an array of iax2 pvt structures
836  *
837  * The container for active chan_iax2_pvt structures is implemented as an
838  * array for extremely quick direct access to the correct pvt structure
839  * based on the local call number.  The local call number is used as the
840  * index into the array where the associated pvt structure is stored.
841  */
842 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
843 /*!
844  * \brief chan_iax2_pvt structure locks
845  *
846  * These locks are used when accessing a pvt structure in the iaxs array.
847  * The index used here is the same as used in the iaxs array.  It is the
848  * local call number for the associated pvt struct.
849  */
850 static ast_mutex_t iaxsl[IAX_MAX_CALLS];
851 /*!
852  * \brief The last time a call number was used
853  *
854  * It is important to know the last time that a call number was used locally so
855  * that it is not used again too soon.  The reason for this is the same as the
856  * reason that the TCP protocol state machine requires a "TIME WAIT" state.
857  *
858  * For example, say that a call is up.  Then, the remote side sends a HANGUP,
859  * which we respond to with an ACK.  However, there is no way to know whether
860  * the ACK made it there successfully.  If it were to get lost, the remote
861  * side may retransmit the HANGUP.  If in the meantime, this call number has
862  * been reused locally, given the right set of circumstances, this retransmitted
863  * HANGUP could potentially improperly hang up the new session.  So, to avoid
864  * this potential issue, we must wait a specified timeout period before reusing
865  * a local call number.
866  *
867  * The specified time that we must wait before reusing a local call number is
868  * defined as MIN_REUSE_TIME, with a default of 60 seconds.
869  */
870 static struct timeval lastused[IAX_MAX_CALLS];
871
872 static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
873 static int expire_registry(const void *data);
874 static int iax2_answer(struct ast_channel *c);
875 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
876 static int iax2_devicestate(void *data);
877 static int iax2_digit_begin(struct ast_channel *c, char digit);
878 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
879 static int iax2_do_register(struct iax2_registry *reg);
880 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
881 static int iax2_hangup(struct ast_channel *c);
882 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
883 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
884 static int iax2_provision(struct sockaddr_in *end, int sockfd, char *dest, const char *template, int force);
885 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
886 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
887 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
888 static int iax2_sendtext(struct ast_channel *c, const char *text);
889 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
890 static int iax2_transfer(struct ast_channel *c, const char *dest);
891 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
892 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
893 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
894 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
895 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
896 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
897 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
898 static struct ast_channel *iax2_request(const char *type, int format, void *data, int *cause);
899 static struct ast_frame *iax2_read(struct ast_channel *c);
900 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
901 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
902 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
903 static void prune_peers(void);
904 static void *iax2_dup_variable_datastore(void *);
905 static void iax2_free_variable_datastore(void *);
906
907 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
908 static int acf_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value);
909
910 static const struct ast_channel_tech iax2_tech = {
911         .type = "IAX2",
912         .description = tdesc,
913         .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
914         .properties = AST_CHAN_TP_WANTSJITTER,
915         .requester = iax2_request,
916         .devicestate = iax2_devicestate,
917         .send_digit_begin = iax2_digit_begin,
918         .send_digit_end = iax2_digit_end,
919         .send_text = iax2_sendtext,
920         .send_image = iax2_sendimage,
921         .send_html = iax2_sendhtml,
922         .call = iax2_call,
923         .hangup = iax2_hangup,
924         .answer = iax2_answer,
925         .read = iax2_read,
926         .write = iax2_write,
927         .write_video = iax2_write,
928         .indicate = iax2_indicate,
929         .setoption = iax2_setoption,
930         .bridge = iax2_bridge,
931         .transfer = iax2_transfer,
932         .fixup = iax2_fixup,
933         .func_channel_read = acf_channel_read,
934         .func_channel_write = acf_channel_write,
935 };
936
937 static void mwi_event_cb(const struct ast_event *event, void *userdata)
938 {
939         /* The MWI subscriptions exist just so the core knows we care about those
940          * mailboxes.  However, we just grab the events out of the cache when it
941          * is time to send MWI, since it is only sent with a REGACK. */
942 }
943
944 /*! \brief Send manager event at call setup to link between Asterisk channel name
945         and IAX2 call identifiers */
946 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt) 
947 {
948         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
949                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
950                 pvt->owner ? pvt->owner->name : "",
951                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
952 }
953
954
955 static struct ast_datastore_info iax2_variable_datastore_info = {
956         .type = "IAX2_VARIABLE",
957         .duplicate = iax2_dup_variable_datastore,
958         .destroy = iax2_free_variable_datastore,
959 };
960
961 static void *iax2_dup_variable_datastore(void *old)
962 {
963         AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
964         struct ast_var_t *oldvar, *newvar;
965
966         newlist = ast_calloc(sizeof(*newlist), 1);
967         if (!newlist) {
968                 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
969                 return NULL;
970         }
971
972         AST_LIST_HEAD_INIT(newlist);
973         AST_LIST_LOCK(oldlist);
974         AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
975                 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
976                 if (newvar)
977                         AST_LIST_INSERT_TAIL(newlist, newvar, entries);
978                 else
979                         ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
980         }
981         AST_LIST_UNLOCK(oldlist);
982         return newlist;
983 }
984
985 static void iax2_free_variable_datastore(void *old)
986 {
987         AST_LIST_HEAD(, ast_var_t) *oldlist = old;
988         struct ast_var_t *oldvar;
989
990         AST_LIST_LOCK(oldlist);
991         while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
992                 ast_free(oldvar);
993         }
994         AST_LIST_UNLOCK(oldlist);
995         AST_LIST_HEAD_DESTROY(oldlist);
996         ast_free(oldlist);
997 }
998
999 /* WARNING: insert_idle_thread should only ever be called within the
1000  * context of an iax2_process_thread() thread.
1001  */
1002 static void insert_idle_thread(struct iax2_thread *thread)
1003 {
1004         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1005                 AST_LIST_LOCK(&dynamic_list);
1006                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1007                 AST_LIST_UNLOCK(&dynamic_list);
1008         } else {
1009                 AST_LIST_LOCK(&idle_list);
1010                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1011                 AST_LIST_UNLOCK(&idle_list);
1012         }
1013
1014         return;
1015 }
1016
1017 static struct iax2_thread *find_idle_thread(void)
1018 {
1019         struct iax2_thread *thread = NULL;
1020
1021         /* Pop the head of the idle list off */
1022         AST_LIST_LOCK(&idle_list);
1023         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1024         AST_LIST_UNLOCK(&idle_list);
1025
1026         /* If we popped a thread off the idle list, just return it */
1027         if (thread) {
1028                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1029                 return thread;
1030         }
1031
1032         /* Pop the head of the dynamic list off */
1033         AST_LIST_LOCK(&dynamic_list);
1034         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1035         AST_LIST_UNLOCK(&dynamic_list);
1036
1037         /* If we popped a thread off the dynamic list, just return it */
1038         if (thread) {
1039                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1040                 return thread;
1041         }
1042
1043         /* If we can't create a new dynamic thread for any reason, return no thread at all */
1044         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1045                 return NULL;
1046
1047         /* Set default values */
1048         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1049         thread->type = IAX_THREAD_TYPE_DYNAMIC;
1050
1051         /* Initialize lock and condition */
1052         ast_mutex_init(&thread->lock);
1053         ast_cond_init(&thread->cond, NULL);
1054
1055         /* Create thread and send it on it's way */
1056         if (ast_pthread_create_detached_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1057                 ast_cond_destroy(&thread->cond);
1058                 ast_mutex_destroy(&thread->lock);
1059                 ast_free(thread);
1060                 return NULL;
1061         }
1062
1063         /* this thread is not processing a full frame (since it is idle),
1064            so ensure that the field for the full frame call number is empty */
1065         memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1066
1067         /* Wait for the thread to be ready before returning it to the caller */
1068         while (!thread->ready_for_signal)
1069                 usleep(1);
1070
1071         return thread;
1072 }
1073
1074 #ifdef SCHED_MULTITHREADED
1075 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1076 {
1077         struct iax2_thread *thread = NULL;
1078         static time_t lasterror;
1079         static time_t t;
1080
1081         thread = find_idle_thread();
1082
1083         if (thread != NULL) {
1084                 thread->schedfunc = func;
1085                 thread->scheddata = data;
1086                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1087 #ifdef DEBUG_SCHED_MULTITHREAD
1088                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1089 #endif
1090                 signal_condition(&thread->lock, &thread->cond);
1091                 return 0;
1092         }
1093         time(&t);
1094         if (t != lasterror) 
1095                 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
1096         lasterror = t;
1097
1098         return -1;
1099 }
1100 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1101 #endif
1102
1103 static int iax2_sched_replace(int old_id, struct sched_context *con, int when, ast_sched_cb callback, const void *data)
1104 {
1105         int res;
1106
1107         res = ast_sched_replace(old_id, con, when, callback, data);
1108         signal_condition(&sched_lock, &sched_cond);
1109
1110         return res;
1111 }
1112
1113 static int iax2_sched_add(struct sched_context *con, int when, ast_sched_cb callback, const void *data)
1114 {
1115         int res;
1116
1117         res = ast_sched_add(con, when, callback, data);
1118         signal_condition(&sched_lock, &sched_cond);
1119
1120         return res;
1121 }
1122
1123 static int send_ping(const void *data);
1124
1125 static void __send_ping(const void *data)
1126 {
1127         int callno = (long)data;
1128         ast_mutex_lock(&iaxsl[callno]);
1129         if (iaxs[callno] && iaxs[callno]->pingid != -1) {
1130                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1131                 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1132         }
1133         ast_mutex_unlock(&iaxsl[callno]);
1134 }
1135
1136 static int send_ping(const void *data)
1137 {
1138 #ifdef SCHED_MULTITHREADED
1139         if (schedule_action(__send_ping, data))
1140 #endif          
1141                 __send_ping(data);
1142         return 0;
1143 }
1144
1145 static int get_encrypt_methods(const char *s)
1146 {
1147         int e;
1148         if (!strcasecmp(s, "aes128"))
1149                 e = IAX_ENCRYPT_AES128;
1150         else if (ast_true(s))
1151                 e = IAX_ENCRYPT_AES128;
1152         else
1153                 e = 0;
1154         return e;
1155 }
1156
1157 static int send_lagrq(const void *data);
1158
1159 static void __send_lagrq(const void *data)
1160 {
1161         int callno = (long)data;
1162         /* Ping only if it's real not if it's bridged */
1163         ast_mutex_lock(&iaxsl[callno]);
1164         if (iaxs[callno] && iaxs[callno]->lagid != -1) {
1165                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1166                 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1167         }
1168         ast_mutex_unlock(&iaxsl[callno]);
1169 }
1170
1171 static int send_lagrq(const void *data)
1172 {
1173 #ifdef SCHED_MULTITHREADED
1174         if (schedule_action(__send_lagrq, data))
1175 #endif          
1176                 __send_lagrq(data);
1177         return 0;
1178 }
1179
1180 static unsigned char compress_subclass(int subclass)
1181 {
1182         int x;
1183         int power=-1;
1184         /* If it's 128 or smaller, just return it */
1185         if (subclass < IAX_FLAG_SC_LOG)
1186                 return subclass;
1187         /* Otherwise find its power */
1188         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1189                 if (subclass & (1 << x)) {
1190                         if (power > -1) {
1191                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1192                                 return 0;
1193                         } else
1194                                 power = x;
1195                 }
1196         }
1197         return power | IAX_FLAG_SC_LOG;
1198 }
1199
1200 static int uncompress_subclass(unsigned char csub)
1201 {
1202         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1203         if (csub & IAX_FLAG_SC_LOG) {
1204                 /* special case for 'compressed' -1 */
1205                 if (csub == 0xff)
1206                         return -1;
1207                 else
1208                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1209         }
1210         else
1211                 return csub;
1212 }
1213
1214 /*!
1215  * \note The only member of the peer passed here guaranteed to be set is the name field
1216  */
1217 static int peer_hash_cb(const void *obj, const int flags)
1218 {
1219         const struct iax2_peer *peer = obj;
1220
1221         return ast_str_hash(peer->name);
1222 }
1223
1224 /*!
1225  * \note The only member of the peer passed here guaranteed to be set is the name field
1226  */
1227 static int peer_cmp_cb(void *obj, void *arg, int flags)
1228 {
1229         struct iax2_peer *peer = obj, *peer2 = arg;
1230
1231         return !strcasecmp(peer->name, peer2->name) ? CMP_MATCH : 0;
1232 }
1233
1234 /*!
1235  * \note The only member of the user passed here guaranteed to be set is the name field
1236  */
1237 static int user_hash_cb(const void *obj, const int flags)
1238 {
1239         const struct iax2_user *user = obj;
1240
1241         return ast_str_hash(user->name);
1242 }
1243
1244 /*!
1245  * \note The only member of the user passed here guaranteed to be set is the name field
1246  */
1247 static int user_cmp_cb(void *obj, void *arg, int flags)
1248 {
1249         struct iax2_user *user = obj, *user2 = arg;
1250
1251         return !strcasecmp(user->name, user2->name) ? CMP_MATCH : 0;
1252 }
1253
1254 /*!
1255  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
1256  *       so do not call it with a pvt lock held.
1257  */
1258 static struct iax2_peer *find_peer(const char *name, int realtime) 
1259 {
1260         struct iax2_peer *peer = NULL;
1261         struct iax2_peer tmp_peer = {
1262                 .name = name,
1263         };
1264
1265         peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
1266
1267         /* Now go for realtime if applicable */
1268         if(!peer && realtime)
1269                 peer = realtime_peer(name, NULL);
1270
1271         return peer;
1272 }
1273
1274 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
1275 {
1276         ao2_ref(peer, +1);
1277         return peer;
1278 }
1279
1280 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
1281 {
1282         ao2_ref(peer, -1);
1283         return NULL;
1284 }
1285
1286 static inline struct iax2_user *user_ref(struct iax2_user *user)
1287 {
1288         ao2_ref(user, +1);
1289         return user;
1290 }
1291
1292 static inline struct iax2_user *user_unref(struct iax2_user *user)
1293 {
1294         ao2_ref(user, -1);
1295         return NULL;
1296 }
1297
1298 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
1299 {
1300         struct iax2_peer *peer = NULL;
1301         int res = 0;
1302         struct ao2_iterator i;
1303
1304         i = ao2_iterator_init(peers, 0);
1305         while ((peer = ao2_iterator_next(&i))) {
1306                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1307                     (peer->addr.sin_port == sin.sin_port)) {
1308                         ast_copy_string(host, peer->name, len);
1309                         peer_unref(peer);
1310                         res = 1;
1311                         break;
1312                 }
1313                 peer_unref(peer);
1314         }
1315
1316         if (!peer) {
1317                 peer = realtime_peer(NULL, &sin);
1318                 if (peer) {
1319                         ast_copy_string(host, peer->name, len);
1320                         peer_unref(peer);
1321                         res = 1;
1322                 }
1323         }
1324
1325         return res;
1326 }
1327
1328 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1329 {
1330         struct chan_iax2_pvt *tmp;
1331         jb_conf jbconf;
1332
1333         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1334                 return NULL;
1335
1336         if (ast_string_field_init(tmp, 32)) {
1337                 ast_free(tmp);
1338                 tmp = NULL;
1339                 return NULL;
1340         }
1341                 
1342         tmp->prefs = prefs;
1343         tmp->pingid = -1;
1344         tmp->lagid = -1;
1345         tmp->autoid = -1;
1346         tmp->authid = -1;
1347         tmp->initid = -1;
1348
1349         ast_string_field_set(tmp,exten, "s");
1350         ast_string_field_set(tmp,host, host);
1351
1352         tmp->jb = jb_new();
1353         tmp->jbid = -1;
1354         jbconf.max_jitterbuf = maxjitterbuffer;
1355         jbconf.resync_threshold = resyncthreshold;
1356         jbconf.max_contig_interp = maxjitterinterps;
1357         jbconf.target_extra = jittertargetextra;
1358         jb_setconf(tmp->jb,&jbconf);
1359
1360         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1361
1362         return tmp;
1363 }
1364
1365 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1366 {
1367         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1368         if (new) {
1369                 size_t afdatalen = new->afdatalen;
1370                 memcpy(new, fr, sizeof(*new));
1371                 iax_frame_wrap(new, &fr->af);
1372                 new->afdatalen = afdatalen;
1373                 new->data = NULL;
1374                 new->datalen = 0;
1375                 new->direction = DIRECTION_INGRESS;
1376                 new->retrans = -1;
1377         }
1378         return new;
1379 }
1380
1381 #define NEW_PREVENT     0
1382 #define NEW_ALLOW       1
1383 #define NEW_FORCE       2
1384
1385 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1386 {
1387         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1388                 (cur->addr.sin_port == sin->sin_port)) {
1389                 /* This is the main host */
1390                 if ((cur->peercallno == callno) ||
1391                         ((dcallno == cur->callno) && !cur->peercallno)) {
1392                         /* That's us.  Be sure we keep track of the peer call number */
1393                         return 1;
1394                 }
1395         }
1396         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1397             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1398                 /* We're transferring */
1399                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1400                         return 1;
1401         }
1402         return 0;
1403 }
1404
1405 static void update_max_trunk(void)
1406 {
1407         int max = TRUNK_CALL_START;
1408         int x;
1409         /* XXX Prolly don't need locks here XXX */
1410         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1411                 if (iaxs[x])
1412                         max = x + 1;
1413         }
1414         maxtrunkcall = max;
1415         if (iaxdebug)
1416                 ast_debug(1, "New max trunk callno is %d\n", max);
1417 }
1418
1419 static void update_max_nontrunk(void)
1420 {
1421         int max = 1;
1422         int x;
1423         /* XXX Prolly don't need locks here XXX */
1424         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1425                 if (iaxs[x])
1426                         max = x + 1;
1427         }
1428         maxnontrunkcall = max;
1429         if (iaxdebug)
1430                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1431 }
1432
1433 static int make_trunk(unsigned short callno, int locked)
1434 {
1435         int x;
1436         int res= 0;
1437         struct timeval now = ast_tvnow();
1438         if (iaxs[callno]->oseqno) {
1439                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1440                 return -1;
1441         }
1442         if (callno & TRUNK_CALL_START) {
1443                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1444                 return -1;
1445         }
1446         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1447                 ast_mutex_lock(&iaxsl[x]);
1448                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1449                         iaxs[x] = iaxs[callno];
1450                         iaxs[x]->callno = x;
1451                         iaxs[callno] = NULL;
1452                         /* Update the two timers that should have been started */
1453                         iaxs[x]->pingid = iax2_sched_replace(iaxs[x]->pingid, sched, 
1454                                 ping_time * 1000, send_ping, (void *)(long)x);
1455                         iaxs[x]->lagid = iax2_sched_replace(iaxs[x]->lagid, sched, 
1456                                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
1457                         if (locked)
1458                                 ast_mutex_unlock(&iaxsl[callno]);
1459                         res = x;
1460                         if (!locked)
1461                                 ast_mutex_unlock(&iaxsl[x]);
1462                         break;
1463                 }
1464                 ast_mutex_unlock(&iaxsl[x]);
1465         }
1466         if (x >= IAX_MAX_CALLS - 1) {
1467                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1468                 return -1;
1469         }
1470         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1471         /* We move this call from a non-trunked to a trunked call */
1472         update_max_trunk();
1473         update_max_nontrunk();
1474         return res;
1475 }
1476
1477 /*!
1478  * \todo XXX Note that this function contains a very expensive operation that
1479  * happens for *every* incoming media frame.  It iterates through every
1480  * possible call number, locking and unlocking each one, to try to match the
1481  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1482  * So, for an call with a local call number of 20000, every incoming audio
1483  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1484  *
1485  * It's a shame that IAX2 media frames carry the source call number instead of
1486  * the destination call number.  If they did, this lookup wouldn't be needed.
1487  * However, it's too late to change that now.  Instead, we need to come up with
1488  * a better way of indexing active calls so that these frequent lookups are not
1489  * so expensive.
1490  *
1491  * \note Calling this function while holding another pvt lock can cause a deadlock.
1492  */
1493 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd)
1494 {
1495         int res = 0;
1496         int x;
1497         struct timeval now;
1498         char host[80];
1499
1500         if (new <= NEW_ALLOW) {
1501                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1502                         ast_mutex_lock(&iaxsl[x]);
1503                         if (iaxs[x]) {
1504                                 /* Look for an exact match */
1505                                 if (match(sin, callno, dcallno, iaxs[x])) {
1506                                         res = x;
1507                                 }
1508                         }
1509                         ast_mutex_unlock(&iaxsl[x]);
1510                 }
1511                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1512                         ast_mutex_lock(&iaxsl[x]);
1513                         if (iaxs[x]) {
1514                                 /* Look for an exact match */
1515                                 if (match(sin, callno, dcallno, iaxs[x])) {
1516                                         res = x;
1517                                 }
1518                         }
1519                         ast_mutex_unlock(&iaxsl[x]);
1520                 }
1521         }
1522         if ((res < 1) && (new >= NEW_ALLOW)) {
1523                 /* It may seem odd that we look through the peer list for a name for
1524                  * this *incoming* call.  Well, it is weird.  However, users don't
1525                  * have an IP address/port number that we can match against.  So,
1526                  * this is just checking for a peer that has that IP/port and
1527                  * assuming that we have a user of the same name.  This isn't always
1528                  * correct, but it will be changed if needed after authentication. */
1529                 if (!iax2_getpeername(*sin, host, sizeof(host)))
1530                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1531                 now = ast_tvnow();
1532                 for (x=1;x<TRUNK_CALL_START;x++) {
1533                         /* Find first unused call number that hasn't been used in a while */
1534                         ast_mutex_lock(&iaxsl[x]);
1535                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1536                         ast_mutex_unlock(&iaxsl[x]);
1537                 }
1538                 /* We've still got lock held if we found a spot */
1539                 if (x >= TRUNK_CALL_START) {
1540                         ast_log(LOG_WARNING, "No more space\n");
1541                         return 0;
1542                 }
1543                 iaxs[x] = new_iax(sin, host);
1544                 update_max_nontrunk();
1545                 if (iaxs[x]) {
1546                         if (iaxdebug)
1547                                 ast_debug(1, "Creating new call structure %d\n", x);
1548                         iaxs[x]->sockfd = sockfd;
1549                         iaxs[x]->addr.sin_port = sin->sin_port;
1550                         iaxs[x]->addr.sin_family = sin->sin_family;
1551                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1552                         iaxs[x]->peercallno = callno;
1553                         iaxs[x]->callno = x;
1554                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1555                         iaxs[x]->expiry = min_reg_expire;
1556                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1557                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1558                         iaxs[x]->amaflags = amaflags;
1559                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1560                         
1561                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1562                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1563                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1564                 } else {
1565                         ast_log(LOG_WARNING, "Out of resources\n");
1566                         ast_mutex_unlock(&iaxsl[x]);
1567                         return 0;
1568                 }
1569                 ast_mutex_unlock(&iaxsl[x]);
1570                 res = x;
1571         }
1572         return res;
1573 }
1574
1575 static void iax2_frame_free(struct iax_frame *fr)
1576 {
1577         if (fr->retrans > -1)
1578                 ast_sched_del(sched, fr->retrans);
1579         iax_frame_free(fr);
1580 }
1581
1582 /*!
1583  * \brief Queue a frame to a call's owning asterisk channel
1584  *
1585  * \pre This function assumes that iaxsl[callno] is locked when called.
1586  *
1587  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1588  * was valid before calling it, it may no longer be valid after calling it.
1589  * This function may unlock and lock the mutex associated with this callno,
1590  * meaning that another thread may grab it and destroy the call.
1591  */
1592 static int iax2_queue_frame(int callno, struct ast_frame *f)
1593 {
1594         for (;;) {
1595                 if (iaxs[callno] && iaxs[callno]->owner) {
1596                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1597                                 /* Avoid deadlock by pausing and trying again */
1598                                 ast_mutex_unlock(&iaxsl[callno]);
1599                                 usleep(1);
1600                                 ast_mutex_lock(&iaxsl[callno]);
1601                         } else {
1602                                 ast_queue_frame(iaxs[callno]->owner, f);
1603                                 ast_channel_unlock(iaxs[callno]->owner);
1604                                 break;
1605                         }
1606                 } else
1607                         break;
1608         }
1609         return 0;
1610 }
1611
1612 /*!
1613  * \brief Queue a hangup frame on the ast_channel owner
1614  *
1615  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
1616  * is active for the given call number.
1617  *
1618  * \pre Assumes lock for callno is already held.
1619  *
1620  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1621  * was valid before calling it, it may no longer be valid after calling it.
1622  * This function may unlock and lock the mutex associated with this callno,
1623  * meaning that another thread may grab it and destroy the call.
1624  */
1625 static int iax2_queue_hangup(int callno)
1626 {
1627         for (;;) {
1628                 if (iaxs[callno] && iaxs[callno]->owner) {
1629                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1630                                 /* Avoid deadlock by pausing and trying again */
1631                                 ast_mutex_unlock(&iaxsl[callno]);
1632                                 usleep(1);
1633                                 ast_mutex_lock(&iaxsl[callno]);
1634                         } else {
1635                                 ast_queue_hangup(iaxs[callno]->owner);
1636                                 ast_channel_unlock(iaxs[callno]->owner);
1637                                 break;
1638                         }
1639                 } else
1640                         break;
1641         }
1642         return 0;
1643 }
1644
1645 /*!
1646  * \brief Queue a control frame on the ast_channel owner
1647  *
1648  * This function queues a control frame on the owner of the IAX2 pvt struct that
1649  * is active for the given call number.
1650  *
1651  * \pre Assumes lock for callno is already held.
1652  *
1653  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1654  * was valid before calling it, it may no longer be valid after calling it.
1655  * This function may unlock and lock the mutex associated with this callno,
1656  * meaning that another thread may grab it and destroy the call.
1657  */
1658 static int iax2_queue_control_data(int callno, 
1659         enum ast_control_frame_type control, const void *data, size_t datalen)
1660 {
1661         for (;;) {
1662                 if (iaxs[callno] && iaxs[callno]->owner) {
1663                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1664                                 /* Avoid deadlock by pausing and trying again */
1665                                 ast_mutex_unlock(&iaxsl[callno]);
1666                                 usleep(1);
1667                                 ast_mutex_lock(&iaxsl[callno]);
1668                         } else {
1669                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
1670                                 ast_channel_unlock(iaxs[callno]->owner);
1671                                 break;
1672                         }
1673                 } else
1674                         break;
1675         }
1676         return 0;
1677 }
1678 static void destroy_firmware(struct iax_firmware *cur)
1679 {
1680         /* Close firmware */
1681         if (cur->fwh) {
1682                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1683         }
1684         close(cur->fd);
1685         ast_free(cur);
1686 }
1687
1688 static int try_firmware(char *s)
1689 {
1690         struct stat stbuf;
1691         struct iax_firmware *cur = NULL;
1692         int ifd, fd, res, len, chunk;
1693         struct ast_iax2_firmware_header *fwh, fwh2;
1694         struct MD5Context md5;
1695         unsigned char sum[16], buf[1024];
1696         char *s2, *last;
1697
1698         if (!(s2 = alloca(strlen(s) + 100))) {
1699                 ast_log(LOG_WARNING, "Alloca failed!\n");
1700                 return -1;
1701         }
1702
1703         last = strrchr(s, '/');
1704         if (last)
1705                 last++;
1706         else
1707                 last = s;
1708
1709         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1710
1711         if ((res = stat(s, &stbuf) < 0)) {
1712                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1713                 return -1;
1714         }
1715
1716         /* Make sure it's not a directory */
1717         if (S_ISDIR(stbuf.st_mode))
1718                 return -1;
1719         ifd = open(s, O_RDONLY);
1720         if (ifd < 0) {
1721                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1722                 return -1;
1723         }
1724         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1725         if (fd < 0) {
1726                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1727                 close(ifd);
1728                 return -1;
1729         }
1730         /* Unlink our newly created file */
1731         unlink(s2);
1732         
1733         /* Now copy the firmware into it */
1734         len = stbuf.st_size;
1735         while(len) {
1736                 chunk = len;
1737                 if (chunk > sizeof(buf))
1738                         chunk = sizeof(buf);
1739                 res = read(ifd, buf, chunk);
1740                 if (res != chunk) {
1741                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1742                         close(ifd);
1743                         close(fd);
1744                         return -1;
1745                 }
1746                 res = write(fd, buf, chunk);
1747                 if (res != chunk) {
1748                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1749                         close(ifd);
1750                         close(fd);
1751                         return -1;
1752                 }
1753                 len -= chunk;
1754         }
1755         close(ifd);
1756         /* Return to the beginning */
1757         lseek(fd, 0, SEEK_SET);
1758         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1759                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1760                 close(fd);
1761                 return -1;
1762         }
1763         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1764                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1765                 close(fd);
1766                 return -1;
1767         }
1768         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1769                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1770                 close(fd);
1771                 return -1;
1772         }
1773         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1774                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1775                 close(fd);
1776                 return -1;
1777         }
1778         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1779         if (fwh == (void *) -1) {
1780                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1781                 close(fd);
1782                 return -1;
1783         }
1784         MD5Init(&md5);
1785         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1786         MD5Final(sum, &md5);
1787         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1788                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1789                 munmap((void*)fwh, stbuf.st_size);
1790                 close(fd);
1791                 return -1;
1792         }
1793
1794         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1795                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1796                         /* Found a candidate */
1797                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1798                                 /* The version we have on loaded is older, load this one instead */
1799                                 break;
1800                         /* This version is no newer than what we have.  Don't worry about it.
1801                            We'll consider it a proper load anyhow though */
1802                         munmap((void*)fwh, stbuf.st_size);
1803                         close(fd);
1804                         return 0;
1805                 }
1806         }
1807         
1808         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1809                 cur->fd = -1;
1810                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1811         }
1812         
1813         if (cur) {
1814                 if (cur->fwh)
1815                         munmap((void*)cur->fwh, cur->mmaplen);
1816                 if (cur->fd > -1)
1817                         close(cur->fd);
1818                 cur->fwh = fwh;
1819                 cur->fd = fd;
1820                 cur->mmaplen = stbuf.st_size;
1821                 cur->dead = 0;
1822         }
1823         
1824         return 0;
1825 }
1826
1827 static int iax_check_version(char *dev)
1828 {
1829         int res = 0;
1830         struct iax_firmware *cur = NULL;
1831
1832         if (ast_strlen_zero(dev))
1833                 return 0;
1834
1835         AST_LIST_LOCK(&firmwares);
1836         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1837                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1838                         res = ntohs(cur->fwh->version);
1839                         break;
1840                 }
1841         }
1842         AST_LIST_UNLOCK(&firmwares);
1843
1844         return res;
1845 }
1846
1847 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1848 {
1849         int res = -1;
1850         unsigned int bs = desc & 0xff;
1851         unsigned int start = (desc >> 8) & 0xffffff;
1852         unsigned int bytes;
1853         struct iax_firmware *cur;
1854
1855         if (ast_strlen_zero((char *)dev) || !bs)
1856                 return -1;
1857
1858         start *= bs;
1859         
1860         AST_LIST_LOCK(&firmwares);
1861         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1862                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1863                         continue;
1864                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1865                 if (start < ntohl(cur->fwh->datalen)) {
1866                         bytes = ntohl(cur->fwh->datalen) - start;
1867                         if (bytes > bs)
1868                                 bytes = bs;
1869                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1870                 } else {
1871                         bytes = 0;
1872                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1873                 }
1874                 if (bytes == bs)
1875                         res = 0;
1876                 else
1877                         res = 1;
1878                 break;
1879         }
1880         AST_LIST_UNLOCK(&firmwares);
1881
1882         return res;
1883 }
1884
1885
1886 static void reload_firmware(int unload)
1887 {
1888         struct iax_firmware *cur = NULL;
1889         DIR *fwd;
1890         struct dirent *de;
1891         char dir[256], fn[256];
1892
1893         AST_LIST_LOCK(&firmwares);
1894
1895         /* Mark all as dead */
1896         AST_LIST_TRAVERSE(&firmwares, cur, list)
1897                 cur->dead = 1;
1898
1899         /* Now that we have marked them dead... load new ones */
1900         if (!unload) {
1901                 snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1902                 fwd = opendir(dir);
1903                 if (fwd) {
1904                         while((de = readdir(fwd))) {
1905                                 if (de->d_name[0] != '.') {
1906                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1907                                         if (!try_firmware(fn)) {
1908                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
1909                                         }
1910                                 }
1911                         }
1912                         closedir(fwd);
1913                 } else 
1914                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1915         }
1916
1917         /* Clean up leftovers */
1918         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1919                 if (!cur->dead)
1920                         continue;
1921                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1922                 destroy_firmware(cur);
1923         }
1924         AST_LIST_TRAVERSE_SAFE_END
1925
1926         AST_LIST_UNLOCK(&firmwares);
1927 }
1928
1929 /*!
1930  * \note This function assumes that iaxsl[callno] is locked when called.
1931  *
1932  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1933  * was valid before calling it, it may no longer be valid after calling it.
1934  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
1935  * associated with this callno, meaning that another thread may grab it and destroy the call.
1936  */
1937 static int __do_deliver(void *data)
1938 {
1939         /* Just deliver the packet by using queueing.  This is called by
1940           the IAX thread with the iaxsl lock held. */
1941         struct iax_frame *fr = data;
1942         fr->retrans = -1;
1943         fr->af.has_timing_info = 0;
1944         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1945                 iax2_queue_frame(fr->callno, &fr->af);
1946         /* Free our iax frame */
1947         iax2_frame_free(fr);
1948         /* And don't run again */
1949         return 0;
1950 }
1951
1952 static int handle_error(void)
1953 {
1954         /* XXX Ideally we should figure out why an error occurred and then abort those
1955            rather than continuing to try.  Unfortunately, the published interface does
1956            not seem to work XXX */
1957 #if 0
1958         struct sockaddr_in *sin;
1959         int res;
1960         struct msghdr m;
1961         struct sock_extended_err e;
1962         m.msg_name = NULL;
1963         m.msg_namelen = 0;
1964         m.msg_iov = NULL;
1965         m.msg_control = &e;
1966         m.msg_controllen = sizeof(e);
1967         m.msg_flags = 0;
1968         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1969         if (res < 0)
1970                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1971         else {
1972                 if (m.msg_controllen) {
1973                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1974                         if (sin) 
1975                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1976                         else
1977                                 ast_log(LOG_WARNING, "No address detected??\n");
1978                 } else {
1979                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1980                 }
1981         }
1982 #endif
1983         return 0;
1984 }
1985
1986 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1987 {
1988         int res;
1989         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1990                                         sizeof(*sin));
1991         if (res < 0) {
1992                 ast_debug(1, "Received error: %s\n", strerror(errno));
1993                 handle_error();
1994         } else
1995                 res = 0;
1996         return res;
1997 }
1998
1999 static int send_packet(struct iax_frame *f)
2000 {
2001         int res;
2002         int callno = f->callno;
2003
2004         /* Don't send if there was an error, but return error instead */
2005         if (!callno || !iaxs[callno] || iaxs[callno]->error)
2006             return -1;
2007         
2008         /* Called with iaxsl held */
2009         if (iaxdebug)
2010                 ast_debug(3, "Sending %d on %d/%d to %s:%d\n", f->ts, callno, iaxs[callno]->peercallno, ast_inet_ntoa(iaxs[callno]->addr.sin_addr), ntohs(iaxs[callno]->addr.sin_port));
2011         if (f->transfer) {
2012                 if (iaxdebug)
2013                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
2014                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
2015                                         sizeof(iaxs[callno]->transfer));
2016         } else {
2017                 if (iaxdebug)
2018                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
2019                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
2020                                         sizeof(iaxs[callno]->addr));
2021         }
2022         if (res < 0) {
2023                 if (iaxdebug)
2024                         ast_debug(1, "Received error: %s\n", strerror(errno));
2025                 handle_error();
2026         } else
2027                 res = 0;
2028         return res;
2029 }
2030
2031 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
2032 {
2033         /* Decrement AUTHREQ count if needed */
2034         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
2035                 struct iax2_user *user;
2036                 struct iax2_user tmp_user = {
2037                         .name = pvt->username,
2038                 };
2039
2040                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
2041                 if (user) {
2042                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
2043                         user_unref(user);       
2044                 }
2045
2046                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
2047         }
2048         /* No more pings or lagrq's */
2049         if (pvt->pingid > -1)
2050                 ast_sched_del(sched, pvt->pingid);
2051         pvt->pingid = -1;
2052         if (pvt->lagid > -1)
2053                 ast_sched_del(sched, pvt->lagid);
2054         pvt->lagid = -1;
2055         if (pvt->autoid > -1)
2056                 ast_sched_del(sched, pvt->autoid);
2057         pvt->autoid = -1;
2058         if (pvt->authid > -1)
2059                 ast_sched_del(sched, pvt->authid);
2060         pvt->authid = -1;
2061         if (pvt->initid > -1)
2062                 ast_sched_del(sched, pvt->initid);
2063         pvt->initid = -1;
2064         if (pvt->jbid > -1)
2065                 ast_sched_del(sched, pvt->jbid);
2066         pvt->jbid = -1;
2067 }
2068
2069 /*!
2070  * \note Since this function calls iax2_queue_hangup(), the pvt struct
2071  *       for the given call number may disappear during its execution.
2072  */
2073 static int iax2_predestroy(int callno)
2074 {
2075         struct ast_channel *c = NULL;
2076         struct chan_iax2_pvt *pvt = iaxs[callno];
2077
2078         if (!pvt)
2079                 return -1;
2080
2081         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
2082                 iax2_destroy_helper(pvt);
2083                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2084         }
2085
2086         if ((c = pvt->owner)) {
2087                 c->tech_pvt = NULL;
2088                 iax2_queue_hangup(callno);
2089                 pvt->owner = NULL;
2090                 ast_module_unref(ast_module_info->self);
2091         }
2092
2093         return 0;
2094 }
2095
2096 static void iax2_destroy(int callno)
2097 {
2098         struct chan_iax2_pvt *pvt = NULL;
2099         struct iax_frame *cur = NULL;
2100         struct ast_channel *owner = NULL;
2101
2102 retry:
2103         pvt = iaxs[callno];
2104         lastused[callno] = ast_tvnow();
2105         
2106         owner = pvt ? pvt->owner : NULL;
2107
2108         if (owner) {
2109                 if (ast_channel_trylock(owner)) {
2110                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
2111                         ast_mutex_unlock(&iaxsl[callno]);
2112                         usleep(1);
2113                         ast_mutex_lock(&iaxsl[callno]);
2114                         goto retry;
2115                 }
2116         }
2117         if (!owner)
2118                 iaxs[callno] = NULL;
2119         if (pvt) {
2120                 if (!owner)
2121                         pvt->owner = NULL;
2122                 iax2_destroy_helper(pvt);
2123
2124                 /* Already gone */
2125                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2126
2127                 if (owner) {
2128                         /* If there's an owner, prod it to give up */
2129                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
2130                          * because we already hold the owner channel lock. */
2131                         ast_queue_hangup(owner);
2132                 }
2133
2134                 AST_LIST_LOCK(&frame_queue);
2135                 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2136                         /* Cancel any pending transmissions */
2137                         if (cur->callno == pvt->callno) 
2138                                 cur->retries = -1;
2139                 }
2140                 AST_LIST_UNLOCK(&frame_queue);
2141
2142                 if (pvt->reg)
2143                         pvt->reg->callno = 0;
2144                 if (!owner) {
2145                         jb_frame frame;
2146                         if (pvt->vars) {
2147                             ast_variables_destroy(pvt->vars);
2148                             pvt->vars = NULL;
2149                         }
2150
2151                         while (jb_getall(pvt->jb, &frame) == JB_OK)
2152                                 iax2_frame_free(frame.data);
2153                         jb_destroy(pvt->jb);
2154                         /* gotta free up the stringfields */
2155                         ast_string_field_free_pools(pvt);
2156                         ast_free(pvt);
2157                 }
2158         }
2159         if (owner) {
2160                 ast_channel_unlock(owner);
2161         }
2162         if (callno & 0x4000)
2163                 update_max_trunk();
2164 }
2165
2166 static int update_packet(struct iax_frame *f)
2167 {
2168         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2169         struct ast_iax2_full_hdr *fh = f->data;
2170         /* Mark this as a retransmission */
2171         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2172         /* Update iseqno */
2173         f->iseqno = iaxs[f->callno]->iseqno;
2174         fh->iseqno = f->iseqno;
2175         return 0;
2176 }
2177
2178 static int attempt_transmit(const void *data);
2179 static void __attempt_transmit(const void *data)
2180 {
2181         /* Attempt to transmit the frame to the remote peer...
2182            Called without iaxsl held. */
2183         struct iax_frame *f = (struct iax_frame *)data;
2184         int freeme = 0;
2185         int callno = f->callno;
2186         /* Make sure this call is still active */
2187         if (callno) 
2188                 ast_mutex_lock(&iaxsl[callno]);
2189         if (callno && iaxs[callno]) {
2190                 if ((f->retries < 0) /* Already ACK'd */ ||
2191                     (f->retries >= max_retries) /* Too many attempts */) {
2192                                 /* Record an error if we've transmitted too many times */
2193                                 if (f->retries >= max_retries) {
2194                                         if (f->transfer) {
2195                                                 /* Transfer timeout */
2196                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
2197                                         } else if (f->final) {
2198                                                 if (f->final) 
2199                                                         iax2_destroy(callno);
2200                                         } else {
2201                                                 if (iaxs[callno]->owner)
2202                                                         ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
2203                                                 iaxs[callno]->error = ETIMEDOUT;
2204                                                 if (iaxs[callno]->owner) {
2205                                                         struct ast_frame fr = { 0, };
2206                                                         /* Hangup the fd */
2207                                                         fr.frametype = AST_FRAME_CONTROL;
2208                                                         fr.subclass = AST_CONTROL_HANGUP;
2209                                                         iax2_queue_frame(callno, &fr); // XXX
2210                                                         /* Remember, owner could disappear */
2211                                                         if (iaxs[callno] && iaxs[callno]->owner)
2212                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2213                                                 } else {
2214                                                         if (iaxs[callno]->reg) {
2215                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2216                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2217                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2218                                                         }
2219                                                         iax2_destroy(callno);
2220                                                 }
2221                                         }
2222
2223                                 }
2224                                 freeme = 1;
2225                 } else {
2226                         /* Update it if it needs it */
2227                         update_packet(f);
2228                         /* Attempt transmission */
2229                         send_packet(f);
2230                         f->retries++;
2231                         /* Try again later after 10 times as long */
2232                         f->retrytime *= 10;
2233                         if (f->retrytime > MAX_RETRY_TIME)
2234                                 f->retrytime = MAX_RETRY_TIME;
2235                         /* Transfer messages max out at one second */
2236                         if (f->transfer && (f->retrytime > 1000))
2237                                 f->retrytime = 1000;
2238                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
2239                 }
2240         } else {
2241                 /* Make sure it gets freed */
2242                 f->retries = -1;
2243                 freeme = 1;
2244         }
2245         if (callno)
2246                 ast_mutex_unlock(&iaxsl[callno]);
2247         /* Do not try again */
2248         if (freeme) {
2249                 /* Don't attempt delivery, just remove it from the queue */
2250                 AST_LIST_LOCK(&frame_queue);
2251                 AST_LIST_REMOVE(&frame_queue, f, list);
2252                 AST_LIST_UNLOCK(&frame_queue);
2253                 f->retrans = -1;
2254                 /* Free the IAX frame */
2255                 iax2_frame_free(f);
2256         }
2257 }
2258
2259 static int attempt_transmit(const void *data)
2260 {
2261 #ifdef SCHED_MULTITHREADED
2262         if (schedule_action(__attempt_transmit, data))
2263 #endif          
2264                 __attempt_transmit(data);
2265         return 0;
2266 }
2267
2268 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2269 {
2270         struct iax2_peer *peer;
2271
2272         switch (cmd) {
2273         case CLI_INIT:
2274                 e->command = "iax2 prune realtime";
2275                 e->usage =
2276                         "Usage: iax2 prune realtime [<peername>|all]\n"
2277                         "       Prunes object(s) from the cache\n";
2278                 return NULL;
2279         case CLI_GENERATE:
2280                 return complete_iax2_show_peer(a->line, a->word, a->pos, a->n);
2281         }
2282
2283         if (a->argc != 4)
2284         return CLI_SHOWUSAGE;
2285         if (!strcmp(a->argv[3], "all")) {
2286                 reload_config();
2287                 ast_cli(a->fd, "Cache flushed successfully.\n");
2288         } else if ((peer = find_peer(a->argv[3], 0))) {
2289                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2290                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2291                         expire_registry(peer_ref(peer));
2292                         ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
2293                 } else {
2294                         ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
2295                 }
2296                 peer_unref(peer);
2297         } else {
2298                 ast_cli(a->fd, "Peer %s was not found in the cache.\n", a->argv[3]);
2299         }
2300         
2301         return CLI_SUCCESS;
2302 }
2303
2304 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2305 {
2306         switch (cmd) {
2307         case CLI_INIT:
2308                 e->command = "iax2 test losspct";
2309                 e->usage =
2310                         "Usage: iax2 test losspct <percentage>\n"
2311                         "       For testing, throws away <percentage> percent of incoming packets\n";
2312                 return NULL;
2313         case CLI_GENERATE:
2314                 return NULL;
2315         }
2316         if (a->argc != 4)
2317                 return CLI_SHOWUSAGE;
2318
2319         test_losspct = atoi(a->argv[3]);
2320
2321         return CLI_SUCCESS;
2322 }
2323
2324 #ifdef IAXTESTS
2325 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2326 {
2327         switch (cmd) {
2328         case CLI_INIT:
2329                 e->command = "iax2 test late";
2330                 e->usage =
2331                         "Usage: iax2 test late <ms>\n"
2332                         "       For testing, count the next frame as <ms> ms late\n";
2333                 return NULL;
2334         case CLI_GENERATE:
2335                 return NULL;
2336         }
2337
2338         if (a->argc != 4)
2339                 return CLI_SHOWUSAGE;
2340
2341         test_late = atoi(a->argv[3]);
2342
2343         return CLI_SUCCESS;
2344 }
2345
2346 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2347 {
2348         switch (cmd) {
2349         case CLI_INIT:
2350                 e->command = "iax2 test resync";
2351                 e->usage =
2352                         "Usage: iax2 test resync <ms>\n"
2353                         "       For testing, adjust all future frames by <ms> ms\n";
2354                 return NULL;
2355         case CLI_GENERATE:
2356                 return NULL;
2357         }
2358
2359         if (a->argc != 4)
2360                 return CLI_SHOWUSAGE;
2361
2362         test_resync = atoi(a->argv[3]);
2363
2364         return CLI_SUCCESS;
2365 }
2366
2367 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2368 {
2369         switch (cmd) {
2370         case CLI_INIT:
2371                 e->command = "iax2 test jitter";
2372                 e->usage =
2373                         "Usage: iax2 test jitter <ms> <pct>\n"
2374                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
2375                         "       percentage of packets. If <pct> is not specified, adds\n"
2376                         "       jitter to all packets.\n";
2377                 return NULL;
2378         case CLI_GENERATE:
2379                 return NULL;
2380         }
2381
2382         if (a->argc < 4 || a->argc > 5)
2383                 return CLI_SHOWUSAGE;
2384
2385         test_jit = atoi(a->argv[3]);
2386         if (a->argc == 5)
2387                 test_jitpct = atoi(a->argv[4]);
2388
2389         return CLI_SUCCESS;
2390 }
2391 #endif /* IAXTESTS */
2392
2393 /*! \brief  peer_status: Report Peer status in character string */
2394 /*      returns 1 if peer is online, -1 if unmonitored */
2395 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2396 {
2397         int res = 0;
2398         if (peer->maxms) {
2399                 if (peer->lastms < 0) {
2400                         ast_copy_string(status, "UNREACHABLE", statuslen);
2401                 } else if (peer->lastms > peer->maxms) {
2402                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2403                         res = 1;
2404                 } else if (peer->lastms) {
2405                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2406                         res = 1;
2407                 } else {
2408                         ast_copy_string(status, "UNKNOWN", statuslen);
2409                 }
2410         } else { 
2411                 ast_copy_string(status, "Unmonitored", statuslen);
2412                 res = -1;
2413         }
2414         return res;
2415 }
2416
2417 /*! \brief Show one peer in detail */
2418 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2419 {
2420         char status[30];
2421         char cbuf[256];
2422         struct iax2_peer *peer;
2423         char codec_buf[512];
2424         int x = 0, codec = 0, load_realtime = 0;
2425
2426         switch (cmd) {
2427         case CLI_INIT:
2428                 e->command = "iax2 show peer";
2429                 e->usage =
2430                         "Usage: iax2 show peer <name>\n"
2431                         "       Display details on specific IAX peer\n";
2432                 return NULL;
2433         case CLI_GENERATE:
2434                 return complete_iax2_show_peer(a->line, a->word, a->pos, a->n);
2435         }
2436
2437         if (a->argc < 4)
2438                 return CLI_SHOWUSAGE;
2439
2440         load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
2441
2442         peer = find_peer(a->argv[3], load_realtime);
2443         if (peer) {
2444                 ast_cli(a->fd, "\n\n");
2445                 ast_cli(a->fd, "  * Name       : %s\n", peer->name);
2446                 ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
2447                 ast_cli(a->fd, "  Context      : %s\n", peer->context);
2448                 ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
2449                 ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes" : "No");
2450                 ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2451                 ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
2452                 ast_cli(a->fd, "  ACL          : %s\n", (peer->ha ? "Yes" : "No"));
2453                 ast_cli(a->fd, "  Addr->IP     : %s Port %d\n",  peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
2454                 ast_cli(a->fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2455                 ast_cli(a->fd, "  Username     : %s\n", peer->username);
2456                 ast_cli(a->fd, "  Codecs       : ");
2457                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2458                 ast_cli(a->fd, "%s\n", codec_buf);
2459
2460                 ast_cli(a->fd, "  Codec Order  : (");
2461                 for(x = 0; x < 32 ; x++) {
2462                         codec = ast_codec_pref_index(&peer->prefs,x);
2463                         if(!codec)
2464                                 break;
2465                         ast_cli(a->fd, "%s", ast_getformatname(codec));
2466                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2467                                 ast_cli(a->fd, "|");
2468                 }
2469
2470                 if (!x)
2471                         ast_cli(a->fd, "none");
2472                 ast_cli(a->fd, ")\n");
2473
2474                 ast_cli(a->fd, "  Status       : ");
2475                 peer_status(peer, status, sizeof(status));      
2476                 ast_cli(a->fd, "%s\n",status);
2477                 ast_cli(a->fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2478                 ast_cli(a->fd, "\n");
2479                 peer_unref(peer);
2480         } else {
2481                 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
2482                 ast_cli(a->fd, "\n");
2483         }
2484
2485         return CLI_SUCCESS;
2486 }
2487
2488 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2489 {
2490         int which = 0;
2491         struct iax2_peer *peer;
2492         char *res = NULL;
2493         int wordlen = strlen(word);
2494         struct ao2_iterator i;
2495
2496         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2497         if (pos != 3)
2498                 return NULL;
2499
2500         i = ao2_iterator_init(peers, 0);
2501         while ((peer = ao2_iterator_next(&i))) {
2502                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state) {
2503                         res = ast_strdup(peer->name);
2504                         peer_unref(peer);
2505                         break;
2506                 }
2507                 peer_unref(peer);
2508         }
2509
2510         return res;
2511 }
2512
2513 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2514 {
2515         struct iax_frame *cur;
2516         int cnt = 0, dead = 0, final = 0;
2517
2518         switch (cmd) {
2519         case CLI_INIT:
2520                 e->command = "iax2 show stats";
2521                 e->usage =
2522                         "Usage: iax2 show stats\n"
2523                         "       Display statistics on IAX channel driver.\n";
2524                 return NULL;
2525         case CLI_GENERATE:
2526                 return NULL;
2527         }
2528
2529         if (a->argc != 3)
2530                 return CLI_SHOWUSAGE;
2531
2532         AST_LIST_LOCK(&frame_queue);
2533         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2534                 if (cur->retries < 0)
2535                         dead++;
2536                 if (cur->final)
2537                         final++;
2538                 cnt++;
2539         }
2540         AST_LIST_UNLOCK(&frame_queue);
2541
2542         ast_cli(a->fd, "    IAX Statistics\n");
2543         ast_cli(a->fd, "---------------------\n");
2544         ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2545         ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2546                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2547         ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2548
2549         trunk_timed = trunk_untimed = 0;
2550         if (trunk_maxmtu > trunk_nmaxmtu)
2551                 trunk_nmaxmtu = trunk_maxmtu;
2552
2553         return CLI_SUCCESS;
2554 }
2555
2556 /*! \brief Set trunk MTU from CLI */
2557 static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2558 {
2559         int mtuv;
2560
2561         switch (cmd) {
2562         case CLI_INIT:
2563                 e->command = "iax2 set mtu";
2564                 e->usage =
2565                         "Usage: iax2 set mtu <value>\n"
2566                         "       Set the system-wide IAX IP mtu to <value> bytes net or\n"
2567                         "       zero to disable. Disabling means that the operating system\n"
2568                         "       must handle fragmentation of UDP packets when the IAX2 trunk\n"
2569                         "       packet exceeds the UDP payload size. This is substantially\n"
2570                         "       below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
2571                         "       greater for G.711 samples.\n";
2572                 return NULL;
2573         case CLI_GENERATE:
2574                 return NULL;
2575         }
2576
2577         if (a->argc != 4)
2578                 return CLI_SHOWUSAGE; 
2579         if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
2580                 mtuv = MAX_TRUNK_MTU;
2581         else
2582                 mtuv = atoi(a->argv[3]);
2583
2584         if (mtuv == 0) {
2585                 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2586                 global_max_trunk_mtu = 0; 
2587                 return CLI_SUCCESS; 
2588         }
2589         if (mtuv < 172 || mtuv > 4000) {
2590                 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n"); 
2591                 return CLI_SHOWUSAGE; 
2592         }
2593         ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2594         global_max_trunk_mtu = mtuv; 
2595         return CLI_SUCCESS;
2596 }
2597
2598 static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2599 {
2600         struct iax2_dpcache *dp = NULL;
2601         char tmp[1024], *pc = NULL;
2602         int s, x, y;
2603         struct timeval tv = ast_tvnow();
2604
2605         switch (cmd) {
2606         case CLI_INIT:
2607                 e->command = "iax2 show cache";
2608                 e->usage =
2609                         "Usage: iax2 show cache\n"
2610                         "       Display currently cached IAX Dialplan results.\n";
2611                 return NULL;
2612         case CLI_GENERATE:
2613                 return NULL;
2614         }
2615
2616         AST_LIST_LOCK(&dpcache);
2617
2618         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2619
2620         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2621                 s = dp->expiry.tv_sec - tv.tv_sec;
2622                 tmp[0] = '\0';
2623                 if (dp->flags & CACHE_FLAG_EXISTS)
2624                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2625                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2626                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2627                 if (dp->flags & CACHE_FLAG_CANEXIST)
2628                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2629                 if (dp->flags & CACHE_FLAG_PENDING)
2630                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2631                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2632                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2633                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2634                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2635                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2636                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2637                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2638                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2639                 /* Trim trailing pipe */
2640                 if (!ast_strlen_zero(tmp))
2641                         tmp[strlen(tmp) - 1] = '\0';
2642                 else
2643                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2644                 y = 0;
2645                 pc = strchr(dp->peercontext, '@');
2646                 if (!pc)
2647                         pc = dp->peercontext;
2648                 else
2649                         pc++;
2650                 for (x = 0; x < sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2651                         if (dp->waiters[x] > -1)
2652                                 y++;
2653                 if (s > 0)
2654                         ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2655                 else
2656                         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2657         }
2658
2659         AST_LIST_LOCK(&dpcache);
2660
2661         return CLI_SUCCESS;
2662 }
2663
2664 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2665
2666 static void unwrap_timestamp(struct iax_frame *fr)
2667 {
2668         int x;
2669
2670         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2671                 x = fr->ts - iaxs[fr->callno]->last;
2672                 if (x < -50000) {
2673                         /* Sudden big jump backwards in timestamp:
2674                            What likely happened here is that miniframe timestamp has circled but we haven't
2675                            gotten the update from the main packet.  We'll just pretend that we did, and
2676                            update the timestamp appropriately. */
2677                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2678                         if (iaxdebug)
2679                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2680                 }
2681                 if (x > 50000) {
2682                         /* Sudden apparent big jump forwards in timestamp:
2683                            What's likely happened is this is an old miniframe belonging to the previous
2684                            top-16-bit timestamp that has turned up out of order.
2685                            Adjust the timestamp appropriately. */
2686                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2687                         if (iaxdebug)
2688                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2689                 }
2690         }
2691 }
2692
2693 static int get_from_jb(const void *p);
2694
2695 static void update_jbsched(struct chan_iax2_pvt *pvt)
2696 {
2697         int when;
2698         
2699         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2700         
2701         when = jb_next(pvt->jb) - when;
2702         
2703         if(when <= 0) {
2704                 /* XXX should really just empty until when > 0.. */
2705                 when = 1;
2706         }
2707         
2708         pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb, 
2709                 CALLNO_TO_PTR(pvt->callno));
2710 }
2711
2712 static void __get_from_jb(const void *p) 
2713 {
2714         int callno = PTR_TO_CALLNO(p);
2715         struct chan_iax2_pvt *pvt = NULL;
2716         struct iax_frame *fr;
2717         jb_frame frame;
2718         int ret;
2719         long now;
2720         long next;
2721         struct timeval tv = ast_tvnow();
2722         
2723         /* Make sure we have a valid private structure before going on */
2724         ast_mutex_lock(&iaxsl[callno]);
2725         pvt = iaxs[callno];
2726         if (!pvt) {
2727                 /* No go! */
2728                 ast_mutex_unlock(&iaxsl[callno]);
2729                 return;
2730         }
2731
2732         pvt->jbid = -1;
2733         
2734         /* round up a millisecond since ast_sched_runq does; */
2735         /* prevents us from spinning while waiting for our now */
2736         /* to catch up with runq's now */
2737         tv.tv_usec += 1000;
2738         
2739         now = ast_tvdiff_ms(tv, pvt->rxcore);
2740         
2741         if(now >= (next = jb_next(pvt->jb))) {
2742                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2743                 switch(ret) {
2744                 case JB_OK:
2745                         fr = frame.data;
2746                         __do_deliver(fr);
2747                         /* __do_deliver() can cause the call to disappear */
2748                         pvt = iaxs[callno];
2749                         break;
2750                 case JB_INTERP:
2751                 {
2752                         struct ast_frame af = { 0, };
2753                         
2754                         /* create an interpolation frame */
2755                         af.frametype = AST_FRAME_VOICE;
2756                         af.subclass = pvt->voiceformat;
2757                         af.samples  = frame.ms * 8;
2758                         af.src  = "IAX2 JB interpolation";
2759                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2760                         af.offset = AST_FRIENDLY_OFFSET;
2761                         
2762                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2763                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2764                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2765                                 iax2_queue_frame(callno, &af);
2766                                 /* iax2_queue_frame() could cause the call to disappear */
2767                                 pvt = iaxs[callno];
2768                         }
2769                 }
2770                         break;
2771                 case JB_DROP:
2772                         iax2_frame_free(frame.data);
2773                         break;
2774                 case JB_NOFRAME:
2775                 case JB_EMPTY:
2776                         /* do nothing */
2777                         break;
2778                 default:
2779                         /* shouldn't happen */
2780                         break;
2781                 }
2782         }
2783         if (pvt)
2784                 update_jbsched(pvt);
2785         ast_mutex_unlock(&iaxsl[callno]);
2786 }
2787
2788 static int get_from_jb(const void *data)
2789 {
2790 #ifdef SCHED_MULTITHREADED
2791         if (schedule_action(__get_from_jb, data))
2792 #endif          
2793                 __get_from_jb(data);
2794         return 0;
2795 }
2796
2797 /*!
2798  * \note This function assumes fr->callno is locked
2799  *
2800  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2801  * was valid before calling it, it may no longer be valid after calling it.
2802  */
2803 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2804 {
2805         int type, len;
2806         int ret;
2807         int needfree = 0;
2808
2809         /* Attempt to recover wrapped timestamps */
2810         unwrap_timestamp(fr);
2811
2812         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2813         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2814                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2815         else {
2816 #if 0
2817                 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2818 #endif
2819                 fr->af.delivery = ast_tv(0,0);
2820         }
2821
2822         type = JB_TYPE_CONTROL;
2823         len = 0;
2824
2825         if(fr->af.frametype == AST_FRAME_VOICE) {
2826                 type = JB_TYPE_VOICE;
2827                 len = ast_codec_get_samples(&fr->af) / 8;
2828         } else if(fr->af.frametype == AST_FRAME_CNG) {
2829                 type = JB_TYPE_SILENCE;
2830         }
2831
2832         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2833                 if (tsout)
2834                         *tsout = fr->ts;
2835                 __do_deliver(fr);
2836                 return -1;
2837         }
2838
2839         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2840          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2841         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2842             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2843             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2844                 jb_frame frame;
2845
2846                 /* deliver any frames in the jb */
2847                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2848                         __do_deliver(frame.data);
2849                         /* __do_deliver() can make the call disappear */
2850                         if (!iaxs[fr->callno])
2851                                 return -1;
2852                 }
2853
2854                 jb_reset(iaxs[fr->callno]->jb);
2855
2856                 if (iaxs[fr->callno]->jbid > -1)
2857                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2858
2859                 iaxs[fr->callno]->jbid = -1;
2860
2861                 /* deliver this frame now */
2862                 if (tsout)
2863                         *tsout = fr->ts;
2864                 __do_deliver(fr);
2865                 return -1;
2866         }
2867
2868         /* insert into jitterbuffer */
2869         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2870         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2871                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2872         if (ret == JB_DROP) {
2873                 needfree++;
2874         } else if (ret == JB_SCHED) {
2875                 update_jbsched(iaxs[fr->callno]);
2876         }
2877         if (tsout)
2878                 *tsout = fr->ts;
2879         if (needfree) {
2880                 /* Free our iax frame */
2881                 iax2_frame_free(fr);
2882                 return -1;
2883         }
2884         return 0;
2885 }
2886
2887 static int iax2_transmit(struct iax_frame *fr)
2888 {
2889         /* Lock the queue and place this packet at the end */
2890         /* By setting this to 0, the network thread will send it for us, and
2891            queue retransmission if necessary */
2892         fr->sentyet = 0;
2893         AST_LIST_LOCK(&frame_queue);
2894         AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
2895         AST_LIST_UNLOCK(&frame_queue);
2896         /* Wake up the network and scheduler thread */
2897         if (netthreadid != AST_PTHREADT_NULL)
2898                 pthread_kill(netthreadid, SIGURG);
2899         signal_condition(&sched_lock, &sched_cond);
2900         return 0;
2901 }
2902
2903
2904
2905 static int iax2_digit_begin(struct ast_channel *c, char digit)
2906 {
2907         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2908 }
2909
2910 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2911 {
2912         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2913 }
2914
2915 static int iax2_sendtext(struct ast_channel *c, const char *text)
2916 {
2917         
2918         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2919                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2920 }
2921
2922 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2923 {
2924         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2925 }
2926
2927 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2928 {
2929         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2930 }
2931
2932 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2933 {
2934         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2935         ast_mutex_lock(&iaxsl[callno]);
2936         if (iaxs[callno])
2937                 iaxs[callno]->owner = newchan;
2938         else
2939                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2940         ast_mutex_unlock(&iaxsl[callno]);
2941         return 0;
2942 }
2943
2944 /*!
2945  * \note This function calls reg_source_db -> iax2_poke_peer -> find_callno,
2946  *       so do not call this with a pvt lock held.
2947  */
2948 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2949 {
2950         struct ast_variable *var;
2951         struct ast_variable *tmp;
2952         struct iax2_peer *peer=NULL;
2953         time_t regseconds = 0, nowtime;
2954         int dynamic=0;
2955
2956         if (peername)
2957                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2958         else {
2959                 char porta[25];
2960                 sprintf(porta, "%d", ntohs(sin->sin_port));
2961                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2962                 if (var) {
2963                         /* We'll need the peer name in order to build the structure! */
2964                         for (tmp = var; tmp; tmp = tmp->next) {
2965                                 if (!strcasecmp(tmp->name, "name"))
2966                                         peername = tmp->value;
2967                         }
2968                 }
2969         }
2970         if (!var)
2971                 return NULL;
2972
2973         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2974         
2975         if (!peer) {
2976                 ast_variables_destroy(var);
2977                 return NULL;
2978         }
2979
2980         for (tmp = var; tmp; tmp = tmp->next) {
2981                 /* Make sure it's not a user only... */
2982                 if (!strcasecmp(tmp->name, "type")) {
2983                         if (strcasecmp(tmp->value, "friend") &&
2984                             strcasecmp(tmp->value, "peer")) {
2985                                 /* Whoops, we weren't supposed to exist! */
2986                                 peer = peer_unref(peer);
2987                                 break;
2988                         } 
2989                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2990                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2991                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2992                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2993                 } else if (!strcasecmp(tmp->name, "port")) {
2994                         peer->addr.sin_port = htons(atoi(tmp->value));
2995                 } else if (!strcasecmp(tmp->name, "host")) {
2996                         if (!strcasecmp(tmp->value, "dynamic"))
2997                                 dynamic = 1;
2998                 }
2999         }
3000
3001         ast_variables_destroy(var);
3002
3003         if (!peer)
3004                 return NULL;
3005
3006         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
3007                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
3008                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
3009                         if (peer->expire > -1) {
3010                                 if (!ast_sched_del(sched, peer->expire)) {
3011                                         peer->expire = -1;
3012                                         peer_unref(peer);
3013                                 }
3014                         }
3015                         peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
3016                         if (peer->expire == -1)
3017                                 peer_unref(peer);
3018                 }
3019                 ao2_link(peers, peer_ref(peer));
3020                 if (ast_test_flag(peer, IAX_DYNAMIC))
3021                         reg_source_db(peer);
3022         } else {
3023                 ast_set_flag(peer, IAX_TEMPONLY);       
3024         }
3025
3026         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
3027                 time(&nowtime);
3028                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
3029                         memset(&peer->addr, 0, sizeof(peer->addr));
3030                         realtime_update_peer(peer->name, &peer->addr, 0);
3031                         ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
3032                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
3033                 }
3034                 else {
3035                         ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
3036                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
3037                 }
3038         }
3039
3040         return peer;
3041 }
3042
3043 static struct iax2_user *realtime_user(const char *username)
3044 {
3045         struct ast_variable *var;
3046         struct ast_variable *tmp;
3047         struct iax2_user *user=NULL;
3048
3049         var = ast_load_realtime("iaxusers", "name", username, NULL);
3050         if (!var)
3051                 return NULL;
3052
3053         tmp = var;
3054         while(tmp) {
3055                 /* Make sure it's not a peer only... */
3056                 if (!strcasecmp(tmp->name, "type")) {
3057                         if (strcasecmp(tmp->value, "friend") &&
3058                             strcasecmp(tmp->value, "user")) {
3059                                 return NULL;
3060                         } 
3061                 }
3062                 tmp = tmp->next;
3063         }
3064
3065         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
3066
3067         ast_variables_destroy(var);
3068
3069         if (!user)
3070                 return NULL;
3071
3072         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
3073                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
3074                 ao2_link(users, user_ref(user));
3075         } else {
3076                 ast_set_flag(user, IAX_TEMPONLY);       
3077         }
3078
3079         return user;
3080 }
3081
3082 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
3083 {
3084         char port[10];
3085         char regseconds[20];
3086         
3087         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
3088         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
3089         ast_update_realtime("iaxpeers", "name", peername, 
3090                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
3091                 "regseconds", regseconds, NULL);
3092 }
3093
3094 struct create_addr_info {
3095         int capability;
3096         unsigned int flags;
3097         int maxtime;
3098         int encmethods;
3099         int found;
3100         int sockfd;
3101         int adsi;
3102         char username[80];
3103         char secret[80];
3104         char outkey[80];
3105         char timezone[80];
3106         char prefs[32];
3107         char context[AST_MAX_CONTEXT];
3108         char peercontext[AST_MAX_CONTEXT];
3109         char mohinterpret[MAX_MUSICCLASS];
3110         char mohsuggest[MAX_MUSICCLASS];
3111 };
3112
3113 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
3114 {
3115         struct iax2_peer *peer;
3116         int res = -1;
3117
3118         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
3119         cai->sockfd = defaultsockfd;
3120         cai->maxtime = 0;
3121         sin->sin_family = AF_INET;
3122
3123         if (!(peer = find_peer(peername, 1))) {
3124                 cai->found = 0;
3125                 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
3126                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
3127                         return -1;
3128                 }
3129                 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
3130                 /* use global iax prefs for unknown peer/user */
3131                 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
3132                 return 0;
3133         }
3134
3135         cai->found = 1;
3136         
3137         /* if the peer has no address (current or default), return failure */
3138         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr))
3139                 goto return_unref;
3140
3141         /* if the peer is being monitored and is currently unreachable, return failure */
3142         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
3143                 goto return_unref;
3144
3145         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
3146         cai->maxtime = peer->maxms;
3147         cai->capability = peer->capability;
3148         cai->encmethods = peer->encmethods;
3149         cai->sockfd = peer->sockfd;
3150         cai->adsi = peer->adsi;
3151         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
3152         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
3153         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
3154         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
3155         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
3156         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
3157         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
3158         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
3159         if (ast_strlen_zero(peer->dbsecret)) {
3160                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
3161         } else {
3162                 char *family;
3163                 char *key = NULL;
3164
3165                 family = ast_strdupa(peer->dbsecret);
3166                 key = strchr(family, '/');
3167                 if (key)
3168                         *key++ = '\0';
3169                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
3170                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
3171                         goto return_unref;
3172                 }
3173         }
3174
3175         if (peer->addr.sin_addr.s_addr) {
3176                 sin->sin_addr = peer->addr.sin_addr;
3177                 sin->sin_port = peer->addr.sin_port;
3178         } else {
3179                 sin->sin_addr = peer->defaddr.sin_addr;
3180                 sin->sin_port = peer->defaddr.sin_port;
3181         }
3182
3183         res = 0;
3184
3185 return_unref:
3186         peer_unref(peer);
3187
3188         return res;
3189 }
3190
3191 static void __auto_congest(const void *nothing)
3192 {
3193         int callno = PTR_TO_CALLNO(nothing);
3194         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
3195         ast_mutex_lock(&iaxsl[callno]);
3196         if (iaxs[callno]) {
3197                 iaxs[callno]->initid = -1;
3198                 iax2_queue_frame(callno, &f);
3199                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
3200         }
3201         ast_mutex_unlock(&iaxsl[callno]);
3202 }
3203
3204 static int auto_congest(const void *data)
3205 {
3206 #ifdef SCHED_MULTITHREADED
3207         if (schedule_action(__auto_congest, data))
3208 #endif          
3209                 __auto_congest(data);
3210         return 0;
3211 }
3212
3213 static unsigned int iax2_datetime(const char *tz)
3214 {
3215         struct timeval t = ast_tvnow();
3216         struct ast_tm tm;
3217         unsigned int tmp;
3218         ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
3219         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
3220         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
3221         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
3222         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
3223         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
3224         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
3225         return tmp;
3226 }
3227
3228 struct parsed_dial_string {
3229         char *username;
3230         char *password;
3231         char *key;
3232         char *peer;
3233         char *port;
3234         char *exten;
3235         char *context;
3236         char *options;
3237 };
3238
3239 /*!
3240  * \brief Parses an IAX dial string into its component parts.
3241  * \param data the string to be parsed
3242  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
3243  * \return nothing
3244  *
3245  * This function parses the string and fills the structure
3246  * with pointers to its component parts. The input string
3247  * will be modified.
3248  *
3249  * \note This function supports both plaintext passwords and RSA
3250  * key names; if the password string is formatted as '[keyname]',
3251  * then the keyname will be placed into the key field, and the
3252  * password field will be set to NULL.
3253  *
3254  * \note The dial string format is:
3255  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
3256  */
3257 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
3258 {
3259         if (ast_strlen_zero(data))
3260                 return;
3261
3262         pds->peer = strsep(&data, "/");
3263         pds->exten = strsep(&data, "/");
3264         pds->options = data;
3265
3266         if (pds->exten) {
3267                 data = pds->exten;
3268                 pds->exten = strsep(&data, "@");
3269                 pds->context = data;
3270         }
3271
3272         if (strchr(pds->peer, '@')) {
3273                 data = pds->peer;
3274                 pds->username = strsep(&data, "@");
3275                 pds->peer = data;
3276         }
3277
3278         if (pds->username) {
3279                 data = pds->username;
3280                 pds->username = strsep(&data, ":");
3281                 pds->password = data;
3282         }
3283
3284         data = pds->peer;
3285         pds->peer = strsep(&data, ":");
3286         pds->port = data;
3287
3288         /* check for a key name wrapped in [] in the secret position, if found,
3289            move it to the key field instead
3290         */
3291         if (pds->password && (pds->password[0] == '[')) {
3292                 pds->key = ast_strip_quoted(pds->password, "[", "]");
3293                 pds->password = NULL;
3294         }
3295 }
3296
3297 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
3298 {
3299         struct sockaddr_in sin;
3300         char *l=NULL, *n=NULL, *tmpstr;
3301         struct iax_ie_data ied;
3302         char *defaultrdest = "s";
3303         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3304         struct parsed_dial_string pds;
3305         struct create_addr_info cai;
3306         struct ast_var_t *var;
3307         struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
3308         const char* osp_token_ptr;
3309         unsigned int osp_token_length;
3310         unsigned char osp_block_index;
3311         unsigned int osp_block_length;
3312         unsigned char osp_buffer[256];
3313
3314         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
3315                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
3316                 return -1;
3317         }
3318
3319         memset(&cai, 0, sizeof(cai));
3320         cai.encmethods = iax2_encryption;
3321
3322         memset(&pds, 0, sizeof(pds));
3323         tmpstr = ast_strdupa(dest);
3324         parse_dial_string(tmpstr, &pds);
3325
3326         if (!pds.exten)
3327                 pds.exten = defaultrdest;
3328
3329         if (create_addr(pds.peer, &sin, &cai)) {
3330                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
3331                 return -1;
3332         }
3333
3334         if (!pds.username && !ast_strlen_zero(cai.username))
3335                 pds.username = cai.username;
3336         if (!pds.password && !ast_strlen_zero(cai.secret))
3337                 pds.password = cai.secret;
3338         if (!pds.key && !ast_strlen_zero(cai.outkey))
3339                 pds.key = cai.outkey;
3340         if (!pds.context && !ast_strlen_zero(cai.peercontext))
3341                 pds.context = cai.peercontext;
3342
3343         /* Keep track of the context for outgoing calls too */
3344         ast_copy_string(c->context, cai.context, sizeof(c->context));
3345
3346         if (pds.port)
3347                 sin.sin_port = htons(atoi(pds.port));
3348
3349         l = c->cid.cid_num;
3350         n = c->cid.cid_name;
3351
3352         /* Now build request */ 
3353         memset(&ied, 0, sizeof(ied));
3354
3355         /* On new call, first IE MUST be IAX version of caller */
3356         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
3357         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
3358         if (pds.options && strchr(pds.options, 'a')) {
3359                 /* Request auto answer */
3360                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
3361         }
3362
3363         iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
3364
3365         if (l) {
3366                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
3367                 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3368         } else {
3369                 if (n)
3370                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3371                 else
3372                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
3373         }
3374
3375         iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
3376         iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
3377
3378         if (n)
3379                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
3380         if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
3381                 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
3382
3383         if (!ast_strlen_zero(c->language))
3384                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
3385         if (!ast_strlen_zero(c->cid.cid_dnid))
3386                 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
3387         if (!ast_strlen_zero(c->cid.cid_rdnis))
3388                 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
3389
3390         if (pds.context)
3391                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
3392
3393         if (pds.username)
3394                 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
3395
3396         if (cai.encmethods)
3397                 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
3398
3399         ast_mutex_lock(&iaxsl[callno]);
3400
3401         if (!ast_strlen_zero(c->context))
3402                 ast_string_field_set(iaxs[callno], context, c->context);
3403
3404         if (pds.username)
3405                 ast_string_field_set(iaxs[callno], username, pds.username);
3406
3407         iaxs[callno]->encmethods = cai.encmethods;
3408
3409         iaxs[callno]->adsi = cai.adsi;
3410         
3411         ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
3412         ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
3413
3414         if (pds.key)
3415                 ast_string_field_set(iaxs[callno], outkey, pds.key);
3416         if (pds.password)
3417                 ast_string_field_set(iaxs[callno], secret, pds.password);
3418
3419         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
3420         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
3421         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
3422         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
3423
3424         if (iaxs[callno]->maxtime) {
3425                 /* Initialize pingtime and auto-congest time */
3426                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
3427                 iaxs[callno]->initid = iax2_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
3428         } else if (autokill) {
3429                 iaxs[callno]->pingtime = autokill / 2;
3430                 iaxs[callno]->initid = iax2_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
3431         }
3432
3433         /* Check if there is an OSP token set by IAXCHANINFO function */
3434         osp_token_ptr = iaxs[callno]->osptoken;
3435         if (!ast_strlen_zero(osp_token_ptr)) {
3436                 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
3437                         osp_block_index = 0;
3438                         while (osp_token_length > 0) {
3439                                 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
3440                                 osp_buffer[0] = osp_block_index;
3441                                 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
3442                                 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
3443                                 osp_block_index++;
3444                                 osp_token_ptr += osp_block_length;
3445                                 osp_token_length -= osp_block_length;
3446                         } 
3447                 } else
3448                         ast_log(LOG_WARNING, "OSP token is too long\n");
3449         } else if (iaxdebug)
3450                 ast_debug(1, "OSP token is undefined\n");
3451
3452         /* send the command using the appropriate socket for this peer */
3453         iaxs[callno]->sockfd = cai.sockfd;
3454
3455         /* Add remote vars */
3456         if (variablestore) {
3457                 AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
3458                 AST_LIST_LOCK(variablelist);
3459                 AST_LIST_TRAVERSE(variablelist, var, entries) {
3460                         char tmp[256];
3461                         int i;
3462                         /* Automatically divide the value up into sized chunks */
3463                         for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) + 1)) {
3464                                 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var), ast_var_value(var) + i);
3465                                 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
3466                         }
3467                 }
3468                 AST_LIST_UNLOCK(variablelist);
3469         }
3470
3471         /* Transmit the string in a "NEW" request */
3472         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
3473
3474         ast_mutex_unlock(&iaxsl[callno]);
3475         ast_setstate(c, AST_STATE_RINGING);
3476
3477         return 0;
3478 }
3479
3480 static int iax2_hangup(struct ast_channel *c) 
3481 {
3482         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3483         int alreadygone;
3484         struct iax_ie_data ied;
3485         memset(&ied, 0, sizeof(ied));
3486         ast_mutex_lock(&iaxsl[callno]);
3487         if (callno && iaxs[callno]) {
3488                 ast_debug(1, "We're hanging up %s now...\n", c->name);
3489                 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
3490                 /* Send the hangup unless we have had a transmission error or are already gone */
3491                 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
3492                 if (!iaxs[callno]->error && !alreadygone) {
3493                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
3494                         if (!iaxs[callno]) {
3495                                 ast_mutex_unlock(&iaxsl[callno]);
3496                                 return 0;
3497                         }
3498                 }
3499                 /* Explicitly predestroy it */
3500                 iax2_predestroy(callno);
3501                 /* If we were already gone to begin with, destroy us now */
3502                 if (alreadygone && iaxs[callno]) {
3503                         ast_debug(1, "Really destroying %s now...\n", c->name);
3504                         iax2_destroy(callno);
3505                 }
3506         }
3507         ast_mutex_unlock(&iaxsl[callno]);
3508         ast_verb(3, "Hungup '%s'\n", c->name);
3509         return 0;
3510 }
3511
3512 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
3513 {
3514         struct ast_option_header *h;
3515         int res;
3516
3517         switch (option) {
3518         case AST_OPTION_TXGAIN:
3519         case AST_OPTION_RXGAIN:
3520                 /* these two cannot be sent, because they require a result */
3521                 errno = ENOSYS;
3522                 return -1;
3523         default:
3524                 if (!(h = ast_malloc(datalen + sizeof(*h))))
3525                         return -1;
3526
3527                 h->flag = AST_OPTION_FLAG_REQUEST;
3528                 h->option = htons(option);
3529                 memcpy(h->data, data, datalen);
3530                 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
3531                                           AST_CONTROL_OPTION, 0, (unsigned char *) h,
3532                                           datalen + sizeof(*h), -1);
3533                 ast_free(h);
3534                 return res;
3535         }
3536 }
3537
3538 static struct ast_frame *iax2_read(struct ast_channel *c) 
3539 {
3540         ast_log(LOG_NOTICE, "I should never be called!\n");
3541         return &ast_null_frame;
3542 }
3543
3544 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
3545 {
3546         int res;
3547         struct iax_ie_data ied0;
3548         struct iax_ie_data ied1;
3549         unsigned int transferid = (unsigned int)ast_random();
3550         memset(&ied0, 0, sizeof(ied0));
3551         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
3552         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
3553         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
3554
3555         memset(&ied1, 0, sizeof(ied1));
3556         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
3557         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
3558         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
3559         
3560         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
3561         if (res)
3562                 return -1;
3563         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
3564         if (res)
3565                 return -1;
3566         iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3567         iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3568         return 0;
3569 }
3570
3571 static void lock_both(unsigned short callno0, unsigned short callno1)
3572 {
3573         ast_mutex_lock(&iaxsl[callno0]);
3574         while (ast_mutex_trylock(&iaxsl[callno1])) {
3575                 ast_mutex_unlock(&iaxsl[callno0]);
3576                 usleep(10);
3577                 ast_mutex_lock(&iaxsl[callno0]);
3578         }
3579 }
3580
3581 static void unlock_both(unsigned short callno0, unsigned short callno1)
3582 {
3583         ast_mutex_unlock(&iaxsl[callno1]);
3584         ast_mutex_unlock(&iaxsl[callno0]);
3585 }
3586
3587 static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
3588 {
3589         struct ast_channel *cs[3];
3590         struct ast_channel *who, *other;
3591         int to = -1;
3592         int res = -1;
3593         int transferstarted=0;
3594         struct ast_frame *f;
3595         unsigned short callno0 = PTR_TO_CALLNO(c0->tech_pvt);
3596         unsigned short callno1 = PTR_TO_CALLNO(c1->tech_pvt);
3597         struct timeval waittimer = {0, 0}, tv;
3598
3599         lock_both(callno0, callno1);
3600         if (!iaxs[callno0] || !iaxs[callno1]) {
3601                 unlock_both(callno0, callno1);
3602                 return AST_BRIDGE_FAILED;
3603         }
3604         /* Put them in native bridge mode */
3605         if (!flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) {
3606                 iaxs[callno0]->bridgecallno = callno1;
3607                 iaxs[callno1]->bridgecallno = callno0;
3608         }
3609         unlock_both(callno0, callno1);
3610
3611         /* If not, try to bridge until we can execute a transfer, if we can */
3612         cs[0] = c0;
3613         cs[1] = c1;
3614         for (/* ever */;;) {
3615                 /* Check in case we got masqueraded into */
3616                 if ((c0->tech != &iax2_tech) || (c1->tech != &iax2_tech)) {
3617                         ast_verb(3, "Can't masquerade, we're different...\n");
3618                         /* Remove from native mode */
3619                         if (c0->tech == &iax2_tech) {
3620                                 ast_mutex_lock(&iaxsl[callno0]);
3621                                 iaxs[callno0]->bridgecallno = 0;
3622                                 ast_mutex_unlock(&iaxsl[callno0]);
3623                         }
3624                         if (c1->tech == &iax2_tech) {
3625                                 ast_mutex_lock(&iaxsl[callno1]);
3626                                 iaxs[callno1]->bridgecallno = 0;
3627                                 ast_mutex_unlock(&iaxsl[callno1]);
3628                         }
3629                         return AST_BRIDGE_FAILED_NOWARN;
3630                 }
3631                 if (c0->nativeformats != c1->nativeformats) {
3632                                 char buf0[255];
3633                                 char buf1[255];
3634                                 ast_getformatname_multiple(buf0, sizeof(buf0) -1, c0->nativeformats);
3635                                 ast_getformatname_multiple(buf1, sizeof(buf1) -1, c1->nativeformats);
3636                         ast_verb(3, "Operating with different codecs %d[%s] %d[%s] , can't native bridge...\n", c0->nativeformats, buf0, c1->nativeformats, buf1);
3637                         /* Remove from native mode */
3638                         lock_both(callno0, callno1);
3639                         if (iaxs[callno0])
3640                                 iaxs[callno0]->bridgecallno = 0;
3641                         if (iaxs[callno1])
3642                                 iaxs[callno1]->bridgecallno = 0;
3643                         unlock_both(callno0, callno1);
3644                         return AST_BRIDGE_FAILED_NOWARN;
3645                 }
3646                 /* check if transfered and if we really want native bridging */
3647                 if (!transferstarted && !ast_test_flag(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag(iaxs[callno1], IAX_NOTRANSFER)) {
3648                         /* Try the transfer */
3649                         if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
3650                                                         ast_test_flag(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag(iaxs[callno1], IAX_TRANSFERMEDIA)))
3651                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
3652                         transferstarted = 1;
3653                 }
3654                 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
3655                         /* Call has been transferred.  We're no longer involved */
3656                         tv = ast_tvnow();
3657                         if (ast_tvzero(waittimer)) {
3658                                 waittimer = tv;
3659                         } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
3660                                 c0->_softhangup |= AST_SOFTHANGUP_DEV;
3661                                 c1->_softhangup |= AST_SOFTHANGUP_DEV;
3662                                 *fo = NULL;
3663                                 *rc = c0;
3664                                 res = AST_BRIDGE_COMPLETE;
3665                                 break;
3666                         }
3667                 }
3668                 to = 1000;
3669                 who = ast_waitfor_n(cs, 2, &to);
3670                 if (timeoutms > -1) {
3671                         timeoutms -= (1000 - to);
3672                         if (timeoutms < 0)
3673                                 timeoutms = 0;
3674                 }
3675                 if (!who) {
3676                         if (!timeoutms) {
3677                                 res = AST_BRIDGE_RETRY;