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