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