Merged revisions 79174 via svnmerge from
[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 static struct iax2_peer *find_peer(const char *name, int realtime) 
1188 {
1189         struct iax2_peer *peer = NULL;
1190
1191         /* Grab peer from linked list */
1192         AST_LIST_LOCK(&peers);
1193         AST_LIST_TRAVERSE(&peers, peer, entry) {
1194                 if (!strcasecmp(peer->name, name)) {
1195                         break;
1196                 }
1197         }
1198         AST_LIST_UNLOCK(&peers);
1199
1200         /* Now go for realtime if applicable */
1201         if(!peer && realtime)
1202                 peer = realtime_peer(name, NULL);
1203         return peer;
1204 }
1205
1206 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1207 {
1208         struct iax2_peer *peer = NULL;
1209         int res = 0;
1210
1211         if (lockpeer)
1212                 AST_LIST_LOCK(&peers);
1213         AST_LIST_TRAVERSE(&peers, peer, entry) {
1214                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1215                     (peer->addr.sin_port == sin.sin_port)) {
1216                         ast_copy_string(host, peer->name, len);
1217                         res = 1;
1218                         break;
1219                 }
1220         }
1221         if (lockpeer)
1222                 AST_LIST_UNLOCK(&peers);
1223         if (!peer) {
1224                 peer = realtime_peer(NULL, &sin);
1225                 if (peer) {
1226                         ast_copy_string(host, peer->name, len);
1227                         if (ast_test_flag(peer, IAX_TEMPONLY))
1228                                 destroy_peer(peer);
1229                         res = 1;
1230                 }
1231         }
1232
1233         return res;
1234 }
1235
1236 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1237 {
1238         struct chan_iax2_pvt *tmp;
1239         jb_conf jbconf;
1240
1241         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1242                 return NULL;
1243
1244         if (ast_string_field_init(tmp, 32)) {
1245                 ast_free(tmp);
1246                 tmp = NULL;
1247                 return NULL;
1248         }
1249                 
1250         tmp->prefs = prefs;
1251         tmp->pingid = -1;
1252         tmp->lagid = -1;
1253         tmp->autoid = -1;
1254         tmp->authid = -1;
1255         tmp->initid = -1;
1256
1257         ast_string_field_set(tmp,exten, "s");
1258         ast_string_field_set(tmp,host, host);
1259
1260         tmp->jb = jb_new();
1261         tmp->jbid = -1;
1262         jbconf.max_jitterbuf = maxjitterbuffer;
1263         jbconf.resync_threshold = resyncthreshold;
1264         jbconf.max_contig_interp = maxjitterinterps;
1265         jbconf.target_extra = jittertargetextra;
1266         jb_setconf(tmp->jb,&jbconf);
1267
1268         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1269
1270         return tmp;
1271 }
1272
1273 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1274 {
1275         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1276         if (new) {
1277                 size_t afdatalen = new->afdatalen;
1278                 memcpy(new, fr, sizeof(*new));
1279                 iax_frame_wrap(new, &fr->af);
1280                 new->afdatalen = afdatalen;
1281                 new->data = NULL;
1282                 new->datalen = 0;
1283                 new->direction = DIRECTION_INGRESS;
1284                 new->retrans = -1;
1285         }
1286         return new;
1287 }
1288
1289 #define NEW_PREVENT     0
1290 #define NEW_ALLOW       1
1291 #define NEW_FORCE       2
1292
1293 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1294 {
1295         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1296                 (cur->addr.sin_port == sin->sin_port)) {
1297                 /* This is the main host */
1298                 if ((cur->peercallno == callno) ||
1299                         ((dcallno == cur->callno) && !cur->peercallno)) {
1300                         /* That's us.  Be sure we keep track of the peer call number */
1301                         return 1;
1302                 }
1303         }
1304         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1305             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1306                 /* We're transferring */
1307                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1308                         return 1;
1309         }
1310         return 0;
1311 }
1312
1313 static void update_max_trunk(void)
1314 {
1315         int max = TRUNK_CALL_START;
1316         int x;
1317         /* XXX Prolly don't need locks here XXX */
1318         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1319                 if (iaxs[x])
1320                         max = x + 1;
1321         }
1322         maxtrunkcall = max;
1323         if (iaxdebug)
1324                 ast_debug(1, "New max trunk callno is %d\n", max);
1325 }
1326
1327 static void update_max_nontrunk(void)
1328 {
1329         int max = 1;
1330         int x;
1331         /* XXX Prolly don't need locks here XXX */
1332         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1333                 if (iaxs[x])
1334                         max = x + 1;
1335         }
1336         maxnontrunkcall = max;
1337         if (iaxdebug)
1338                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1339 }
1340
1341 static int make_trunk(unsigned short callno, int locked)
1342 {
1343         int x;
1344         int res= 0;
1345         struct timeval now = ast_tvnow();
1346         if (iaxs[callno]->oseqno) {
1347                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1348                 return -1;
1349         }
1350         if (callno & TRUNK_CALL_START) {
1351                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1352                 return -1;
1353         }
1354         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1355                 ast_mutex_lock(&iaxsl[x]);
1356                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1357                         iaxs[x] = iaxs[callno];
1358                         iaxs[x]->callno = x;
1359                         iaxs[callno] = NULL;
1360                         /* Update the two timers that should have been started */
1361                         if (iaxs[x]->pingid > -1)
1362                                 ast_sched_del(sched, iaxs[x]->pingid);
1363                         if (iaxs[x]->lagid > -1)
1364                                 ast_sched_del(sched, iaxs[x]->lagid);
1365                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1366                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1367                         if (locked)
1368                                 ast_mutex_unlock(&iaxsl[callno]);
1369                         res = x;
1370                         if (!locked)
1371                                 ast_mutex_unlock(&iaxsl[x]);
1372                         break;
1373                 }
1374                 ast_mutex_unlock(&iaxsl[x]);
1375         }
1376         if (x >= IAX_MAX_CALLS - 1) {
1377                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1378                 return -1;
1379         }
1380         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1381         /* We move this call from a non-trunked to a trunked call */
1382         update_max_trunk();
1383         update_max_nontrunk();
1384         return res;
1385 }
1386
1387 /*!
1388  * \todo XXX Note that this function contains a very expensive operation that
1389  * happens for *every* incoming media frame.  It iterates through every
1390  * possible call number, locking and unlocking each one, to try to match the
1391  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1392  * So, for an call with a local call number of 20000, every incoming audio
1393  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1394  *
1395  * It's a shame that IAX2 media frames carry the source call number instead of
1396  * the destination call number.  If they did, this lookup wouldn't be needed.
1397  * However, it's too late to change that now.  Instead, we need to come up with
1398  * a better way of indexing active calls so that these frequent lookups are not
1399  * so expensive.
1400  */
1401 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1402 {
1403         int res = 0;
1404         int x;
1405         struct timeval now;
1406         char host[80];
1407
1408         if (new <= NEW_ALLOW) {
1409                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1410                         ast_mutex_lock(&iaxsl[x]);
1411                         if (iaxs[x]) {
1412                                 /* Look for an exact match */
1413                                 if (match(sin, callno, dcallno, iaxs[x])) {
1414                                         res = x;
1415                                 }
1416                         }
1417                         ast_mutex_unlock(&iaxsl[x]);
1418                 }
1419                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1420                         ast_mutex_lock(&iaxsl[x]);
1421                         if (iaxs[x]) {
1422                                 /* Look for an exact match */
1423                                 if (match(sin, callno, dcallno, iaxs[x])) {
1424                                         res = x;
1425                                 }
1426                         }
1427                         ast_mutex_unlock(&iaxsl[x]);
1428                 }
1429         }
1430         if ((res < 1) && (new >= NEW_ALLOW)) {
1431                 /* It may seem odd that we look through the peer list for a name for
1432                  * this *incoming* call.  Well, it is weird.  However, users don't
1433                  * have an IP address/port number that we can match against.  So,
1434                  * this is just checking for a peer that has that IP/port and
1435                  * assuming that we have a user of the same name.  This isn't always
1436                  * correct, but it will be changed if needed after authentication. */
1437                 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1438                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1439                 now = ast_tvnow();
1440                 for (x=1;x<TRUNK_CALL_START;x++) {
1441                         /* Find first unused call number that hasn't been used in a while */
1442                         ast_mutex_lock(&iaxsl[x]);
1443                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1444                         ast_mutex_unlock(&iaxsl[x]);
1445                 }
1446                 /* We've still got lock held if we found a spot */
1447                 if (x >= TRUNK_CALL_START) {
1448                         ast_log(LOG_WARNING, "No more space\n");
1449                         return 0;
1450                 }
1451                 iaxs[x] = new_iax(sin, lockpeer, host);
1452                 update_max_nontrunk();
1453                 if (iaxs[x]) {
1454                         if (iaxdebug)
1455                                 ast_debug(1, "Creating new call structure %d\n", x);
1456                         iaxs[x]->sockfd = sockfd;
1457                         iaxs[x]->addr.sin_port = sin->sin_port;
1458                         iaxs[x]->addr.sin_family = sin->sin_family;
1459                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1460                         iaxs[x]->peercallno = callno;
1461                         iaxs[x]->callno = x;
1462                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1463                         iaxs[x]->expiry = min_reg_expire;
1464                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1465                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1466                         iaxs[x]->amaflags = amaflags;
1467                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1468                         
1469                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1470                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1471                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1472                 } else {
1473                         ast_log(LOG_WARNING, "Out of resources\n");
1474                         ast_mutex_unlock(&iaxsl[x]);
1475                         return 0;
1476                 }
1477                 ast_mutex_unlock(&iaxsl[x]);
1478                 res = x;
1479         }
1480         return res;
1481 }
1482
1483 static void iax2_frame_free(struct iax_frame *fr)
1484 {
1485         if (fr->retrans > -1)
1486                 ast_sched_del(sched, fr->retrans);
1487         iax_frame_free(fr);
1488 }
1489
1490 /*!
1491  * \brief Queue a frame to a call's owning asterisk channel
1492  *
1493  * \note This function assumes that iaxsl[callno] is locked when called.
1494  *
1495  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1496  * was valid before calling it, it may no longer be valid after calling it.
1497  * This function may unlock and lock the mutex associated with this callno,
1498  * meaning that another thread may grab it and destroy the call.
1499  */
1500 static int iax2_queue_frame(int callno, struct ast_frame *f)
1501 {
1502         /* Assumes lock for callno is already held... */
1503         for (;;) {
1504                 if (iaxs[callno] && iaxs[callno]->owner) {
1505                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1506                                 /* Avoid deadlock by pausing and trying again */
1507                                 ast_mutex_unlock(&iaxsl[callno]);
1508                                 usleep(1);
1509                                 ast_mutex_lock(&iaxsl[callno]);
1510                         } else {
1511                                 ast_queue_frame(iaxs[callno]->owner, f);
1512                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1513                                 break;
1514                         }
1515                 } else
1516                         break;
1517         }
1518         return 0;
1519 }
1520
1521 static void destroy_firmware(struct iax_firmware *cur)
1522 {
1523         /* Close firmware */
1524         if (cur->fwh) {
1525                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1526         }
1527         close(cur->fd);
1528         ast_free(cur);
1529 }
1530
1531 static int try_firmware(char *s)
1532 {
1533         struct stat stbuf;
1534         struct iax_firmware *cur = NULL;
1535         int ifd, fd, res, len, chunk;
1536         struct ast_iax2_firmware_header *fwh, fwh2;
1537         struct MD5Context md5;
1538         unsigned char sum[16], buf[1024];
1539         char *s2, *last;
1540
1541         if (!(s2 = alloca(strlen(s) + 100))) {
1542                 ast_log(LOG_WARNING, "Alloca failed!\n");
1543                 return -1;
1544         }
1545
1546         last = strrchr(s, '/');
1547         if (last)
1548                 last++;
1549         else
1550                 last = s;
1551
1552         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1553
1554         if ((res = stat(s, &stbuf) < 0)) {
1555                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1556                 return -1;
1557         }
1558
1559         /* Make sure it's not a directory */
1560         if (S_ISDIR(stbuf.st_mode))
1561                 return -1;
1562         ifd = open(s, O_RDONLY);
1563         if (ifd < 0) {
1564                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1565                 return -1;
1566         }
1567         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1568         if (fd < 0) {
1569                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1570                 close(ifd);
1571                 return -1;
1572         }
1573         /* Unlink our newly created file */
1574         unlink(s2);
1575         
1576         /* Now copy the firmware into it */
1577         len = stbuf.st_size;
1578         while(len) {
1579                 chunk = len;
1580                 if (chunk > sizeof(buf))
1581                         chunk = sizeof(buf);
1582                 res = read(ifd, buf, chunk);
1583                 if (res != chunk) {
1584                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1585                         close(ifd);
1586                         close(fd);
1587                         return -1;
1588                 }
1589                 res = write(fd, buf, chunk);
1590                 if (res != chunk) {
1591                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1592                         close(ifd);
1593                         close(fd);
1594                         return -1;
1595                 }
1596                 len -= chunk;
1597         }
1598         close(ifd);
1599         /* Return to the beginning */
1600         lseek(fd, 0, SEEK_SET);
1601         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1602                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1603                 close(fd);
1604                 return -1;
1605         }
1606         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1607                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1608                 close(fd);
1609                 return -1;
1610         }
1611         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1612                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1613                 close(fd);
1614                 return -1;
1615         }
1616         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1617                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1618                 close(fd);
1619                 return -1;
1620         }
1621         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1622         if (fwh == (void *) -1) {
1623                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1624                 close(fd);
1625                 return -1;
1626         }
1627         MD5Init(&md5);
1628         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1629         MD5Final(sum, &md5);
1630         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1631                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1632                 munmap((void*)fwh, stbuf.st_size);
1633                 close(fd);
1634                 return -1;
1635         }
1636
1637         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1638                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1639                         /* Found a candidate */
1640                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1641                                 /* The version we have on loaded is older, load this one instead */
1642                                 break;
1643                         /* This version is no newer than what we have.  Don't worry about it.
1644                            We'll consider it a proper load anyhow though */
1645                         munmap((void*)fwh, stbuf.st_size);
1646                         close(fd);
1647                         return 0;
1648                 }
1649         }
1650         
1651         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1652                 cur->fd = -1;
1653                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1654         }
1655         
1656         if (cur) {
1657                 if (cur->fwh)
1658                         munmap((void*)cur->fwh, cur->mmaplen);
1659                 if (cur->fd > -1)
1660                         close(cur->fd);
1661                 cur->fwh = fwh;
1662                 cur->fd = fd;
1663                 cur->mmaplen = stbuf.st_size;
1664                 cur->dead = 0;
1665         }
1666         
1667         return 0;
1668 }
1669
1670 static int iax_check_version(char *dev)
1671 {
1672         int res = 0;
1673         struct iax_firmware *cur = NULL;
1674
1675         if (ast_strlen_zero(dev))
1676                 return 0;
1677
1678         AST_LIST_LOCK(&firmwares);
1679         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1680                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1681                         res = ntohs(cur->fwh->version);
1682                         break;
1683                 }
1684         }
1685         AST_LIST_UNLOCK(&firmwares);
1686
1687         return res;
1688 }
1689
1690 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1691 {
1692         int res = -1;
1693         unsigned int bs = desc & 0xff;
1694         unsigned int start = (desc >> 8) & 0xffffff;
1695         unsigned int bytes;
1696         struct iax_firmware *cur;
1697
1698         if (ast_strlen_zero((char *)dev) || !bs)
1699                 return -1;
1700
1701         start *= bs;
1702         
1703         AST_LIST_LOCK(&firmwares);
1704         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1705                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1706                         continue;
1707                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1708                 if (start < ntohl(cur->fwh->datalen)) {
1709                         bytes = ntohl(cur->fwh->datalen) - start;
1710                         if (bytes > bs)
1711                                 bytes = bs;
1712                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1713                 } else {
1714                         bytes = 0;
1715                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1716                 }
1717                 if (bytes == bs)
1718                         res = 0;
1719                 else
1720                         res = 1;
1721                 break;
1722         }
1723         AST_LIST_UNLOCK(&firmwares);
1724
1725         return res;
1726 }
1727
1728
1729 static void reload_firmware(void)
1730 {
1731         struct iax_firmware *cur = NULL;
1732         DIR *fwd;
1733         struct dirent *de;
1734         char dir[256], fn[256];
1735
1736         AST_LIST_LOCK(&firmwares);
1737
1738         /* Mark all as dead */
1739         AST_LIST_TRAVERSE(&firmwares, cur, list)
1740                 cur->dead = 1;
1741
1742         /* Now that we have marked them dead... load new ones */
1743         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1744         fwd = opendir(dir);
1745         if (fwd) {
1746                 while((de = readdir(fwd))) {
1747                         if (de->d_name[0] != '.') {
1748                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1749                                 if (!try_firmware(fn)) {
1750                                         ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
1751                                 }
1752                         }
1753                 }
1754                 closedir(fwd);
1755         } else 
1756                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1757
1758         /* Clean up leftovers */
1759         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1760                 if (!cur->dead)
1761                         continue;
1762                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1763                 destroy_firmware(cur);
1764         }
1765         AST_LIST_TRAVERSE_SAFE_END
1766
1767         AST_LIST_UNLOCK(&firmwares);
1768 }
1769
1770 /*!
1771  * \note This function assumes that iaxsl[callno] is locked when called.
1772  *
1773  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1774  * was valid before calling it, it may no longer be valid after calling it.
1775  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
1776  * associated with this callno, meaning that another thread may grab it and destroy the call.
1777  */
1778 static int __do_deliver(void *data)
1779 {
1780         /* Just deliver the packet by using queueing.  This is called by
1781           the IAX thread with the iaxsl lock held. */
1782         struct iax_frame *fr = data;
1783         fr->retrans = -1;
1784         fr->af.has_timing_info = 0;
1785         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1786                 iax2_queue_frame(fr->callno, &fr->af);
1787         /* Free our iax frame */
1788         iax2_frame_free(fr);
1789         /* And don't run again */
1790         return 0;
1791 }
1792
1793 static int handle_error(void)
1794 {
1795         /* XXX Ideally we should figure out why an error occurred and then abort those
1796            rather than continuing to try.  Unfortunately, the published interface does
1797            not seem to work XXX */
1798 #if 0
1799         struct sockaddr_in *sin;
1800         int res;
1801         struct msghdr m;
1802         struct sock_extended_err e;
1803         m.msg_name = NULL;
1804         m.msg_namelen = 0;
1805         m.msg_iov = NULL;
1806         m.msg_control = &e;
1807         m.msg_controllen = sizeof(e);
1808         m.msg_flags = 0;
1809         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1810         if (res < 0)
1811                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1812         else {
1813                 if (m.msg_controllen) {
1814                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1815                         if (sin) 
1816                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1817                         else
1818                                 ast_log(LOG_WARNING, "No address detected??\n");
1819                 } else {
1820                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1821                 }
1822         }
1823 #endif
1824         return 0;
1825 }
1826
1827 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1828 {
1829         int res;
1830         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1831                                         sizeof(*sin));
1832         if (res < 0) {
1833                 ast_debug(1, "Received error: %s\n", strerror(errno));
1834                 handle_error();
1835         } else
1836                 res = 0;
1837         return res;
1838 }
1839
1840 static int send_packet(struct iax_frame *f)
1841 {
1842         int res;
1843         int callno = f->callno;
1844
1845         /* Don't send if there was an error, but return error instead */
1846         if (!callno || !iaxs[callno] || iaxs[callno]->error)
1847             return -1;
1848         
1849         /* Called with iaxsl held */
1850         if (iaxdebug)
1851                 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));
1852         if (f->transfer) {
1853                 if (iaxdebug)
1854                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1855                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1856                                         sizeof(iaxs[callno]->transfer));
1857         } else {
1858                 if (iaxdebug)
1859                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1860                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1861                                         sizeof(iaxs[callno]->addr));
1862         }
1863         if (res < 0) {
1864                 if (iaxdebug)
1865                         ast_debug(1, "Received error: %s\n", strerror(errno));
1866                 handle_error();
1867         } else
1868                 res = 0;
1869         return res;
1870 }
1871
1872 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1873 {
1874         struct iax2_user *user = NULL;
1875
1876         /* Decrement AUTHREQ count if needed */
1877         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1878                 AST_LIST_LOCK(&users);
1879                 AST_LIST_TRAVERSE(&users, user, entry) {
1880                         if (!strcmp(user->name, pvt->username)) {
1881                                 user->curauthreq--;
1882                                 break;
1883                         }
1884                 }
1885                 AST_LIST_UNLOCK(&users);
1886                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1887         }
1888         /* No more pings or lagrq's */
1889         if (pvt->pingid > -1)
1890                 ast_sched_del(sched, pvt->pingid);
1891         pvt->pingid = -1;
1892         if (pvt->lagid > -1)
1893                 ast_sched_del(sched, pvt->lagid);
1894         pvt->lagid = -1;
1895         if (pvt->autoid > -1)
1896                 ast_sched_del(sched, pvt->autoid);
1897         pvt->autoid = -1;
1898         if (pvt->authid > -1)
1899                 ast_sched_del(sched, pvt->authid);
1900         pvt->authid = -1;
1901         if (pvt->initid > -1)
1902                 ast_sched_del(sched, pvt->initid);
1903         pvt->initid = -1;
1904         if (pvt->jbid > -1)
1905                 ast_sched_del(sched, pvt->jbid);
1906         pvt->jbid = -1;
1907 }
1908
1909 static int iax2_predestroy(int callno)
1910 {
1911         struct ast_channel *c = NULL;
1912         struct chan_iax2_pvt *pvt = iaxs[callno];
1913
1914         if (!pvt)
1915                 return -1;
1916
1917         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1918                 iax2_destroy_helper(pvt);
1919                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1920         }
1921
1922         if ((c = pvt->owner)) {
1923                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1924                 c->tech_pvt = NULL;
1925                 ast_queue_hangup(c);
1926                 pvt->owner = NULL;
1927                 ast_module_unref(ast_module_info->self);
1928         }
1929
1930         return 0;
1931 }
1932
1933 static void iax2_destroy(int callno)
1934 {
1935         struct chan_iax2_pvt *pvt = NULL;
1936         struct iax_frame *cur = NULL;
1937         struct ast_channel *owner = NULL;
1938
1939 retry:
1940         pvt = iaxs[callno];
1941         lastused[callno] = ast_tvnow();
1942         
1943         owner = pvt ? pvt->owner : NULL;
1944
1945         if (owner) {
1946                 if (ast_mutex_trylock(&owner->lock)) {
1947                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1948                         ast_mutex_unlock(&iaxsl[callno]);
1949                         usleep(1);
1950                         ast_mutex_lock(&iaxsl[callno]);
1951                         goto retry;
1952                 }
1953         }
1954         if (!owner)
1955                 iaxs[callno] = NULL;
1956         if (pvt) {
1957                 if (!owner)
1958                         pvt->owner = NULL;
1959                 iax2_destroy_helper(pvt);
1960
1961                 /* Already gone */
1962                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1963
1964                 if (owner) {
1965                         /* If there's an owner, prod it to give up */
1966                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1967                         ast_queue_hangup(owner);
1968                 }
1969
1970                 AST_LIST_LOCK(&frame_queue);
1971                 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
1972                         /* Cancel any pending transmissions */
1973                         if (cur->callno == pvt->callno) 
1974                                 cur->retries = -1;
1975                 }
1976                 AST_LIST_UNLOCK(&frame_queue);
1977
1978                 if (pvt->reg)
1979                         pvt->reg->callno = 0;
1980                 if (!owner) {
1981                         jb_frame frame;
1982                         if (pvt->vars) {
1983                             ast_variables_destroy(pvt->vars);
1984                             pvt->vars = NULL;
1985                         }
1986
1987                         while (jb_getall(pvt->jb, &frame) == JB_OK)
1988                                 iax2_frame_free(frame.data);
1989                         jb_destroy(pvt->jb);
1990                         /* gotta free up the stringfields */
1991                         ast_string_field_free_pools(pvt);
1992                         ast_free(pvt);
1993                 }
1994         }
1995         if (owner) {
1996                 ast_mutex_unlock(&owner->lock);
1997         }
1998         if (callno & 0x4000)
1999                 update_max_trunk();
2000 }
2001
2002 static int update_packet(struct iax_frame *f)
2003 {
2004         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2005         struct ast_iax2_full_hdr *fh = f->data;
2006         /* Mark this as a retransmission */
2007         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2008         /* Update iseqno */
2009         f->iseqno = iaxs[f->callno]->iseqno;
2010         fh->iseqno = f->iseqno;
2011         return 0;
2012 }
2013
2014 static int attempt_transmit(void *data);
2015 static void __attempt_transmit(void *data)
2016 {
2017         /* Attempt to transmit the frame to the remote peer...
2018            Called without iaxsl held. */
2019         struct iax_frame *f = data;
2020         int freeme = 0;
2021         int callno = f->callno;
2022         /* Make sure this call is still active */
2023         if (callno) 
2024                 ast_mutex_lock(&iaxsl[callno]);
2025         if (callno && iaxs[callno]) {
2026                 if ((f->retries < 0) /* Already ACK'd */ ||
2027                     (f->retries >= max_retries) /* Too many attempts */) {
2028                                 /* Record an error if we've transmitted too many times */
2029                                 if (f->retries >= max_retries) {
2030                                         if (f->transfer) {
2031                                                 /* Transfer timeout */
2032                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
2033                                         } else if (f->final) {
2034                                                 if (f->final) 
2035                                                         iax2_destroy(callno);
2036                                         } else {
2037                                                 if (iaxs[callno]->owner)
2038                                                         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);
2039                                                 iaxs[callno]->error = ETIMEDOUT;
2040                                                 if (iaxs[callno]->owner) {
2041                                                         struct ast_frame fr = { 0, };
2042                                                         /* Hangup the fd */
2043                                                         fr.frametype = AST_FRAME_CONTROL;
2044                                                         fr.subclass = AST_CONTROL_HANGUP;
2045                                                         iax2_queue_frame(callno, &fr); // XXX
2046                                                         /* Remember, owner could disappear */
2047                                                         if (iaxs[callno] && iaxs[callno]->owner)
2048                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2049                                                 } else {
2050                                                         if (iaxs[callno]->reg) {
2051                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2052                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2053                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2054                                                         }
2055                                                         iax2_destroy(callno);
2056                                                 }
2057                                         }
2058
2059                                 }
2060                                 freeme = 1;
2061                 } else {
2062                         /* Update it if it needs it */
2063                         update_packet(f);
2064                         /* Attempt transmission */
2065                         send_packet(f);
2066                         f->retries++;
2067                         /* Try again later after 10 times as long */
2068                         f->retrytime *= 10;
2069                         if (f->retrytime > MAX_RETRY_TIME)
2070                                 f->retrytime = MAX_RETRY_TIME;
2071                         /* Transfer messages max out at one second */
2072                         if (f->transfer && (f->retrytime > 1000))
2073                                 f->retrytime = 1000;
2074                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
2075                 }
2076         } else {
2077                 /* Make sure it gets freed */
2078                 f->retries = -1;
2079                 freeme = 1;
2080         }
2081         if (callno)
2082                 ast_mutex_unlock(&iaxsl[callno]);
2083         /* Do not try again */
2084         if (freeme) {
2085                 /* Don't attempt delivery, just remove it from the queue */
2086                 AST_LIST_LOCK(&frame_queue);
2087                 AST_LIST_REMOVE(&frame_queue, f, list);
2088                 AST_LIST_UNLOCK(&frame_queue);
2089                 f->retrans = -1;
2090                 /* Free the IAX frame */
2091                 iax2_frame_free(f);
2092         }
2093 }
2094
2095 static int attempt_transmit(void *data)
2096 {
2097 #ifdef SCHED_MULTITHREADED
2098         if (schedule_action(__attempt_transmit, data))
2099 #endif          
2100                 __attempt_transmit(data);
2101         return 0;
2102 }
2103
2104 static int iax2_prune_realtime(int fd, int argc, char *argv[])
2105 {
2106         struct iax2_peer *peer;
2107
2108         if (argc != 4)
2109         return RESULT_SHOWUSAGE;
2110         if (!strcmp(argv[3],"all")) {
2111                 reload_config();
2112                 ast_cli(fd, "OK cache is flushed.\n");
2113         } else if ((peer = find_peer(argv[3], 0))) {
2114                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2115                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2116                         expire_registry((void *)peer->name);
2117                         ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
2118                 } else {
2119                         ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
2120                 }
2121         } else {
2122                 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
2123         }
2124         
2125         return RESULT_SUCCESS;
2126 }
2127
2128 static int iax2_test_losspct(int fd, int argc, char *argv[])
2129 {
2130        if (argc != 4)
2131                return RESULT_SHOWUSAGE;
2132
2133        test_losspct = atoi(argv[3]);
2134
2135        return RESULT_SUCCESS;
2136 }
2137
2138 #ifdef IAXTESTS
2139 static int iax2_test_late(int fd, int argc, char *argv[])
2140 {
2141         if (argc != 4)
2142                 return RESULT_SHOWUSAGE;
2143
2144         test_late = atoi(argv[3]);
2145
2146         return RESULT_SUCCESS;
2147 }
2148
2149 static int iax2_test_resync(int fd, int argc, char *argv[])
2150 {
2151         if (argc != 4)
2152                 return RESULT_SHOWUSAGE;
2153
2154         test_resync = atoi(argv[3]);
2155
2156         return RESULT_SUCCESS;
2157 }
2158
2159 static int iax2_test_jitter(int fd, int argc, char *argv[])
2160 {
2161         if (argc < 4 || argc > 5)
2162                 return RESULT_SHOWUSAGE;
2163
2164         test_jit = atoi(argv[3]);
2165         if (argc == 5) 
2166                 test_jitpct = atoi(argv[4]);
2167
2168         return RESULT_SUCCESS;
2169 }
2170 #endif /* IAXTESTS */
2171
2172 /*! \brief  peer_status: Report Peer status in character string */
2173 /*      returns 1 if peer is online, -1 if unmonitored */
2174 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2175 {
2176         int res = 0;
2177         if (peer->maxms) {
2178                 if (peer->lastms < 0) {
2179                         ast_copy_string(status, "UNREACHABLE", statuslen);
2180                 } else if (peer->lastms > peer->maxms) {
2181                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2182                         res = 1;
2183                 } else if (peer->lastms) {
2184                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2185                         res = 1;
2186                 } else {
2187                         ast_copy_string(status, "UNKNOWN", statuslen);
2188                 }
2189         } else { 
2190                 ast_copy_string(status, "Unmonitored", statuslen);
2191                 res = -1;
2192         }
2193         return res;
2194 }
2195
2196 /*! \brief Show one peer in detail */
2197 static int iax2_show_peer(int fd, int argc, char *argv[])
2198 {
2199         char status[30];
2200         char cbuf[256];
2201         struct iax2_peer *peer;
2202         char codec_buf[512];
2203         int x = 0, codec = 0, load_realtime = 0;
2204
2205         if (argc < 4)
2206                 return RESULT_SHOWUSAGE;
2207
2208         load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2209
2210         peer = find_peer(argv[3], load_realtime);
2211         if (peer) {
2212                 ast_cli(fd,"\n\n");
2213                 ast_cli(fd, "  * Name       : %s\n", peer->name);
2214                 ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2215                 ast_cli(fd, "  Context      : %s\n", peer->context);
2216                 ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
2217                 ast_cli(fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2218                 ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2219                 ast_cli(fd, "  Expire       : %d\n", peer->expire);
2220                 ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
2221                 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));
2222                 ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2223                 ast_cli(fd, "  Username     : %s\n", peer->username);
2224                 ast_cli(fd, "  Codecs       : ");
2225                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2226                 ast_cli(fd, "%s\n", codec_buf);
2227
2228                 ast_cli(fd, "  Codec Order  : (");
2229                 for(x = 0; x < 32 ; x++) {
2230                         codec = ast_codec_pref_index(&peer->prefs,x);
2231                         if(!codec)
2232                                 break;
2233                         ast_cli(fd, "%s", ast_getformatname(codec));
2234                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2235                                 ast_cli(fd, "|");
2236                 }
2237
2238                 if (!x)
2239                         ast_cli(fd, "none");
2240                 ast_cli(fd, ")\n");
2241
2242                 ast_cli(fd, "  Status       : ");
2243                 peer_status(peer, status, sizeof(status));      
2244                 ast_cli(fd, "%s\n",status);
2245                 ast_cli(fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2246                 ast_cli(fd,"\n");
2247                 if (ast_test_flag(peer, IAX_TEMPONLY))
2248                         destroy_peer(peer);
2249         } else {
2250                 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2251                 ast_cli(fd,"\n");
2252         }
2253
2254         return RESULT_SUCCESS;
2255 }
2256
2257 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2258 {
2259         int which = 0;
2260         struct iax2_peer *p = NULL;
2261         char *res = NULL;
2262         int wordlen = strlen(word);
2263
2264         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2265         if (pos == 3) {
2266                 AST_LIST_LOCK(&peers);
2267                 AST_LIST_TRAVERSE(&peers, p, entry) {
2268                         if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2269                                 res = ast_strdup(p->name);
2270                                 break;
2271                         }
2272                 }
2273                 AST_LIST_UNLOCK(&peers);
2274         }
2275
2276         return res;
2277 }
2278
2279 static int iax2_show_stats(int fd, int argc, char *argv[])
2280 {
2281         struct iax_frame *cur;
2282         int cnt = 0, dead=0, final=0;
2283
2284         if (argc != 3)
2285                 return RESULT_SHOWUSAGE;
2286
2287         AST_LIST_LOCK(&frame_queue);
2288         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2289                 if (cur->retries < 0)
2290                         dead++;
2291                 if (cur->final)
2292                         final++;
2293                 cnt++;
2294         }
2295         AST_LIST_UNLOCK(&frame_queue);
2296
2297         ast_cli(fd, "    IAX Statistics\n");
2298         ast_cli(fd, "---------------------\n");
2299         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2300         ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2301                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2302
2303         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2304
2305         trunk_timed = trunk_untimed = 0;
2306         if (trunk_maxmtu > trunk_nmaxmtu)
2307                 trunk_nmaxmtu = trunk_maxmtu;
2308         
2309         return RESULT_SUCCESS;
2310 }
2311
2312 /*! \brief Set trunk MTU from CLI */
2313 static int iax2_set_mtu(int fd, int argc, char *argv[])
2314 {
2315         int mtuv;
2316
2317         if (argc != 4)
2318                 return RESULT_SHOWUSAGE; 
2319         if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0) 
2320                 mtuv = MAX_TRUNK_MTU; 
2321         else                                         
2322                 mtuv = atoi(argv[3]); 
2323
2324         if (mtuv == 0) {
2325                 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2326                 global_max_trunk_mtu = 0; 
2327                 return RESULT_SUCCESS; 
2328         }
2329         if (mtuv < 172 || mtuv > 4000) {
2330                 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n"); 
2331                 return RESULT_SHOWUSAGE; 
2332         }
2333         ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2334         global_max_trunk_mtu = mtuv; 
2335         return RESULT_SUCCESS;
2336 }
2337
2338 static int iax2_show_cache(int fd, int argc, char *argv[])
2339 {
2340         struct iax2_dpcache *dp = NULL;
2341         char tmp[1024], *pc = NULL;
2342         int s, x, y;
2343         struct timeval tv = ast_tvnow();
2344
2345         AST_LIST_LOCK(&dpcache);
2346
2347         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2348
2349         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2350                 s = dp->expiry.tv_sec - tv.tv_sec;
2351                 tmp[0] = '\0';
2352                 if (dp->flags & CACHE_FLAG_EXISTS)
2353                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2354                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2355                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2356                 if (dp->flags & CACHE_FLAG_CANEXIST)
2357                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2358                 if (dp->flags & CACHE_FLAG_PENDING)
2359                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2360                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2361                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2362                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2363                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2364                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2365                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2366                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2367                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2368                 /* Trim trailing pipe */
2369                 if (!ast_strlen_zero(tmp))
2370                         tmp[strlen(tmp) - 1] = '\0';
2371                 else
2372                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2373                 y=0;
2374                 pc = strchr(dp->peercontext, '@');
2375                 if (!pc)
2376                         pc = dp->peercontext;
2377                 else
2378                         pc++;
2379                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2380                         if (dp->waiters[x] > -1)
2381                                 y++;
2382                 if (s > 0)
2383                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2384                 else
2385                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2386         }
2387
2388         AST_LIST_LOCK(&dpcache);
2389
2390         return RESULT_SUCCESS;
2391 }
2392
2393 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2394
2395 static void unwrap_timestamp(struct iax_frame *fr)
2396 {
2397         int x;
2398
2399         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2400                 x = fr->ts - iaxs[fr->callno]->last;
2401                 if (x < -50000) {
2402                         /* Sudden big jump backwards in timestamp:
2403                            What likely happened here is that miniframe timestamp has circled but we haven't
2404                            gotten the update from the main packet.  We'll just pretend that we did, and
2405                            update the timestamp appropriately. */
2406                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2407                         if (iaxdebug)
2408                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2409                 }
2410                 if (x > 50000) {
2411                         /* Sudden apparent big jump forwards in timestamp:
2412                            What's likely happened is this is an old miniframe belonging to the previous
2413                            top-16-bit timestamp that has turned up out of order.
2414                            Adjust the timestamp appropriately. */
2415                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2416                         if (iaxdebug)
2417                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2418                 }
2419         }
2420 }
2421
2422 static int get_from_jb(void *p);
2423
2424 static void update_jbsched(struct chan_iax2_pvt *pvt)
2425 {
2426         int when;
2427         
2428         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2429         
2430         when = jb_next(pvt->jb) - when;
2431         
2432         if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2433         
2434         if(when <= 0) {
2435                 /* XXX should really just empty until when > 0.. */
2436                 when = 1;
2437         }
2438         
2439         pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2440         
2441         /* Signal scheduler thread */
2442         signal_condition(&sched_lock, &sched_cond);
2443 }
2444
2445 static void __get_from_jb(void *p) 
2446 {
2447         int callno = PTR_TO_CALLNO(p);
2448         struct chan_iax2_pvt *pvt = NULL;
2449         struct iax_frame *fr;
2450         jb_frame frame;
2451         int ret;
2452         long now;
2453         long next;
2454         struct timeval tv = ast_tvnow();
2455         
2456         /* Make sure we have a valid private structure before going on */
2457         ast_mutex_lock(&iaxsl[callno]);
2458         pvt = iaxs[callno];
2459         if (!pvt) {
2460                 /* No go! */
2461                 ast_mutex_unlock(&iaxsl[callno]);
2462                 return;
2463         }
2464
2465         pvt->jbid = -1;
2466         
2467         /* round up a millisecond since ast_sched_runq does; */
2468         /* prevents us from spinning while waiting for our now */
2469         /* to catch up with runq's now */
2470         tv.tv_usec += 1000;
2471         
2472         now = ast_tvdiff_ms(tv, pvt->rxcore);
2473         
2474         if(now >= (next = jb_next(pvt->jb))) {
2475                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2476                 switch(ret) {
2477                 case JB_OK:
2478                         fr = frame.data;
2479                         __do_deliver(fr);
2480                         /* __do_deliver() can cause the call to disappear */
2481                         pvt = iaxs[callno];
2482                         break;
2483                 case JB_INTERP:
2484                 {
2485                         struct ast_frame af = { 0, };
2486                         
2487                         /* create an interpolation frame */
2488                         af.frametype = AST_FRAME_VOICE;
2489                         af.subclass = pvt->voiceformat;
2490                         af.samples  = frame.ms * 8;
2491                         af.src  = "IAX2 JB interpolation";
2492                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2493                         af.offset = AST_FRIENDLY_OFFSET;
2494                         
2495                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2496                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2497                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2498                                 iax2_queue_frame(callno, &af);
2499                                 /* iax2_queue_frame() could cause the call to disappear */
2500                                 pvt = iaxs[callno];
2501                         }
2502                 }
2503                         break;
2504                 case JB_DROP:
2505                         iax2_frame_free(frame.data);
2506                         break;
2507                 case JB_NOFRAME:
2508                 case JB_EMPTY:
2509                         /* do nothing */
2510                         break;
2511                 default:
2512                         /* shouldn't happen */
2513                         break;
2514                 }
2515         }
2516         if (pvt)
2517                 update_jbsched(pvt);
2518         ast_mutex_unlock(&iaxsl[callno]);
2519 }
2520
2521 static int get_from_jb(void *data)
2522 {
2523 #ifdef SCHED_MULTITHREADED
2524         if (schedule_action(__get_from_jb, data))
2525 #endif          
2526                 __get_from_jb(data);
2527         return 0;
2528 }
2529
2530 /*!
2531  * \note This function assumes fr->callno is locked
2532  *
2533  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2534  * was valid before calling it, it may no longer be valid after calling it.
2535  */
2536 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2537 {
2538         int type, len;
2539         int ret;
2540         int needfree = 0;
2541
2542         /* Attempt to recover wrapped timestamps */
2543         unwrap_timestamp(fr);
2544
2545         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2546         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2547                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2548         else {
2549 #if 0
2550                 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2551 #endif
2552                 fr->af.delivery = ast_tv(0,0);
2553         }
2554
2555         type = JB_TYPE_CONTROL;
2556         len = 0;
2557
2558         if(fr->af.frametype == AST_FRAME_VOICE) {
2559                 type = JB_TYPE_VOICE;
2560                 len = ast_codec_get_samples(&fr->af) / 8;
2561         } else if(fr->af.frametype == AST_FRAME_CNG) {
2562                 type = JB_TYPE_SILENCE;
2563         }
2564
2565         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2566                 if (tsout)
2567                         *tsout = fr->ts;
2568                 __do_deliver(fr);
2569                 return -1;
2570         }
2571
2572         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2573          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2574         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2575             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2576             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2577                 jb_frame frame;
2578
2579                 /* deliver any frames in the jb */
2580                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2581                         __do_deliver(frame.data);
2582                         /* __do_deliver() can make the call disappear */
2583                         if (!iaxs[fr->callno])
2584                                 return -1;
2585                 }
2586
2587                 jb_reset(iaxs[fr->callno]->jb);
2588
2589                 if (iaxs[fr->callno]->jbid > -1)
2590                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2591
2592                 iaxs[fr->callno]->jbid = -1;
2593
2594                 /* deliver this frame now */
2595                 if (tsout)
2596                         *tsout = fr->ts;
2597                 __do_deliver(fr);
2598                 return -1;
2599         }
2600
2601         /* insert into jitterbuffer */
2602         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2603         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2604                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2605         if (ret == JB_DROP) {
2606                 needfree++;
2607         } else if (ret == JB_SCHED) {
2608                 update_jbsched(iaxs[fr->callno]);
2609         }
2610         if (tsout)
2611                 *tsout = fr->ts;
2612         if (needfree) {
2613                 /* Free our iax frame */
2614                 iax2_frame_free(fr);
2615                 return -1;
2616         }
2617         return 0;
2618 }
2619
2620 static int iax2_transmit(struct iax_frame *fr)
2621 {
2622         /* Lock the queue and place this packet at the end */
2623         /* By setting this to 0, the network thread will send it for us, and
2624            queue retransmission if necessary */
2625         fr->sentyet = 0;
2626         AST_LIST_LOCK(&frame_queue);
2627         AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
2628         AST_LIST_UNLOCK(&frame_queue);
2629         /* Wake up the network and scheduler thread */
2630         if (netthreadid != AST_PTHREADT_NULL)
2631                 pthread_kill(netthreadid, SIGURG);
2632         signal_condition(&sched_lock, &sched_cond);
2633         return 0;
2634 }
2635
2636
2637
2638 static int iax2_digit_begin(struct ast_channel *c, char digit)
2639 {
2640         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2641 }
2642
2643 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2644 {
2645         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2646 }
2647
2648 static int iax2_sendtext(struct ast_channel *c, const char *text)
2649 {
2650         
2651         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2652                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2653 }
2654
2655 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2656 {
2657         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2658 }
2659
2660 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2661 {
2662         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2663 }
2664
2665 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2666 {
2667         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2668         ast_mutex_lock(&iaxsl[callno]);
2669         if (iaxs[callno])
2670                 iaxs[callno]->owner = newchan;
2671         else
2672                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2673         ast_mutex_unlock(&iaxsl[callno]);
2674         return 0;
2675 }
2676
2677 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2678 {
2679         struct ast_variable *var;
2680         struct ast_variable *tmp;
2681         struct iax2_peer *peer=NULL;
2682         time_t regseconds = 0, nowtime;
2683         int dynamic=0;
2684
2685         if (peername)
2686                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2687         else {
2688                 char porta[25];
2689                 sprintf(porta, "%d", ntohs(sin->sin_port));
2690                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2691                 if (var) {
2692                         /* We'll need the peer name in order to build the structure! */
2693                         for (tmp = var; tmp; tmp = tmp->next) {
2694                                 if (!strcasecmp(tmp->name, "name"))
2695                                         peername = tmp->value;
2696                         }
2697                 }
2698         }
2699         if (!var)
2700                 return NULL;
2701
2702         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2703         
2704         if (!peer) {
2705                 ast_variables_destroy(var);
2706                 return NULL;
2707         }
2708
2709         for (tmp = var; tmp; tmp = tmp->next) {
2710                 /* Make sure it's not a user only... */
2711                 if (!strcasecmp(tmp->name, "type")) {
2712                         if (strcasecmp(tmp->value, "friend") &&
2713                             strcasecmp(tmp->value, "peer")) {
2714                                 /* Whoops, we weren't supposed to exist! */
2715                                 destroy_peer(peer);
2716                                 peer = NULL;
2717                                 break;
2718                         } 
2719                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2720                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2721                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2722                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2723                 } else if (!strcasecmp(tmp->name, "port")) {
2724                         peer->addr.sin_port = htons(atoi(tmp->value));
2725                 } else if (!strcasecmp(tmp->name, "host")) {
2726                         if (!strcasecmp(tmp->value, "dynamic"))
2727                                 dynamic = 1;
2728                 }
2729         }
2730
2731         ast_variables_destroy(var);
2732
2733         if (!peer)
2734                 return NULL;
2735
2736         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2737                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2738                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2739                         if (peer->expire > -1)
2740                                 ast_sched_del(sched, peer->expire);
2741                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2742                 }
2743                 AST_LIST_LOCK(&peers);
2744                 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2745                 AST_LIST_UNLOCK(&peers);
2746                 if (ast_test_flag(peer, IAX_DYNAMIC))
2747                         reg_source_db(peer);
2748         } else {
2749                 ast_set_flag(peer, IAX_TEMPONLY);       
2750         }
2751
2752         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2753                 time(&nowtime);
2754                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2755                         memset(&peer->addr, 0, sizeof(peer->addr));
2756                         realtime_update_peer(peer->name, &peer->addr, 0);
2757                         ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2758                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2759                 }
2760                 else {
2761                         ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2762                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2763                 }
2764         }
2765
2766         return peer;
2767 }
2768
2769 static struct iax2_user *realtime_user(const char *username)
2770 {
2771         struct ast_variable *var;
2772         struct ast_variable *tmp;
2773         struct iax2_user *user=NULL;
2774
2775         var = ast_load_realtime("iaxusers", "name", username, NULL);
2776         if (!var)
2777                 return NULL;
2778
2779         tmp = var;
2780         while(tmp) {
2781                 /* Make sure it's not a peer only... */
2782                 if (!strcasecmp(tmp->name, "type")) {
2783                         if (strcasecmp(tmp->value, "friend") &&
2784                             strcasecmp(tmp->value, "user")) {
2785                                 return NULL;
2786                         } 
2787                 }
2788                 tmp = tmp->next;
2789         }
2790
2791         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2792
2793         ast_variables_destroy(var);
2794
2795         if (!user)
2796                 return NULL;
2797
2798         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2799                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2800                 AST_LIST_LOCK(&users);
2801                 AST_LIST_INSERT_HEAD(&users, user, entry);
2802                 AST_LIST_UNLOCK(&users);
2803         } else {
2804                 ast_set_flag(user, IAX_TEMPONLY);       
2805         }
2806
2807         return user;
2808 }
2809
2810 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2811 {
2812         char port[10];
2813         char regseconds[20];
2814         
2815         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2816         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2817         ast_update_realtime("iaxpeers", "name", peername, 
2818                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
2819                 "regseconds", regseconds, NULL);
2820 }
2821
2822 struct create_addr_info {
2823         int capability;
2824         unsigned int flags;
2825         int maxtime;
2826         int encmethods;
2827         int found;
2828         int sockfd;
2829         int adsi;
2830         char username[80];
2831         char secret[80];
2832         char outkey[80];
2833         char timezone[80];
2834         char prefs[32];
2835         char context[AST_MAX_CONTEXT];
2836         char peercontext[AST_MAX_CONTEXT];
2837         char mohinterpret[MAX_MUSICCLASS];
2838         char mohsuggest[MAX_MUSICCLASS];
2839 };
2840
2841 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2842 {
2843         struct iax2_peer *peer;
2844
2845         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2846         cai->sockfd = defaultsockfd;
2847         cai->maxtime = 0;
2848         sin->sin_family = AF_INET;
2849
2850         if (!(peer = find_peer(peername, 1))) {
2851                 cai->found = 0;
2852                 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
2853                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
2854                         return -1;
2855                 }
2856                 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2857                 /* use global iax prefs for unknown peer/user */
2858                 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2859                 return 0;
2860         }
2861
2862         cai->found = 1;
2863         
2864         /* if the peer has no address (current or default), return failure */
2865         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2866                 if (ast_test_flag(peer, IAX_TEMPONLY))
2867                         destroy_peer(peer);
2868                 return -1;
2869         }
2870
2871         /* if the peer is being monitored and is currently unreachable, return failure */
2872         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2873                 if (ast_test_flag(peer, IAX_TEMPONLY))
2874                         destroy_peer(peer);
2875                 return -1;
2876         }
2877
2878         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2879         cai->maxtime = peer->maxms;
2880         cai->capability = peer->capability;
2881         cai->encmethods = peer->encmethods;
2882         cai->sockfd = peer->sockfd;
2883         cai->adsi = peer->adsi;
2884         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2885         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2886         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2887         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2888         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2889         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2890         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2891         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2892         if (ast_strlen_zero(peer->dbsecret)) {
2893                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2894         } else {
2895                 char *family;
2896                 char *key = NULL;
2897
2898                 family = ast_strdupa(peer->dbsecret);
2899                 key = strchr(family, '/');
2900                 if (key)
2901                         *key++ = '\0';
2902                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2903                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2904                         if (ast_test_flag(peer, IAX_TEMPONLY))
2905                                 destroy_peer(peer);
2906                         return -1;
2907                 }
2908         }
2909
2910         if (peer->addr.sin_addr.s_addr) {
2911                 sin->sin_addr = peer->addr.sin_addr;
2912                 sin->sin_port = peer->addr.sin_port;
2913         } else {
2914                 sin->sin_addr = peer->defaddr.sin_addr;
2915                 sin->sin_port = peer->defaddr.sin_port;
2916         }
2917
2918         if (ast_test_flag(peer, IAX_TEMPONLY))
2919                 destroy_peer(peer);
2920
2921         return 0;
2922 }
2923
2924 static void __auto_congest(void *nothing)
2925 {
2926         int callno = PTR_TO_CALLNO(nothing);
2927         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2928         ast_mutex_lock(&iaxsl[callno]);
2929         if (iaxs[callno]) {
2930                 iaxs[callno]->initid = -1;
2931                 iax2_queue_frame(callno, &f);
2932                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2933         }
2934         ast_mutex_unlock(&iaxsl[callno]);
2935 }
2936
2937 static int auto_congest(void *data)
2938 {
2939 #ifdef SCHED_MULTITHREADED
2940         if (schedule_action(__auto_congest, data))
2941 #endif          
2942                 __auto_congest(data);
2943         return 0;
2944 }
2945
2946 static unsigned int iax2_datetime(const char *tz)
2947 {
2948         struct timeval t = ast_tvnow();
2949         struct ast_tm tm;
2950         unsigned int tmp;
2951         ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
2952         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
2953         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
2954         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
2955         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
2956         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
2957         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
2958         return tmp;
2959 }
2960
2961 struct parsed_dial_string {
2962         char *username;
2963         char *password;
2964         char *key;
2965         char *peer;
2966         char *port;
2967         char *exten;
2968         char *context;
2969         char *options;
2970 };
2971
2972 /*!
2973  * \brief Parses an IAX dial string into its component parts.
2974  * \param data the string to be parsed
2975  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2976  * \return nothing
2977  *
2978  * This function parses the string and fills the structure
2979  * with pointers to its component parts. The input string
2980  * will be modified.
2981  *
2982  * \note This function supports both plaintext passwords and RSA
2983  * key names; if the password string is formatted as '[keyname]',
2984  * then the keyname will be placed into the key field, and the
2985  * password field will be set to NULL.
2986  *
2987  * \note The dial string format is:
2988  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
2989  */
2990 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2991 {
2992         if (ast_strlen_zero(data))
2993                 return;
2994
2995         pds->peer = strsep(&data, "/");
2996         pds->exten = strsep(&data, "/");
2997         pds->options = data;
2998
2999         if (pds->exten) {
3000                 data = pds->exten;
3001                 pds->exten = strsep(&data, "@");
3002                 pds->context = data;
3003         }
3004
3005         if (strchr(pds->peer, '@')) {
3006                 data = pds->peer;
3007                 pds->username = strsep(&data, "@");
3008                 pds->peer = data;
3009         }
3010
3011         if (pds->username) {
3012                 data = pds->username;
3013                 pds->username = strsep(&data, ":");
3014                 pds->password = data;
3015         }
3016
3017         data = pds->peer;
3018         pds->peer = strsep(&data, ":");
3019         pds->port = data;
3020
3021         /* check for a key name wrapped in [] in the secret position, if found,
3022            move it to the key field instead
3023         */
3024         if (pds->password && (pds->password[0] == '[')) {
3025                 pds->key = ast_strip_quoted(pds->password, "[", "]");
3026                 pds->password = NULL;
3027         }
3028 }
3029
3030 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
3031 {
3032         struct sockaddr_in sin;
3033         char *l=NULL, *n=NULL, *tmpstr;
3034         struct iax_ie_data ied;
3035         char *defaultrdest = "s";
3036         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3037         struct parsed_dial_string pds;
3038         struct create_addr_info cai;
3039         struct ast_var_t *var;
3040         struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
3041         const char* osp_token_ptr;
3042         unsigned int osp_token_length;
3043         unsigned char osp_block_index;
3044         unsigned int osp_block_length;
3045         unsigned char osp_buffer[256];
3046
3047         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
3048                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
3049                 return -1;
3050         }
3051
3052         memset(&cai, 0, sizeof(cai));
3053         cai.encmethods = iax2_encryption;
3054
3055         memset(&pds, 0, sizeof(pds));
3056         tmpstr = ast_strdupa(dest);
3057         parse_dial_string(tmpstr, &pds);
3058
3059         if (!pds.exten)
3060                 pds.exten = defaultrdest;
3061
3062         if (create_addr(pds.peer, &sin, &cai)) {
3063                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
3064                 return -1;
3065         }
3066
3067         if (!pds.username && !ast_strlen_zero(cai.username))
3068                 pds.username = cai.username;
3069         if (!pds.password && !ast_strlen_zero(cai.secret))
3070                 pds.password = cai.secret;
3071         if (!pds.key && !ast_strlen_zero(cai.outkey))
3072                 pds.key = cai.outkey;
3073         if (!pds.context && !ast_strlen_zero(cai.peercontext))
3074                 pds.context = cai.peercontext;
3075
3076         /* Keep track of the context for outgoing calls too */
3077         ast_copy_string(c->context, cai.context, sizeof(c->context));
3078
3079         if (pds.port)
3080                 sin.sin_port = htons(atoi(pds.port));
3081
3082         l = c->cid.cid_num;
3083         n = c->cid.cid_name;
3084
3085         /* Now build request */ 
3086         memset(&ied, 0, sizeof(ied));
3087
3088         /* On new call, first IE MUST be IAX version of caller */
3089         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
3090         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
3091         if (pds.options && strchr(pds.options, 'a')) {
3092                 /* Request auto answer */
3093                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
3094         }
3095
3096         iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
3097
3098         if (l) {
3099                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
3100                 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3101         } else {
3102                 if (n)
3103                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3104                 else
3105                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
3106         }
3107
3108         iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
3109         iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
3110
3111         if (n)
3112                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
3113         if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
3114                 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
3115
3116         if (!ast_strlen_zero(c->language))
3117                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
3118         if (!ast_strlen_zero(c->cid.cid_dnid))
3119                 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
3120         if (!ast_strlen_zero(c->cid.cid_rdnis))
3121                 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
3122
3123         if (pds.context)
3124                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
3125
3126         if (pds.username)
3127                 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
3128
3129         if (cai.encmethods)
3130                 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
3131
3132         ast_mutex_lock(&iaxsl[callno]);
3133
3134         if (!ast_strlen_zero(c->context))
3135                 ast_string_field_set(iaxs[callno], context, c->context);
3136
3137         if (pds.username)
3138                 ast_string_field_set(iaxs[callno], username, pds.username);
3139
3140         iaxs[callno]->encmethods = cai.encmethods;
3141
3142         iaxs[callno]->adsi = cai.adsi;
3143         
3144         ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
3145         ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
3146
3147         if (pds.key)
3148                 ast_string_field_set(iaxs[callno], outkey, pds.key);
3149         if (pds.password)
3150                 ast_string_field_set(iaxs[callno], secret, pds.password);
3151
3152         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
3153         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
3154         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
3155         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
3156
3157         if (iaxs[callno]->maxtime) {
3158                 /* Initialize pingtime and auto-congest time */
3159                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
3160                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
3161         } else if (autokill) {
3162                 iaxs[callno]->pingtime = autokill / 2;
3163                 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
3164         }
3165
3166         /* Check if there is an OSP token set by IAXCHANINFO function */
3167         osp_token_ptr = iaxs[callno]->osptoken;
3168         if (!ast_strlen_zero(osp_token_ptr)) {
3169                 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
3170                         osp_block_index = 0;
3171                         while (osp_token_length > 0) {
3172                                 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
3173                                 osp_buffer[0] = osp_block_index;
3174                                 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
3175                                 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
3176                                 osp_block_index++;
3177                                 osp_token_ptr += osp_block_length;
3178                                 osp_token_length -= osp_block_length;
3179                         } 
3180                 } else
3181                         ast_log(LOG_WARNING, "OSP token is too long\n");
3182         } else if (iaxdebug)
3183                 ast_debug(1, "OSP token is undefined\n");
3184
3185         /* send the command using the appropriate socket for this peer */
3186         iaxs[callno]->sockfd = cai.sockfd;
3187
3188         /* Add remote vars */
3189         if (variablestore) {
3190                 AST_LIST_HEAD(, ast_var_t) *variablelist = variablestore->data;
3191                 AST_LIST_LOCK(variablelist);
3192                 AST_LIST_TRAVERSE(variablelist, var, entries) {
3193                         char tmp[256];
3194                         int i;
3195                         /* Automatically divide the value up into sized chunks */
3196                         for (i = 0; i < strlen(ast