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