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