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