88e1f5495850e77882273beb637d846498cf45a8
[asterisk/asterisk.git] / channels / chan_iax2.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Implementation of Inter-Asterisk eXchange Version 2
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \par See also
26  * \arg \ref Config_iax
27  *
28  * \ingroup channel_drivers
29  */
30
31 /*** MODULEINFO
32         <use>zaptel</use>
33         <use>crypto</use>
34  ***/
35
36 #include "asterisk.h"
37
38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
39
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <sys/types.h>
43 #include <sys/mman.h>
44 #include <dirent.h>
45 #include <sys/socket.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <netinet/in_systm.h>
49 #include <netinet/ip.h>
50 #include <sys/time.h>
51 #include <sys/signal.h>
52 #include <signal.h>
53 #include <string.h>
54 #include <strings.h>
55 #include <errno.h>
56 #include <unistd.h>
57 #include <netdb.h>
58 #include <fcntl.h>
59 #include <sys/stat.h>
60 #include <regex.h>
61
62 #include "asterisk/zapata.h"
63
64 #include "asterisk/lock.h"
65 #include "asterisk/frame.h" 
66 #include "asterisk/channel.h"
67 #include "asterisk/logger.h"
68 #include "asterisk/module.h"
69 #include "asterisk/pbx.h"
70 #include "asterisk/sched.h"
71 #include "asterisk/io.h"
72 #include "asterisk/config.h"
73 #include "asterisk/options.h"
74 #include "asterisk/cli.h"
75 #include "asterisk/translate.h"
76 #include "asterisk/md5.h"
77 #include "asterisk/cdr.h"
78 #include "asterisk/crypto.h"
79 #include "asterisk/acl.h"
80 #include "asterisk/manager.h"
81 #include "asterisk/callerid.h"
82 #include "asterisk/app.h"
83 #include "asterisk/astdb.h"
84 #include "asterisk/musiconhold.h"
85 #include "asterisk/features.h"
86 #include "asterisk/utils.h"
87 #include "asterisk/causes.h"
88 #include "asterisk/localtime.h"
89 #include "asterisk/aes.h"
90 #include "asterisk/dnsmgr.h"
91 #include "asterisk/devicestate.h"
92 #include "asterisk/netsock.h"
93 #include "asterisk/stringfields.h"
94 #include "asterisk/linkedlists.h"
95 #include "asterisk/event.h"
96
97 #include "iax2.h"
98 #include "iax2-parser.h"
99 #include "iax2-provision.h"
100 #include "jitterbuf.h"
101
102 /* Define SCHED_MULTITHREADED to run the scheduler in a special
103    multithreaded mode. */
104 #define SCHED_MULTITHREADED
105
106 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
107    thread is actually doing. */
108 #define DEBUG_SCHED_MULTITHREAD
109
110 #ifndef IPTOS_MINCOST
111 #define IPTOS_MINCOST 0x02
112 #endif
113
114 #ifdef SO_NO_CHECK
115 static int nochecksums = 0;
116 #endif
117
118
119 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
120 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
121
122 #define DEFAULT_THREAD_COUNT 10
123 #define DEFAULT_MAX_THREAD_COUNT 100
124 #define DEFAULT_RETRY_TIME 1000
125 #define MEMORY_SIZE 100
126 #define DEFAULT_DROP 3
127 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
128    but keeps the division between trunked and non-trunked better. */
129 #define TRUNK_CALL_START        0x4000
130
131 #define DEBUG_SUPPORT
132
133 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
134
135 /* Sample over last 100 units to determine historic jitter */
136 #define GAMMA (0.01)
137
138 static struct ast_codec_pref prefs;
139
140 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
141
142
143 /*! \brief Maximum transmission unit for the UDP packet in the trunk not to be
144     fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240 */
145 #define MAX_TRUNK_MTU 1240 
146
147 static int global_max_trunk_mtu;        /*!< Maximum MTU, 0 if not used */
148 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ;    /*!< Trunk MTU statistics */
149
150
151 static char context[80] = "default";
152
153 static char language[MAX_LANGUAGE] = "";
154 static char regcontext[AST_MAX_CONTEXT] = "";
155
156 static int maxauthreq = 3;
157 static int max_retries = 4;
158 static int ping_time = 21;
159 static int lagrq_time = 10;
160 static int maxtrunkcall = TRUNK_CALL_START;
161 static int maxnontrunkcall = 1;
162 static int maxjitterbuffer=1000;
163 static int resyncthreshold=1000;
164 static int maxjitterinterps=10;
165 static int jittertargetextra = 40; /* number of milliseconds the new jitter buffer adds on to its size */
166
167 #define MAX_TRUNKDATA           640 * 200       /*!< 40ms, uncompressed linear * 200 channels */
168
169 static int trunkfreq = 20;
170 static int trunkmaxsize = MAX_TRUNKDATA;
171
172 static int authdebug = 1;
173 static int autokill = 0;
174 static int iaxcompat = 0;
175
176 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
177
178 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
179
180 static unsigned int tos = 0;
181
182 static unsigned int cos = 0;
183
184 static int min_reg_expire;
185 static int max_reg_expire;
186
187 static int srvlookup = 0;
188
189 static int timingfd = -1;                               /* Timing file descriptor */
190
191 static struct ast_netsock_list *netsock;
192 static struct ast_netsock_list *outsock;                /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
193 static int defaultsockfd = -1;
194
195 int (*iax2_regfunk)(const char *username, int onoff) = NULL;
196
197 /* Ethernet, etc */
198 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
199 /* T1, maybe ISDN */
200 #define IAX_CAPABILITY_MEDBANDWIDTH     (IAX_CAPABILITY_FULLBANDWIDTH &         \
201                                          ~AST_FORMAT_SLINEAR &                  \
202                                          ~AST_FORMAT_ULAW &                     \
203                                          ~AST_FORMAT_ALAW &                     \
204                                          ~AST_FORMAT_G722) 
205 /* A modem */
206 #define IAX_CAPABILITY_LOWBANDWIDTH     (IAX_CAPABILITY_MEDBANDWIDTH &          \
207                                          ~AST_FORMAT_G726 &                     \
208                                          ~AST_FORMAT_G726_AAL2 &                \
209                                          ~AST_FORMAT_ADPCM)
210
211 #define IAX_CAPABILITY_LOWFREE          (IAX_CAPABILITY_LOWBANDWIDTH &          \
212                                          ~AST_FORMAT_G723_1)
213
214
215 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
216 #define DEFAULT_FREQ_OK         60 * 1000       /* How often to check for the host to be up */
217 #define DEFAULT_FREQ_NOTOK      10 * 1000       /* How often to check, if the host is down... */
218
219 static  struct io_context *io;
220 static  struct sched_context *sched;
221
222 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
223
224 static int iaxdebug = 0;
225
226 static int iaxtrunkdebug = 0;
227
228 static int test_losspct = 0;
229 #ifdef IAXTESTS
230 static int test_late = 0;
231 static int test_resync = 0;
232 static int test_jit = 0;
233 static int test_jitpct = 0;
234 #endif /* IAXTESTS */
235
236 static char accountcode[AST_MAX_ACCOUNT_CODE];
237 static char mohinterpret[MAX_MUSICCLASS];
238 static char mohsuggest[MAX_MUSICCLASS];
239 static int amaflags = 0;
240 static int adsi = 0;
241 static int delayreject = 0;
242 static int iax2_encryption = 0;
243
244 static struct ast_flags globalflags = { 0 };
245
246 static pthread_t netthreadid = AST_PTHREADT_NULL;
247 static pthread_t schedthreadid = AST_PTHREADT_NULL;
248 AST_MUTEX_DEFINE_STATIC(sched_lock);
249 static ast_cond_t sched_cond;
250
251 enum iax2_state {
252         IAX_STATE_STARTED =             (1 << 0),
253         IAX_STATE_AUTHENTICATED =       (1 << 1),
254         IAX_STATE_TBD =                 (1 << 2),
255         IAX_STATE_UNCHANGED =           (1 << 3),
256 };
257
258 struct iax2_context {
259         char context[AST_MAX_CONTEXT];
260         struct iax2_context *next;
261 };
262
263 enum iax2_flags {
264         IAX_HASCALLERID =       (1 << 0),       /*!< CallerID has been specified */
265         IAX_DELME =             (1 << 1),       /*!< Needs to be deleted */
266         IAX_TEMPONLY =          (1 << 2),       /*!< Temporary (realtime) */
267         IAX_TRUNK =             (1 << 3),       /*!< Treat as a trunk */
268         IAX_NOTRANSFER =        (1 << 4),       /*!< Don't native bridge */
269         IAX_USEJITTERBUF =      (1 << 5),       /*!< Use jitter buffer */
270         IAX_DYNAMIC =           (1 << 6),       /*!< dynamic peer */
271         IAX_SENDANI =           (1 << 7),       /*!< Send ANI along with CallerID */
272         /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
273         IAX_ALREADYGONE =       (1 << 9),       /*!< Already disconnected */
274         IAX_PROVISION =         (1 << 10),      /*!< This is a provisioning request */
275         IAX_QUELCH =            (1 << 11),      /*!< Whether or not we quelch audio */
276         IAX_ENCRYPTED =         (1 << 12),      /*!< Whether we should assume encrypted tx/rx */
277         IAX_KEYPOPULATED =      (1 << 13),      /*!< Whether we have a key populated */
278         IAX_CODEC_USER_FIRST =  (1 << 14),      /*!< are we willing to let the other guy choose the codec? */
279         IAX_CODEC_NOPREFS =     (1 << 15),      /*!< Force old behaviour by turning off prefs */
280         IAX_CODEC_NOCAP =       (1 << 16),      /*!< only consider requested format and ignore capabilities*/
281         IAX_RTCACHEFRIENDS =    (1 << 17),      /*!< let realtime stay till your reload */
282         IAX_RTUPDATE =          (1 << 18),      /*!< Send a realtime update */
283         IAX_RTAUTOCLEAR =       (1 << 19),      /*!< erase me on expire */ 
284         IAX_FORCEJITTERBUF =    (1 << 20),      /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */ 
285         IAX_RTIGNOREREGEXPIRE = (1 << 21),      /*!< When using realtime, ignore registration expiration */
286         IAX_TRUNKTIMESTAMPS =   (1 << 22),      /*!< Send trunk timestamps */
287         IAX_TRANSFERMEDIA =     (1 << 23),      /*!< When doing IAX2 transfers, transfer media only */
288         IAX_MAXAUTHREQ =        (1 << 24),      /*!< Maximum outstanding AUTHREQ restriction is in place */
289         IAX_DELAYPBXSTART =     (1 << 25),      /*!< Don't start a PBX on the channel until the peer sends us a
290                                                      response, so that we've achieved a three-way handshake with
291                                                      them before sending voice or anything else*/
292 };
293
294 static int global_rtautoclear = 120;
295
296 static int reload_config(void);
297 static int iax2_reload(int fd, int argc, char *argv[]);
298
299
300 struct iax2_user {
301         AST_DECLARE_STRING_FIELDS(
302                 AST_STRING_FIELD(name);
303                 AST_STRING_FIELD(secret);
304                 AST_STRING_FIELD(dbsecret);
305                 AST_STRING_FIELD(accountcode);
306                 AST_STRING_FIELD(mohinterpret);
307                 AST_STRING_FIELD(mohsuggest);
308                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this user can use to authenticate to us */
309                 AST_STRING_FIELD(language);
310                 AST_STRING_FIELD(cid_num);
311                 AST_STRING_FIELD(cid_name);
312         );
313         
314         int authmethods;
315         int encmethods;
316         int amaflags;
317         int adsi;
318         unsigned int flags;
319         int capability;
320         int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
321         int curauthreq; /*!< Current number of outstanding AUTHREQs */
322         struct ast_codec_pref prefs;
323         struct ast_ha *ha;
324         struct iax2_context *contexts;
325         struct ast_variable *vars;
326         AST_LIST_ENTRY(iax2_user) entry;
327 };
328
329 struct iax2_peer {
330         AST_DECLARE_STRING_FIELDS(
331                 AST_STRING_FIELD(name);
332                 AST_STRING_FIELD(username);
333                 AST_STRING_FIELD(secret);
334                 AST_STRING_FIELD(dbsecret);
335                 AST_STRING_FIELD(outkey);           /*!< What key we use to talk to this peer */
336
337                 AST_STRING_FIELD(regexten);     /*!< Extension to register (if regcontext is used) */
338                 AST_STRING_FIELD(context);      /*!< For transfers only */
339                 AST_STRING_FIELD(peercontext);  /*!< Context to pass to peer */
340                 AST_STRING_FIELD(mailbox);          /*!< Mailbox */
341                 AST_STRING_FIELD(mohinterpret);
342                 AST_STRING_FIELD(mohsuggest);
343                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this peer can use to authenticate to us */
344                 /* Suggested caller id if registering */
345                 AST_STRING_FIELD(cid_num);              /*!< Default context (for transfer really) */
346                 AST_STRING_FIELD(cid_name);             /*!< Default context (for transfer really) */
347                 AST_STRING_FIELD(zonetag);              /*!< Time Zone */
348         );
349         struct ast_codec_pref prefs;
350         struct ast_dnsmgr_entry *dnsmgr;                /*!< DNS refresh manager */
351         struct sockaddr_in addr;
352         int formats;
353         int sockfd;                                     /*!< Socket to use for transmission */
354         struct in_addr mask;
355         int adsi;
356         unsigned int flags;
357
358         /* Dynamic Registration fields */
359         struct sockaddr_in defaddr;                     /*!< Default address if there is one */
360         int authmethods;                                /*!< Authentication methods (IAX_AUTH_*) */
361         int encmethods;                                 /*!< Encryption methods (IAX_ENCRYPT_*) */
362
363         int expire;                                     /*!< Schedule entry for expiry */
364         int expiry;                                     /*!< How soon to expire */
365         int capability;                                 /*!< Capability */
366
367         /* Qualification */
368         int callno;                                     /*!< Call number of POKE request */
369         int pokeexpire;                                 /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
370         int lastms;                                     /*!< How long last response took (in ms), or -1 for no response */
371         int maxms;                                      /*!< Max ms we will accept for the host to be up, 0 to not monitor */
372
373         int pokefreqok;                                 /*!< How often to check if the host is up */
374         int pokefreqnotok;                              /*!< How often to check when the host has been determined to be down */
375         int historicms;                                 /*!< How long recent average responses took */
376         int smoothing;                                  /*!< Sample over how many units to determine historic ms */
377
378         struct ast_event_sub *mwi_event_sub;
379
380         struct ast_ha *ha;
381         AST_LIST_ENTRY(iax2_peer) entry;
382 };
383
384 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
385
386 struct iax2_trunk_peer {
387         ast_mutex_t lock;
388         int sockfd;
389         struct sockaddr_in addr;
390         struct timeval txtrunktime;             /*!< Transmit trunktime */
391         struct timeval rxtrunktime;             /*!< Receive trunktime */
392         struct timeval lasttxtime;              /*!< Last transmitted trunktime */
393         struct timeval trunkact;                /*!< Last trunk activity */
394         unsigned int lastsent;                  /*!< Last sent time */
395         /* Trunk data and length */
396         unsigned char *trunkdata;
397         unsigned int trunkdatalen;
398         unsigned int trunkdataalloc;
399         int trunkmaxmtu;
400         int trunkerror;
401         int calls;
402         AST_LIST_ENTRY(iax2_trunk_peer) list;
403 };
404
405 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
406
407 struct iax_firmware {
408         AST_LIST_ENTRY(iax_firmware) list;
409         int fd;
410         int mmaplen;
411         int dead;
412         struct ast_iax2_firmware_header *fwh;
413         unsigned char *buf;
414 };
415
416 enum iax_reg_state {
417         REG_STATE_UNREGISTERED = 0,
418         REG_STATE_REGSENT,
419         REG_STATE_AUTHSENT,
420         REG_STATE_REGISTERED,
421         REG_STATE_REJECTED,
422         REG_STATE_TIMEOUT,
423         REG_STATE_NOAUTH
424 };
425
426 enum iax_transfer_state {
427         TRANSFER_NONE = 0,
428         TRANSFER_BEGIN,
429         TRANSFER_READY,
430         TRANSFER_RELEASED,
431         TRANSFER_PASSTHROUGH,
432         TRANSFER_MBEGIN,
433         TRANSFER_MREADY,
434         TRANSFER_MRELEASED,
435         TRANSFER_MPASSTHROUGH,
436         TRANSFER_MEDIA,
437         TRANSFER_MEDIAPASS
438 };
439
440 struct iax2_registry {
441         struct sockaddr_in addr;                /*!< Who we connect to for registration purposes */
442         char username[80];
443         char secret[80];                        /*!< Password or key name in []'s */
444         int expire;                             /*!< Sched ID of expiration */
445         int refresh;                            /*!< How often to refresh */
446         enum iax_reg_state regstate;
447         int messages;                           /*!< Message count, low 8 bits = new, high 8 bits = old */
448         int callno;                             /*!< Associated call number if applicable */
449         struct sockaddr_in us;                  /*!< Who the server thinks we are */
450         struct ast_dnsmgr_entry *dnsmgr;        /*!< DNS refresh manager */
451         AST_LIST_ENTRY(iax2_registry) entry;
452 };
453
454 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
455
456 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
457 #define MIN_RETRY_TIME          100
458 #define MAX_RETRY_TIME          10000
459
460 #define MAX_JITTER_BUFFER       50
461 #define MIN_JITTER_BUFFER       10
462
463 #define DEFAULT_TRUNKDATA       640 * 10        /*!< 40ms, uncompressed linear * 10 channels */
464
465 #define MAX_TIMESTAMP_SKEW      160             /*!< maximum difference between actual and predicted ts for sending */
466
467 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
468 #define TS_GAP_FOR_JB_RESYNC    5000
469
470 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
471 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
472 static int iaxdynamicthreadcount = 0;
473 static int iaxactivethreadcount = 0;
474
475 struct iax_rr {
476         int jitter;
477         int losspct;
478         int losscnt;
479         int packets;
480         int delay;
481         int dropped;
482         int ooo;
483 };
484
485 struct iax2_pvt_ref;
486
487 struct chan_iax2_pvt {
488         /*! Socket to send/receive on for this call */
489         int sockfd;
490         /*! Last received voice format */
491         int voiceformat;
492         /*! Last received video format */
493         int videoformat;
494         /*! Last sent voice format */
495         int svoiceformat;
496         /*! Last sent video format */
497         int svideoformat;
498         /*! What we are capable of sending */
499         int capability;
500         /*! Last received timestamp */
501         unsigned int last;
502         /*! Last sent timestamp - never send the same timestamp twice in a single call */
503         unsigned int lastsent;
504         /*! Next outgoing timestamp if everything is good */
505         unsigned int nextpred;
506         /*! True if the last voice we transmitted was not silence/CNG */
507         unsigned int notsilenttx:1;
508         /*! Ping time */
509         unsigned int pingtime;
510         /*! Max time for initial response */
511         int maxtime;
512         /*! Peer Address */
513         struct sockaddr_in addr;
514         /*! Actual used codec preferences */
515         struct ast_codec_pref prefs;
516         /*! Requested codec preferences */
517         struct ast_codec_pref rprefs;
518         /*! Our call number */
519         unsigned short callno;
520         /*! Peer callno */
521         unsigned short peercallno;
522         /*! 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,
730           some information about that frame will be stored
731           here, so we can avoid dispatching any more full
732           frames for that callno to other threads */
733         struct {
734                 unsigned short callno;
735                 struct sockaddr_in sin;
736                 unsigned char type;
737                 unsigned char csub;
738         } ffinfo;
739 };
740
741 /* Thread lists */
742 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
743 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
744 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
745
746 static void *iax2_process_thread(void *data);
747
748 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
749 {
750         ast_mutex_lock(lock);
751         ast_cond_signal(cond);
752         ast_mutex_unlock(lock);
753 }
754
755 static void iax_debug_output(const char *data)
756 {
757         if (iaxdebug)
758                 ast_verbose("%s", data);
759 }
760
761 static void iax_error_output(const char *data)
762 {
763         ast_log(LOG_WARNING, "%s", data);
764 }
765
766 static void jb_error_output(const char *fmt, ...)
767 {
768         va_list args;
769         char buf[1024];
770
771         va_start(args, fmt);
772         vsnprintf(buf, sizeof(buf), fmt, args);
773         va_end(args);
774
775         ast_log(LOG_ERROR, buf);
776 }
777
778 static void jb_warning_output(const char *fmt, ...)
779 {
780         va_list args;
781         char buf[1024];
782
783         va_start(args, fmt);
784         vsnprintf(buf, sizeof(buf), fmt, args);
785         va_end(args);
786
787         ast_log(LOG_WARNING, buf);
788 }
789
790 static void jb_debug_output(const char *fmt, ...)
791 {
792         va_list args;
793         char buf[1024];
794
795         va_start(args, fmt);
796         vsnprintf(buf, sizeof(buf), fmt, args);
797         va_end(args);
798
799         ast_verbose(buf);
800 }
801
802 /*!
803  * \brief an array of iax2 pvt structures
804  *
805  * The container for active chan_iax2_pvt structures is implemented as an
806  * array for extremely quick direct access to the correct pvt structure
807  * based on the local call number.  The local call number is used as the
808  * index into the array where the associated pvt structure is stored.
809  */
810 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
811 /*!
812  * \brief chan_iax2_pvt structure locks
813  *
814  * These locks are used when accessing a pvt structure in the iaxs array.
815  * The index used here is the same as used in the iaxs array.  It is the
816  * local call number for the associated pvt struct.
817  */
818 static ast_mutex_t iaxsl[IAX_MAX_CALLS];
819 /*!
820  * \brief The last time a call number was used
821  *
822  * It is important to know the last time that a call number was used locally so
823  * that it is not used again too soon.  The reason for this is the same as the
824  * reason that the TCP protocol state machine requires a "TIME WAIT" state.
825  *
826  * For example, say that a call is up.  Then, the remote side sends a HANGUP,
827  * which we respond to with an ACK.  However, there is no way to know whether
828  * the ACK made it there successfully.  If it were to get lost, the remote
829  * side may retransmit the HANGUP.  If in the meantime, this call number has
830  * been reused locally, given the right set of circumstances, this retransmitted
831  * HANGUP could potentially improperly hang up the new session.  So, to avoid
832  * this potential issue, we must wait a specified timeout period before reusing
833  * a local call number.
834  *
835  * The specified time that we must wait before reusing a local call number is
836  * defined as MIN_REUSE_TIME, with a default of 60 seconds.
837  */
838 static struct timeval lastused[IAX_MAX_CALLS];
839
840 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);
841 static int expire_registry(void *data);
842 static int iax2_answer(struct ast_channel *c);
843 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
844 static int iax2_devicestate(void *data);
845 static int iax2_digit_begin(struct ast_channel *c, char digit);
846 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
847 static int iax2_do_register(struct iax2_registry *reg);
848 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
849 static int iax2_hangup(struct ast_channel *c);
850 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
851 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
852 static int iax2_provision(struct sockaddr_in *end, int sockfd, char *dest, const char *template, int force);
853 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
854 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
855 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
856 static int iax2_sendtext(struct ast_channel *c, const char *text);
857 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
858 static int iax2_transfer(struct ast_channel *c, const char *dest);
859 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
860 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
861 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
862 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
863 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
864 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
865 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
866 static struct ast_channel *iax2_request(const char *type, int format, void *data, int *cause);
867 static struct ast_frame *iax2_read(struct ast_channel *c);
868 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
869 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
870 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
871 static void destroy_user(struct iax2_user *user);
872 static void prune_peers(void);
873
874 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
875 static int acf_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value);
876
877 static const struct ast_channel_tech iax2_tech = {
878         .type = "IAX2",
879         .description = tdesc,
880         .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
881         .properties = AST_CHAN_TP_WANTSJITTER,
882         .requester = iax2_request,
883         .devicestate = iax2_devicestate,
884         .send_digit_begin = iax2_digit_begin,
885         .send_digit_end = iax2_digit_end,
886         .send_text = iax2_sendtext,
887         .send_image = iax2_sendimage,
888         .send_html = iax2_sendhtml,
889         .call = iax2_call,
890         .hangup = iax2_hangup,
891         .answer = iax2_answer,
892         .read = iax2_read,
893         .write = iax2_write,
894         .write_video = iax2_write,
895         .indicate = iax2_indicate,
896         .setoption = iax2_setoption,
897         .bridge = iax2_bridge,
898         .transfer = iax2_transfer,
899         .fixup = iax2_fixup,
900         .func_channel_read = acf_channel_read,
901         .func_channel_write = acf_channel_write,
902 };
903
904 static void mwi_event_cb(const struct ast_event *event, void *userdata)
905 {
906         /* The MWI subscriptions exist just so the core knows we care about those
907          * mailboxes.  However, we just grab the events out of the cache when it
908          * is time to send MWI, since it is only sent with a REGACK. */
909 }
910
911 /*! \brief Send manager event at call setup to link between Asterisk channel name
912         and IAX2 call identifiers */
913 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt) 
914 {
915         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
916                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
917                 pvt->owner ? pvt->owner->name : "",
918                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
919 }
920
921
922 static void insert_idle_thread(struct iax2_thread *thread)
923 {
924         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
925                 AST_LIST_LOCK(&dynamic_list);
926                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
927                 AST_LIST_UNLOCK(&dynamic_list);
928         } else {
929                 AST_LIST_LOCK(&idle_list);
930                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
931                 AST_LIST_UNLOCK(&idle_list);
932         }
933
934         return;
935 }
936
937 static struct iax2_thread *find_idle_thread(void)
938 {
939         struct iax2_thread *thread = NULL;
940
941         /* Pop the head of the idle list off */
942         AST_LIST_LOCK(&idle_list);
943         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
944         AST_LIST_UNLOCK(&idle_list);
945
946         /* If we popped a thread off the idle list, just return it */
947         if (thread)
948                 return thread;
949
950         /* Pop the head of the dynamic list off */
951         AST_LIST_LOCK(&dynamic_list);
952         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
953         AST_LIST_UNLOCK(&dynamic_list);
954
955         /* If we popped a thread off the dynamic list, just return it */
956         if (thread)
957                 return thread;
958
959         /* If we can't create a new dynamic thread for any reason, return no thread at all */
960         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
961                 return NULL;
962
963         /* Set default values */
964         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
965         thread->type = IAX_THREAD_TYPE_DYNAMIC;
966
967         /* Initialize lock and condition */
968         ast_mutex_init(&thread->lock);
969         ast_cond_init(&thread->cond, NULL);
970
971         /* Create thread and send it on it's way */
972         if (ast_pthread_create_detached_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
973                 ast_cond_destroy(&thread->cond);
974                 ast_mutex_destroy(&thread->lock);
975                 ast_free(thread);
976                 thread = NULL;
977         }
978
979         /* this thread is not processing a full frame (since it is idle),
980            so ensure that the field for the full frame call number is empty */
981         if (thread)
982                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
983
984         return thread;
985 }
986
987 #ifdef SCHED_MULTITHREADED
988 static int __schedule_action(void (*func)(void *data), void *data, const char *funcname)
989 {
990         struct iax2_thread *thread = NULL;
991         static time_t lasterror;
992         static time_t t;
993
994         thread = find_idle_thread();
995
996         if (thread != NULL) {
997                 thread->schedfunc = func;
998                 thread->scheddata = data;
999                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1000 #ifdef DEBUG_SCHED_MULTITHREAD
1001                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1002 #endif
1003                 signal_condition(&thread->lock, &thread->cond);
1004                 return 0;
1005         }
1006         time(&t);
1007         if (t != lasterror) 
1008                 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
1009         lasterror = t;
1010
1011         return -1;
1012 }
1013 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1014 #endif
1015
1016 static int send_ping(void *data);
1017
1018 static void __send_ping(void *data)
1019 {
1020         int callno = (long)data;
1021         ast_mutex_lock(&iaxsl[callno]);
1022         if (iaxs[callno] && iaxs[callno]->pingid != -1) {
1023                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1024                 iaxs[callno]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, data);
1025         }
1026         ast_mutex_unlock(&iaxsl[callno]);
1027 }
1028
1029 static int send_ping(void *data)
1030 {
1031 #ifdef SCHED_MULTITHREADED
1032         if (schedule_action(__send_ping, data))
1033 #endif          
1034                 __send_ping(data);
1035         return 0;
1036 }
1037
1038 static int get_encrypt_methods(const char *s)
1039 {
1040         int e;
1041         if (!strcasecmp(s, "aes128"))
1042                 e = IAX_ENCRYPT_AES128;
1043         else if (ast_true(s))
1044                 e = IAX_ENCRYPT_AES128;
1045         else
1046                 e = 0;
1047         return e;
1048 }
1049
1050 static int send_lagrq(void *data);
1051
1052 static void __send_lagrq(void *data)
1053 {
1054         int callno = (long)data;
1055         /* Ping only if it's real not if it's bridged */
1056         ast_mutex_lock(&iaxsl[callno]);
1057         if (iaxs[callno] && iaxs[callno]->lagid != -1) {
1058                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1059                 iaxs[callno]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1060         }
1061         ast_mutex_unlock(&iaxsl[callno]);
1062 }
1063
1064 static int send_lagrq(void *data)
1065 {
1066 #ifdef SCHED_MULTITHREADED
1067         if (schedule_action(__send_lagrq, data))
1068 #endif          
1069                 __send_lagrq(data);
1070         return 0;
1071 }
1072
1073 static unsigned char compress_subclass(int subclass)
1074 {
1075         int x;
1076         int power=-1;
1077         /* If it's 128 or smaller, just return it */
1078         if (subclass < IAX_FLAG_SC_LOG)
1079                 return subclass;
1080         /* Otherwise find its power */
1081         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1082                 if (subclass & (1 << x)) {
1083                         if (power > -1) {
1084                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1085                                 return 0;
1086                         } else
1087                                 power = x;
1088                 }
1089         }
1090         return power | IAX_FLAG_SC_LOG;
1091 }
1092
1093 static int uncompress_subclass(unsigned char csub)
1094 {
1095         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1096         if (csub & IAX_FLAG_SC_LOG) {
1097                 /* special case for 'compressed' -1 */
1098                 if (csub == 0xff)
1099                         return -1;
1100                 else
1101                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1102         }
1103         else
1104                 return csub;
1105 }
1106
1107 static struct iax2_peer *find_peer(const char *name, int realtime) 
1108 {
1109         struct iax2_peer *peer = NULL;
1110
1111         /* Grab peer from linked list */
1112         AST_LIST_LOCK(&peers);
1113         AST_LIST_TRAVERSE(&peers, peer, entry) {
1114                 if (!strcasecmp(peer->name, name)) {
1115                         break;
1116                 }
1117         }
1118         AST_LIST_UNLOCK(&peers);
1119
1120         /* Now go for realtime if applicable */
1121         if(!peer && realtime)
1122                 peer = realtime_peer(name, NULL);
1123         return peer;
1124 }
1125
1126 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1127 {
1128         struct iax2_peer *peer = NULL;
1129         int res = 0;
1130
1131         if (lockpeer)
1132                 AST_LIST_LOCK(&peers);
1133         AST_LIST_TRAVERSE(&peers, peer, entry) {
1134                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1135                     (peer->addr.sin_port == sin.sin_port)) {
1136                         ast_copy_string(host, peer->name, len);
1137                         res = 1;
1138                         break;
1139                 }
1140         }
1141         if (lockpeer)
1142                 AST_LIST_UNLOCK(&peers);
1143         if (!peer) {
1144                 peer = realtime_peer(NULL, &sin);
1145                 if (peer) {
1146                         ast_copy_string(host, peer->name, len);
1147                         if (ast_test_flag(peer, IAX_TEMPONLY))
1148                                 destroy_peer(peer);
1149                         res = 1;
1150                 }
1151         }
1152
1153         return res;
1154 }
1155
1156 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1157 {
1158         struct chan_iax2_pvt *tmp;
1159         jb_conf jbconf;
1160
1161         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1162                 return NULL;
1163
1164         if (ast_string_field_init(tmp, 32)) {
1165                 ast_free(tmp);
1166                 tmp = NULL;
1167                 return NULL;
1168         }
1169                 
1170         tmp->prefs = prefs;
1171         tmp->pingid = -1;
1172         tmp->lagid = -1;
1173         tmp->autoid = -1;
1174         tmp->authid = -1;
1175         tmp->initid = -1;
1176
1177         ast_string_field_set(tmp,exten, "s");
1178         ast_string_field_set(tmp,host, host);
1179
1180         tmp->jb = jb_new();
1181         tmp->jbid = -1;
1182         jbconf.max_jitterbuf = maxjitterbuffer;
1183         jbconf.resync_threshold = resyncthreshold;
1184         jbconf.max_contig_interp = maxjitterinterps;
1185         jbconf.target_extra = jittertargetextra;
1186         jb_setconf(tmp->jb,&jbconf);
1187
1188         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1189
1190         return tmp;
1191 }
1192
1193 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1194 {
1195         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1196         if (new) {
1197                 size_t mallocd_datalen = new->mallocd_datalen;
1198                 memcpy(new, fr, sizeof(*new));
1199                 iax_frame_wrap(new, &fr->af);
1200                 new->mallocd_datalen = mallocd_datalen;
1201                 new->data = NULL;
1202                 new->datalen = 0;
1203                 new->direction = DIRECTION_INGRESS;
1204                 new->retrans = -1;
1205         }
1206         return new;
1207 }
1208
1209 #define NEW_PREVENT     0
1210 #define NEW_ALLOW       1
1211 #define NEW_FORCE       2
1212
1213 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1214 {
1215         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1216                 (cur->addr.sin_port == sin->sin_port)) {
1217                 /* This is the main host */
1218                 if ((cur->peercallno == callno) ||
1219                         ((dcallno == cur->callno) && !cur->peercallno)) {
1220                         /* That's us.  Be sure we keep track of the peer call number */
1221                         return 1;
1222                 }
1223         }
1224         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1225             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1226                 /* We're transferring */
1227                 if (dcallno == cur->callno)
1228                         return 1;
1229         }
1230         return 0;
1231 }
1232
1233 static void update_max_trunk(void)
1234 {
1235         int max = TRUNK_CALL_START;
1236         int x;
1237         /* XXX Prolly don't need locks here XXX */
1238         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1239                 if (iaxs[x])
1240                         max = x + 1;
1241         }
1242         maxtrunkcall = max;
1243         if (option_debug && iaxdebug)
1244                 ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max);
1245 }
1246
1247 static void update_max_nontrunk(void)
1248 {
1249         int max = 1;
1250         int x;
1251         /* XXX Prolly don't need locks here XXX */
1252         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1253                 if (iaxs[x])
1254                         max = x + 1;
1255         }
1256         maxnontrunkcall = max;
1257         if (option_debug && iaxdebug)
1258                 ast_log(LOG_DEBUG, "New max nontrunk callno is %d\n", max);
1259 }
1260
1261 static int make_trunk(unsigned short callno, int locked)
1262 {
1263         int x;
1264         int res= 0;
1265         struct timeval now;
1266         if (iaxs[callno]->oseqno) {
1267                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1268                 return -1;
1269         }
1270         if (callno & TRUNK_CALL_START) {
1271                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1272                 return -1;
1273         }
1274         gettimeofday(&now, NULL);
1275         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1276                 ast_mutex_lock(&iaxsl[x]);
1277                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1278                         iaxs[x] = iaxs[callno];
1279                         iaxs[x]->callno = x;
1280                         iaxs[callno] = NULL;
1281                         /* Update the two timers that should have been started */
1282                         if (iaxs[x]->pingid > -1)
1283                                 ast_sched_del(sched, iaxs[x]->pingid);
1284                         if (iaxs[x]->lagid > -1)
1285                                 ast_sched_del(sched, iaxs[x]->lagid);
1286                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1287                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1288                         if (locked)
1289                                 ast_mutex_unlock(&iaxsl[callno]);
1290                         res = x;
1291                         if (!locked)
1292                                 ast_mutex_unlock(&iaxsl[x]);
1293                         break;
1294                 }
1295                 ast_mutex_unlock(&iaxsl[x]);
1296         }
1297         if (x >= IAX_MAX_CALLS - 1) {
1298                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1299                 return -1;
1300         }
1301         if (option_debug)
1302                 ast_log(LOG_DEBUG, "Made call %d into trunk call %d\n", callno, x);
1303         /* We move this call from a non-trunked to a trunked call */
1304         update_max_trunk();
1305         update_max_nontrunk();
1306         return res;
1307 }
1308
1309 /*!
1310  * \todo XXX Note that this function contains a very expensive operation that
1311  * happens for *every* incoming media frame.  It iterates through every
1312  * possible call number, locking and unlocking each one, to try to match the
1313  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1314  * So, for an call with a local call number of 20000, every incoming audio
1315  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1316  *
1317  * It's a shame that IAX2 media frames carry the source call number instead of
1318  * the destination call number.  If they did, this lookup wouldn't be needed.
1319  * However, it's too late to change that now.  Instead, we need to come up with
1320  * a better way of indexing active calls so that these frequent lookups are not
1321  * so expensive.
1322  */
1323 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1324 {
1325         int res = 0;
1326         int x;
1327         struct timeval now;
1328         char host[80];
1329         if (new <= NEW_ALLOW) {
1330                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1331                         ast_mutex_lock(&iaxsl[x]);
1332                         if (iaxs[x]) {
1333                                 /* Look for an exact match */
1334                                 if (match(sin, callno, dcallno, iaxs[x])) {
1335                                         res = x;
1336                                 }
1337                         }
1338                         ast_mutex_unlock(&iaxsl[x]);
1339                 }
1340                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1341                         ast_mutex_lock(&iaxsl[x]);
1342                         if (iaxs[x]) {
1343                                 /* Look for an exact match */
1344                                 if (match(sin, callno, dcallno, iaxs[x])) {
1345                                         res = x;
1346                                 }
1347                         }
1348                         ast_mutex_unlock(&iaxsl[x]);
1349                 }
1350         }
1351         if ((res < 1) && (new >= NEW_ALLOW)) {
1352                 /* It may seem odd that we look through the peer list for a name for
1353                  * this *incoming* call.  Well, it is weird.  However, users don't
1354                  * have an IP address/port number that we can match against.  So,
1355                  * this is just checking for a peer that has that IP/port and
1356                  * assuming that we have a user of the same name.  This isn't always
1357                  * correct, but it will be changed if needed after authentication. */
1358                 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1359                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1360                 gettimeofday(&now, NULL);
1361                 for (x=1;x<TRUNK_CALL_START;x++) {
1362                         /* Find first unused call number that hasn't been used in a while */
1363                         ast_mutex_lock(&iaxsl[x]);
1364                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1365                         ast_mutex_unlock(&iaxsl[x]);
1366                 }
1367                 /* We've still got lock held if we found a spot */
1368                 if (x >= TRUNK_CALL_START) {
1369                         ast_log(LOG_WARNING, "No more space\n");
1370                         return 0;
1371                 }
1372                 iaxs[x] = new_iax(sin, lockpeer, host);
1373                 update_max_nontrunk();
1374                 if (iaxs[x]) {
1375                         if (option_debug && iaxdebug)
1376                                 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
1377                         iaxs[x]->sockfd = sockfd;
1378                         iaxs[x]->addr.sin_port = sin->sin_port;
1379                         iaxs[x]->addr.sin_family = sin->sin_family;
1380                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1381                         iaxs[x]->peercallno = callno;
1382                         iaxs[x]->callno = x;
1383                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1384                         iaxs[x]->expiry = min_reg_expire;
1385                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1386                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1387                         iaxs[x]->amaflags = amaflags;
1388                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1389                         
1390                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1391                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1392                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1393                 } else {
1394                         ast_log(LOG_WARNING, "Out of resources\n");
1395                         ast_mutex_unlock(&iaxsl[x]);
1396                         return 0;
1397                 }
1398                 ast_mutex_unlock(&iaxsl[x]);
1399                 res = x;
1400         }
1401         return res;
1402 }
1403
1404 static void iax2_frame_free(struct iax_frame *fr)
1405 {
1406         if (fr->retrans > -1)
1407                 ast_sched_del(sched, fr->retrans);
1408         iax_frame_free(fr);
1409 }
1410
1411 /*!
1412  * \brief Queue a frame to a call's owning asterisk channel
1413  *
1414  * \note This function assumes that iaxsl[callno] is locked when called.
1415  *
1416  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1417  * was valid before calling it, it may no longer be valid after calling it.
1418  * This function may unlock and lock the mutex associated with this callno,
1419  * meaning that another thread may grab it and destroy the call.
1420  */
1421 static int iax2_queue_frame(int callno, struct ast_frame *f)
1422 {
1423         /* Assumes lock for callno is already held... */
1424         for (;;) {
1425                 if (iaxs[callno] && iaxs[callno]->owner) {
1426                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1427                                 /* Avoid deadlock by pausing and trying again */
1428                                 ast_mutex_unlock(&iaxsl[callno]);
1429                                 usleep(1);
1430                                 ast_mutex_lock(&iaxsl[callno]);
1431                         } else {
1432                                 ast_queue_frame(iaxs[callno]->owner, f);
1433                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1434                                 break;
1435                         }
1436                 } else
1437                         break;
1438         }
1439         return 0;
1440 }
1441
1442 static void destroy_firmware(struct iax_firmware *cur)
1443 {
1444         /* Close firmware */
1445         if (cur->fwh) {
1446                 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1447         }
1448         close(cur->fd);
1449         ast_free(cur);
1450 }
1451
1452 static int try_firmware(char *s)
1453 {
1454         struct stat stbuf;
1455         struct iax_firmware *cur = NULL;
1456         int ifd, fd, res, len, chunk;
1457         struct ast_iax2_firmware_header *fwh, fwh2;
1458         struct MD5Context md5;
1459         unsigned char sum[16], buf[1024];
1460         char *s2, *last;
1461
1462         if (!(s2 = alloca(strlen(s) + 100))) {
1463                 ast_log(LOG_WARNING, "Alloca failed!\n");
1464                 return -1;
1465         }
1466
1467         last = strrchr(s, '/');
1468         if (last)
1469                 last++;
1470         else
1471                 last = s;
1472
1473         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1474
1475         if ((res = stat(s, &stbuf) < 0)) {
1476                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1477                 return -1;
1478         }
1479
1480         /* Make sure it's not a directory */
1481         if (S_ISDIR(stbuf.st_mode))
1482                 return -1;
1483         ifd = open(s, O_RDONLY);
1484         if (ifd < 0) {
1485                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1486                 return -1;
1487         }
1488         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1489         if (fd < 0) {
1490                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1491                 close(ifd);
1492                 return -1;
1493         }
1494         /* Unlink our newly created file */
1495         unlink(s2);
1496         
1497         /* Now copy the firmware into it */
1498         len = stbuf.st_size;
1499         while(len) {
1500                 chunk = len;
1501                 if (chunk > sizeof(buf))
1502                         chunk = sizeof(buf);
1503                 res = read(ifd, buf, chunk);
1504                 if (res != chunk) {
1505                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1506                         close(ifd);
1507                         close(fd);
1508                         return -1;
1509                 }
1510                 res = write(fd, buf, chunk);
1511                 if (res != chunk) {
1512                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1513                         close(ifd);
1514                         close(fd);
1515                         return -1;
1516                 }
1517                 len -= chunk;
1518         }
1519         close(ifd);
1520         /* Return to the beginning */
1521         lseek(fd, 0, SEEK_SET);
1522         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1523                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1524                 close(fd);
1525                 return -1;
1526         }
1527         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1528                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1529                 close(fd);
1530                 return -1;
1531         }
1532         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1533                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1534                 close(fd);
1535                 return -1;
1536         }
1537         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1538                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1539                 close(fd);
1540                 return -1;
1541         }
1542         fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1543         if (fwh == (void *) -1) {
1544                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1545                 close(fd);
1546                 return -1;
1547         }
1548         MD5Init(&md5);
1549         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1550         MD5Final(sum, &md5);
1551         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1552                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1553                 munmap(fwh, stbuf.st_size);
1554                 close(fd);
1555                 return -1;
1556         }
1557
1558         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1559                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1560                         /* Found a candidate */
1561                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1562                                 /* The version we have on loaded is older, load this one instead */
1563                                 break;
1564                         /* This version is no newer than what we have.  Don't worry about it.
1565                            We'll consider it a proper load anyhow though */
1566                         munmap(fwh, stbuf.st_size);
1567                         close(fd);
1568                         return 0;
1569                 }
1570         }
1571         
1572         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1573                 cur->fd = -1;
1574                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1575         }
1576         
1577         if (cur) {
1578                 if (cur->fwh)
1579                         munmap(cur->fwh, cur->mmaplen);
1580                 if (cur->fd > -1)
1581                         close(cur->fd);
1582                 cur->fwh = fwh;
1583                 cur->fd = fd;
1584                 cur->mmaplen = stbuf.st_size;
1585                 cur->dead = 0;
1586         }
1587         
1588         return 0;
1589 }
1590
1591 static int iax_check_version(char *dev)
1592 {
1593         int res = 0;
1594         struct iax_firmware *cur = NULL;
1595
1596         if (ast_strlen_zero(dev))
1597                 return 0;
1598
1599         AST_LIST_LOCK(&firmwares);
1600         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1601                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1602                         res = ntohs(cur->fwh->version);
1603                         break;
1604                 }
1605         }
1606         AST_LIST_UNLOCK(&firmwares);
1607
1608         return res;
1609 }
1610
1611 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1612 {
1613         int res = -1;
1614         unsigned int bs = desc & 0xff;
1615         unsigned int start = (desc >> 8) & 0xffffff;
1616         unsigned int bytes;
1617         struct iax_firmware *cur;
1618
1619         if (ast_strlen_zero((char *)dev) || !bs)
1620                 return -1;
1621
1622         start *= bs;
1623         
1624         AST_LIST_LOCK(&firmwares);
1625         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1626                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1627                         continue;
1628                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1629                 if (start < ntohl(cur->fwh->datalen)) {
1630                         bytes = ntohl(cur->fwh->datalen) - start;
1631                         if (bytes > bs)
1632                                 bytes = bs;
1633                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1634                 } else {
1635                         bytes = 0;
1636                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1637                 }
1638                 if (bytes == bs)
1639                         res = 0;
1640                 else
1641                         res = 1;
1642                 break;
1643         }
1644         AST_LIST_UNLOCK(&firmwares);
1645
1646         return res;
1647 }
1648
1649
1650 static void reload_firmware(void)
1651 {
1652         struct iax_firmware *cur = NULL;
1653         DIR *fwd;
1654         struct dirent *de;
1655         char dir[256], fn[256];
1656
1657         AST_LIST_LOCK(&firmwares);
1658
1659         /* Mark all as dead */
1660         AST_LIST_TRAVERSE(&firmwares, cur, list)
1661                 cur->dead = 1;
1662
1663         /* Now that we have marked them dead... load new ones */
1664         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1665         fwd = opendir(dir);
1666         if (fwd) {
1667                 while((de = readdir(fwd))) {
1668                         if (de->d_name[0] != '.') {
1669                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1670                                 if (!try_firmware(fn)) {
1671                                         if (option_verbose > 1)
1672                                                 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1673                                 }
1674                         }
1675                 }
1676                 closedir(fwd);
1677         } else 
1678                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1679
1680         /* Clean up leftovers */
1681         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1682                 if (!cur->dead)
1683                         continue;
1684                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1685                 destroy_firmware(cur);
1686         }
1687         AST_LIST_TRAVERSE_SAFE_END
1688
1689         AST_LIST_UNLOCK(&firmwares);
1690 }
1691
1692 /*!
1693  * \note This function assumes that iaxsl[callno] is locked when called.
1694  *
1695  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1696  * was valid before calling it, it may no longer be valid after calling it.
1697  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
1698  * associated with this callno, meaning that another thread may grab it and destroy the call.
1699  */
1700 static int __do_deliver(void *data)
1701 {
1702         /* Just deliver the packet by using queueing.  This is called by
1703           the IAX thread with the iaxsl lock held. */
1704         struct iax_frame *fr = data;
1705         fr->retrans = -1;
1706         fr->af.has_timing_info = 0;
1707         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1708                 iax2_queue_frame(fr->callno, &fr->af);
1709         /* Free our iax frame */
1710         iax2_frame_free(fr);
1711         /* And don't run again */
1712         return 0;
1713 }
1714
1715 static int handle_error(void)
1716 {
1717         /* XXX Ideally we should figure out why an error occurred and then abort those
1718            rather than continuing to try.  Unfortunately, the published interface does
1719            not seem to work XXX */
1720 #if 0
1721         struct sockaddr_in *sin;
1722         int res;
1723         struct msghdr m;
1724         struct sock_extended_err e;
1725         m.msg_name = NULL;
1726         m.msg_namelen = 0;
1727         m.msg_iov = NULL;
1728         m.msg_control = &e;
1729         m.msg_controllen = sizeof(e);
1730         m.msg_flags = 0;
1731         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1732         if (res < 0)
1733                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1734         else {
1735                 if (m.msg_controllen) {
1736                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1737                         if (sin) 
1738                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1739                         else
1740                                 ast_log(LOG_WARNING, "No address detected??\n");
1741                 } else {
1742                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1743                 }
1744         }
1745 #endif
1746         return 0;
1747 }
1748
1749 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1750 {
1751         int res;
1752         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1753                                         sizeof(*sin));
1754         if (res < 0) {
1755                 if (option_debug)
1756                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1757                 handle_error();
1758         } else
1759                 res = 0;
1760         return res;
1761 }
1762
1763 static int send_packet(struct iax_frame *f)
1764 {
1765         int res;
1766         int callno = f->callno;
1767
1768         /* Don't send if there was an error, but return error instead */
1769         if (!callno || !iaxs[callno] || iaxs[callno]->error)
1770             return -1;
1771         
1772         /* Called with iaxsl held */
1773         if (option_debug > 2 && iaxdebug)
1774                 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));
1775         if (f->transfer) {
1776                 if (iaxdebug)
1777                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1778                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1779                                         sizeof(iaxs[callno]->transfer));
1780         } else {
1781                 if (iaxdebug)
1782                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1783                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1784                                         sizeof(iaxs[callno]->addr));
1785         }
1786         if (res < 0) {
1787                 if (option_debug && iaxdebug)
1788                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1789                 handle_error();
1790         } else
1791                 res = 0;
1792         return res;
1793 }
1794
1795 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1796 {
1797         struct iax2_user *user = NULL;
1798
1799         /* Decrement AUTHREQ count if needed */
1800         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1801                 AST_LIST_LOCK(&users);
1802                 AST_LIST_TRAVERSE(&users, user, entry) {
1803                         if (!strcmp(user->name, pvt->username)) {
1804                                 user->curauthreq--;
1805                                 break;
1806                         }
1807                 }
1808                 AST_LIST_UNLOCK(&users);
1809                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1810         }
1811         /* No more pings or lagrq's */
1812         if (pvt->pingid > -1)
1813                 ast_sched_del(sched, pvt->pingid);
1814         pvt->pingid = -1;
1815         if (pvt->lagid > -1)
1816                 ast_sched_del(sched, pvt->lagid);
1817         pvt->lagid = -1;
1818         if (pvt->autoid > -1)
1819                 ast_sched_del(sched, pvt->autoid);
1820         pvt->autoid = -1;
1821         if (pvt->authid > -1)
1822                 ast_sched_del(sched, pvt->authid);
1823         pvt->authid = -1;
1824         if (pvt->initid > -1)
1825                 ast_sched_del(sched, pvt->initid);
1826         pvt->initid = -1;
1827         if (pvt->jbid > -1)
1828                 ast_sched_del(sched, pvt->jbid);
1829         pvt->jbid = -1;
1830 }
1831
1832 static int iax2_predestroy(int callno)
1833 {
1834         struct ast_channel *c = NULL;
1835         struct chan_iax2_pvt *pvt = iaxs[callno];
1836
1837         if (!pvt)
1838                 return -1;
1839
1840         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1841                 iax2_destroy_helper(pvt);
1842                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1843         }
1844
1845         if ((c = pvt->owner)) {
1846                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1847                 c->tech_pvt = NULL;
1848                 ast_queue_hangup(c);
1849                 pvt->owner = NULL;
1850                 ast_module_unref(ast_module_info->self);
1851         }
1852
1853         return 0;
1854 }
1855
1856 static void iax2_destroy(int callno)
1857 {
1858         struct chan_iax2_pvt *pvt = NULL;
1859         struct iax_frame *cur = NULL;
1860         struct ast_channel *owner = NULL;
1861
1862 retry:
1863         pvt = iaxs[callno];
1864         gettimeofday(&lastused[callno], NULL);
1865         
1866         owner = pvt ? pvt->owner : NULL;
1867
1868         if (owner) {
1869                 if (ast_mutex_trylock(&owner->lock)) {
1870                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1871                         ast_mutex_unlock(&iaxsl[callno]);
1872                         usleep(1);
1873                         ast_mutex_lock(&iaxsl[callno]);
1874                         goto retry;
1875                 }
1876         }
1877         if (!owner)
1878                 iaxs[callno] = NULL;
1879         if (pvt) {
1880                 if (!owner)
1881                         pvt->owner = NULL;
1882                 iax2_destroy_helper(pvt);
1883
1884                 /* Already gone */
1885                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1886
1887                 if (owner) {
1888                         /* If there's an owner, prod it to give up */
1889                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1890                         ast_queue_hangup(owner);
1891                 }
1892
1893                 AST_LIST_LOCK(&queue);
1894                 AST_LIST_TRAVERSE(&queue, cur, list) {
1895                         /* Cancel any pending transmissions */
1896                         if (cur->callno == pvt->callno) 
1897                                 cur->retries = -1;
1898                 }
1899                 AST_LIST_UNLOCK(&queue);
1900
1901                 if (pvt->reg)
1902                         pvt->reg->callno = 0;
1903                 if (!owner) {
1904                         jb_frame frame;
1905                         if (pvt->vars) {
1906                             ast_variables_destroy(pvt->vars);
1907                             pvt->vars = NULL;
1908                         }
1909
1910                         while (jb_getall(pvt->jb, &frame) == JB_OK)
1911                                 iax2_frame_free(frame.data);
1912                         jb_destroy(pvt->jb);
1913                         /* gotta free up the stringfields */
1914                         ast_string_field_free_pools(pvt);
1915                         ast_free(pvt);
1916                 }
1917         }
1918         if (owner) {
1919                 ast_mutex_unlock(&owner->lock);
1920         }
1921         if (callno & 0x4000)
1922                 update_max_trunk();
1923 }
1924
1925 static int update_packet(struct iax_frame *f)
1926 {
1927         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1928         struct ast_iax2_full_hdr *fh = f->data;
1929         /* Mark this as a retransmission */
1930         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1931         /* Update iseqno */
1932         f->iseqno = iaxs[f->callno]->iseqno;
1933         fh->iseqno = f->iseqno;
1934         return 0;
1935 }
1936
1937 static int attempt_transmit(void *data);
1938 static void __attempt_transmit(void *data)
1939 {
1940         /* Attempt to transmit the frame to the remote peer...
1941            Called without iaxsl held. */
1942         struct iax_frame *f = data;
1943         int freeme=0;
1944         int callno = f->callno;
1945         /* Make sure this call is still active */
1946         if (callno) 
1947                 ast_mutex_lock(&iaxsl[callno]);
1948         if (callno && iaxs[callno]) {
1949                 if ((f->retries < 0) /* Already ACK'd */ ||
1950                     (f->retries >= max_retries) /* Too many attempts */) {
1951                                 /* Record an error if we've transmitted too many times */
1952                                 if (f->retries >= max_retries) {
1953                                         if (f->transfer) {
1954                                                 /* Transfer timeout */
1955                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1956                                         } else if (f->final) {
1957                                                 if (f->final) 
1958                                                         iax2_destroy(callno);
1959                                         } else {
1960                                                 if (iaxs[callno]->owner)
1961                                                         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);
1962                                                 iaxs[callno]->error = ETIMEDOUT;
1963                                                 if (iaxs[callno]->owner) {
1964                                                         struct ast_frame fr = { 0, };
1965                                                         /* Hangup the fd */
1966                                                         fr.frametype = AST_FRAME_CONTROL;
1967                                                         fr.subclass = AST_CONTROL_HANGUP;
1968                                                         iax2_queue_frame(callno, &fr); // XXX
1969                                                         /* Remember, owner could disappear */
1970                                                         if (iaxs[callno] && iaxs[callno]->owner)
1971                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1972                                                 } else {
1973                                                         if (iaxs[callno]->reg) {
1974                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
1975                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
1976                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1977                                                         }
1978                                                         iax2_destroy(callno);
1979                                                 }
1980                                         }
1981
1982                                 }
1983                                 freeme++;
1984                 } else {
1985                         /* Update it if it needs it */
1986                         update_packet(f);
1987                         /* Attempt transmission */
1988                         send_packet(f);
1989                         f->retries++;
1990                         /* Try again later after 10 times as long */
1991                         f->retrytime *= 10;
1992                         if (f->retrytime > MAX_RETRY_TIME)
1993                                 f->retrytime = MAX_RETRY_TIME;
1994                         /* Transfer messages max out at one second */
1995                         if (f->transfer && (f->retrytime > 1000))
1996                                 f->retrytime = 1000;
1997                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1998                 }
1999         } else {
2000                 /* Make sure it gets freed */
2001                 f->retries = -1;
2002                 freeme++;
2003         }
2004         if (callno)
2005                 ast_mutex_unlock(&iaxsl[callno]);
2006         /* Do not try again */
2007         if (freeme) {
2008                 /* Don't attempt delivery, just remove it from the queue */
2009                 AST_LIST_LOCK(&queue);
2010                 AST_LIST_REMOVE(&queue, f, list);
2011                 AST_LIST_UNLOCK(&queue);
2012                 f->retrans = -1;
2013                 /* Free the IAX frame */
2014                 iax2_frame_free(f);
2015         }
2016 }
2017
2018 static int attempt_transmit(void *data)
2019 {
2020 #ifdef SCHED_MULTITHREADED
2021         if (schedule_action(__attempt_transmit, data))
2022 #endif          
2023                 __attempt_transmit(data);
2024         return 0;
2025 }
2026
2027 static int iax2_prune_realtime(int fd, int argc, char *argv[])
2028 {
2029         struct iax2_peer *peer;
2030
2031         if (argc != 4)
2032         return RESULT_SHOWUSAGE;
2033         if (!strcmp(argv[3],"all")) {
2034                 reload_config();
2035                 ast_cli(fd, "OK cache is flushed.\n");
2036         } else if ((peer = find_peer(argv[3], 0))) {
2037                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2038                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2039                         expire_registry((void*)peer->name);
2040                         ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
2041                 } else {
2042                         ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
2043                 }
2044         } else {
2045                 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
2046         }
2047         
2048         return RESULT_SUCCESS;
2049 }
2050
2051 static int iax2_test_losspct(int fd, int argc, char *argv[])
2052 {
2053        if (argc != 4)
2054                return RESULT_SHOWUSAGE;
2055
2056        test_losspct = atoi(argv[3]);
2057
2058        return RESULT_SUCCESS;
2059 }
2060
2061 #ifdef IAXTESTS
2062 static int iax2_test_late(int fd, int argc, char *argv[])
2063 {
2064         if (argc != 4)
2065                 return RESULT_SHOWUSAGE;
2066
2067         test_late = atoi(argv[3]);
2068
2069         return RESULT_SUCCESS;
2070 }
2071
2072 static int iax2_test_resync(int fd, int argc, char *argv[])
2073 {
2074         if (argc != 4)
2075                 return RESULT_SHOWUSAGE;
2076
2077         test_resync = atoi(argv[3]);
2078
2079         return RESULT_SUCCESS;
2080 }
2081
2082 static int iax2_test_jitter(int fd, int argc, char *argv[])
2083 {
2084         if (argc < 4 || argc > 5)
2085                 return RESULT_SHOWUSAGE;
2086
2087         test_jit = atoi(argv[3]);
2088         if (argc == 5) 
2089                 test_jitpct = atoi(argv[4]);
2090
2091         return RESULT_SUCCESS;
2092 }
2093 #endif /* IAXTESTS */
2094
2095 /*! \brief  peer_status: Report Peer status in character string */
2096 /*      returns 1 if peer is online, -1 if unmonitored */
2097 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2098 {
2099         int res = 0;
2100         if (peer->maxms) {
2101                 if (peer->lastms < 0) {
2102                         ast_copy_string(status, "UNREACHABLE", statuslen);
2103                 } else if (peer->lastms > peer->maxms) {
2104                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2105                         res = 1;
2106                 } else if (peer->lastms) {
2107                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2108                         res = 1;
2109                 } else {
2110                         ast_copy_string(status, "UNKNOWN", statuslen);
2111                 }
2112         } else { 
2113                 ast_copy_string(status, "Unmonitored", statuslen);
2114                 res = -1;
2115         }
2116         return res;
2117 }
2118
2119 /*! \brief Show one peer in detail */
2120 static int iax2_show_peer(int fd, int argc, char *argv[])
2121 {
2122         char status[30];
2123         char cbuf[256];
2124         struct iax2_peer *peer;
2125         char codec_buf[512];
2126         int x = 0, codec = 0, load_realtime = 0;
2127
2128         if (argc < 4)
2129                 return RESULT_SHOWUSAGE;
2130
2131         load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2132
2133         peer = find_peer(argv[3], load_realtime);
2134         if (peer) {
2135                 ast_cli(fd,"\n\n");
2136                 ast_cli(fd, "  * Name       : %s\n", peer->name);
2137                 ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2138                 ast_cli(fd, "  Context      : %s\n", peer->context);
2139                 ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
2140                 ast_cli(fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2141                 ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2142                 ast_cli(fd, "  Expire       : %d\n", peer->expire);
2143                 ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
2144                 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));
2145                 ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2146                 ast_cli(fd, "  Username     : %s\n", peer->username);
2147                 ast_cli(fd, "  Codecs       : ");
2148                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2149                 ast_cli(fd, "%s\n", codec_buf);
2150
2151                 ast_cli(fd, "  Codec Order  : (");
2152                 for(x = 0; x < 32 ; x++) {
2153                         codec = ast_codec_pref_index(&peer->prefs,x);
2154                         if(!codec)
2155                                 break;
2156                         ast_cli(fd, "%s", ast_getformatname(codec));
2157                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2158                                 ast_cli(fd, "|");
2159                 }
2160
2161                 if (!x)
2162                         ast_cli(fd, "none");
2163                 ast_cli(fd, ")\n");
2164
2165                 ast_cli(fd, "  Status       : ");
2166                 peer_status(peer, status, sizeof(status));      
2167                 ast_cli(fd, "%s\n",status);
2168                 ast_cli(fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2169                 ast_cli(fd,"\n");
2170                 if (ast_test_flag(peer, IAX_TEMPONLY))
2171                         destroy_peer(peer);
2172         } else {
2173                 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2174                 ast_cli(fd,"\n");
2175         }
2176
2177         return RESULT_SUCCESS;
2178 }
2179
2180 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2181 {
2182         int which = 0;
2183         struct iax2_peer *p = NULL;
2184         char *res = NULL;
2185         int wordlen = strlen(word);
2186
2187         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2188         if (pos == 3) {
2189                 AST_LIST_LOCK(&peers);
2190                 AST_LIST_TRAVERSE(&peers, p, entry) {
2191                         if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2192                                 res = ast_strdup(p->name);
2193                                 break;
2194                         }
2195                 }
2196                 AST_LIST_UNLOCK(&peers);
2197         }
2198
2199         return res;
2200 }
2201
2202 static int iax2_show_stats(int fd, int argc, char *argv[])
2203 {
2204         struct iax_frame *cur;
2205         int cnt = 0, dead=0, final=0;
2206
2207         if (argc != 3)
2208                 return RESULT_SHOWUSAGE;
2209
2210         AST_LIST_LOCK(&queue);
2211         AST_LIST_TRAVERSE(&queue, cur, list) {
2212                 if (cur->retries < 0)
2213                         dead++;
2214                 if (cur->final)
2215                         final++;
2216                 cnt++;
2217         }
2218         AST_LIST_UNLOCK(&queue);
2219
2220         ast_cli(fd, "    IAX Statistics\n");
2221         ast_cli(fd, "---------------------\n");
2222         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2223         ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2224                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2225
2226         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2227
2228         trunk_timed = trunk_untimed = 0;
2229         if (trunk_maxmtu > trunk_nmaxmtu)
2230                 trunk_nmaxmtu = trunk_maxmtu;
2231         
2232         return RESULT_SUCCESS;
2233 }
2234
2235 /*! \brief Set trunk MTU from CLI */
2236 static int iax2_set_mtu(int fd, int argc, char *argv[])
2237 {
2238         int mtuv;
2239
2240         if (argc != 4)
2241                 return RESULT_SHOWUSAGE; 
2242         if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0) 
2243                 mtuv = MAX_TRUNK_MTU; 
2244         else                                         
2245                 mtuv = atoi(argv[3]); 
2246
2247         if (mtuv == 0) {
2248                 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2249                 global_max_trunk_mtu = 0; 
2250                 return RESULT_SUCCESS; 
2251         }
2252         if (mtuv < 172 || mtuv > 4000) {
2253                 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n"); 
2254                 return RESULT_SHOWUSAGE; 
2255         }
2256         ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2257         global_max_trunk_mtu = mtuv; 
2258         return RESULT_SUCCESS;
2259 }
2260
2261 static int iax2_show_cache(int fd, int argc, char *argv[])
2262 {
2263         struct iax2_dpcache *dp = NULL;
2264         char tmp[1024], *pc = NULL;
2265         int s, x, y;
2266         struct timeval tv;
2267
2268         gettimeofday(&tv, NULL);
2269
2270         AST_LIST_LOCK(&dpcache);
2271
2272         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2273
2274         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2275                 s = dp->expiry.tv_sec - tv.tv_sec;
2276                 tmp[0] = '\0';
2277                 if (dp->flags & CACHE_FLAG_EXISTS)
2278                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2279                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2280                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2281                 if (dp->flags & CACHE_FLAG_CANEXIST)
2282                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2283                 if (dp->flags & CACHE_FLAG_PENDING)
2284                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2285                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2286                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2287                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2288                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2289                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2290                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2291                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2292                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2293                 /* Trim trailing pipe */
2294                 if (!ast_strlen_zero(tmp))
2295                         tmp[strlen(tmp) - 1] = '\0';
2296                 else
2297                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2298                 y=0;
2299                 pc = strchr(dp->peercontext, '@');
2300                 if (!pc)
2301                         pc = dp->peercontext;
2302                 else
2303                         pc++;
2304                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2305                         if (dp->waiters[x] > -1)
2306                                 y++;
2307                 if (s > 0)
2308                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2309                 else
2310                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2311         }
2312
2313         AST_LIST_LOCK(&dpcache);
2314
2315         return RESULT_SUCCESS;
2316 }
2317
2318 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2319
2320 static void unwrap_timestamp(struct iax_frame *fr)
2321 {
2322         int x;
2323
2324         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2325                 x = fr->ts - iaxs[fr->callno]->last;
2326                 if (x < -50000) {
2327                         /* Sudden big jump backwards in timestamp:
2328                            What likely happened here is that miniframe timestamp has circled but we haven't
2329                            gotten the update from the main packet.  We'll just pretend that we did, and
2330                            update the timestamp appropriately. */
2331                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2332                         if (option_debug && iaxdebug)
2333                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed forward timestamp\n");
2334                 }
2335                 if (x > 50000) {
2336                         /* Sudden apparent big jump forwards in timestamp:
2337                            What's likely happened is this is an old miniframe belonging to the previous
2338                            top-16-bit timestamp that has turned up out of order.
2339                            Adjust the timestamp appropriately. */
2340                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2341                         if (option_debug && iaxdebug)
2342                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed back timestamp\n");
2343                 }
2344         }
2345 }
2346
2347 static int get_from_jb(void *p);
2348
2349 static void update_jbsched(struct chan_iax2_pvt *pvt)
2350 {
2351         int when;
2352         
2353         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2354         
2355         when = jb_next(pvt->jb) - when;
2356         
2357         if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2358         
2359         if(when <= 0) {
2360                 /* XXX should really just empty until when > 0.. */
2361                 when = 1;
2362         }
2363         
2364         pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2365         
2366         /* Signal scheduler thread */
2367         signal_condition(&sched_lock, &sched_cond);
2368 }
2369
2370 static void __get_from_jb(void *p) 
2371 {
2372         int callno = PTR_TO_CALLNO(p);
2373         struct chan_iax2_pvt *pvt = NULL;
2374         struct iax_frame *fr;
2375         jb_frame frame;
2376         int ret;
2377         long now;
2378         long next;
2379         struct timeval tv;
2380         
2381         /* Make sure we have a valid private structure before going on */
2382         ast_mutex_lock(&iaxsl[callno]);
2383         pvt = iaxs[callno];
2384         if (!pvt) {
2385                 /* No go! */
2386                 ast_mutex_unlock(&iaxsl[callno]);
2387                 return;
2388         }
2389
2390         pvt->jbid = -1;
2391         
2392         gettimeofday(&tv,NULL);
2393         /* round up a millisecond since ast_sched_runq does; */
2394         /* prevents us from spinning while waiting for our now */
2395         /* to catch up with runq's now */
2396         tv.tv_usec += 1000;
2397         
2398         now = ast_tvdiff_ms(tv, pvt->rxcore);
2399         
2400         if(now >= (next = jb_next(pvt->jb))) {
2401                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2402                 switch(ret) {
2403                 case JB_OK:
2404                         fr = frame.data;
2405                         __do_deliver(fr);
2406                         /* __do_deliver() can cause the call to disappear */
2407                         pvt = iaxs[callno];
2408                         break;
2409                 case JB_INTERP:
2410                 {
2411                         struct ast_frame af = { 0, };
2412                         
2413                         /* create an interpolation frame */
2414                         af.frametype = AST_FRAME_VOICE;
2415                         af.subclass = pvt->voiceformat;
2416                         af.samples  = frame.ms * 8;
2417                         af.src  = "IAX2 JB interpolation";
2418                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2419                         af.offset = AST_FRIENDLY_OFFSET;
2420                         
2421                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2422                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2423                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2424                                 iax2_queue_frame(callno, &af);
2425                                 /* iax2_queue_frame() could cause the call to disappear */
2426                                 pvt = iaxs[callno];
2427                         }
2428                 }
2429                         break;
2430                 case JB_DROP:
2431                         iax2_frame_free(frame.data);
2432                         break;
2433                 case JB_NOFRAME:
2434                 case JB_EMPTY:
2435                         /* do nothing */
2436                         break;
2437                 default:
2438                         /* shouldn't happen */
2439                         break;
2440                 }
2441         }
2442         if (pvt)
2443                 update_jbsched(pvt);
2444         ast_mutex_unlock(&iaxsl[callno]);
2445 }
2446
2447 static int get_from_jb(void *data)
2448 {
2449 #ifdef SCHED_MULTITHREADED
2450         if (schedule_action(__get_from_jb, data))
2451 #endif          
2452                 __get_from_jb(data);
2453         return 0;
2454 }
2455
2456 /*!
2457  * \note This function assumes fr->callno is locked
2458  *
2459  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2460  * was valid before calling it, it may no longer be valid after calling it.
2461  */
2462 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2463 {
2464         int type, len;
2465         int ret;
2466         int needfree = 0;
2467
2468         /* Attempt to recover wrapped timestamps */
2469         unwrap_timestamp(fr);
2470
2471         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2472         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2473                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2474         else {
2475 #if 0
2476                 if (option_debug)
2477                         ast_log(LOG_DEBUG, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2478 #endif
2479                 fr->af.delivery = ast_tv(0,0);
2480         }
2481
2482         type = JB_TYPE_CONTROL;
2483         len = 0;
2484
2485         if(fr->af.frametype == AST_FRAME_VOICE) {
2486                 type = JB_TYPE_VOICE;
2487                 len = ast_codec_get_samples(&fr->af) / 8;
2488         } else if(fr->af.frametype == AST_FRAME_CNG) {
2489                 type = JB_TYPE_SILENCE;
2490         }
2491
2492         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2493                 if (tsout)
2494                         *tsout = fr->ts;
2495                 __do_deliver(fr);
2496                 return -1;
2497         }
2498
2499         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2500          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2501         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2502             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2503             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2504                 jb_frame frame;
2505
2506                 /* deliver any frames in the jb */
2507                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2508                         __do_deliver(frame.data);
2509                         /* __do_deliver() can make the call disappear */
2510                         if (!iaxs[fr->callno])
2511                                 return -1;
2512                 }
2513
2514                 jb_reset(iaxs[fr->callno]->jb);
2515
2516                 if (iaxs[fr->callno]->jbid > -1)
2517                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2518
2519                 iaxs[fr->callno]->jbid = -1;
2520
2521                 /* deliver this frame now */
2522                 if (tsout)
2523                         *tsout = fr->ts;
2524                 __do_deliver(fr);
2525                 return -1;
2526         }
2527
2528         /* insert into jitterbuffer */
2529         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2530         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2531                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2532         if (ret == JB_DROP) {
2533                 needfree++;
2534         } else if (ret == JB_SCHED) {
2535                 update_jbsched(iaxs[fr->callno]);
2536         }
2537         if (tsout)
2538                 *tsout = fr->ts;
2539         if (needfree) {
2540                 /* Free our iax frame */
2541                 iax2_frame_free(fr);
2542                 return -1;
2543         }
2544         return 0;
2545 }
2546
2547 static int iax2_transmit(struct iax_frame *fr)
2548 {
2549         /* Lock the queue and place this packet at the end */
2550         /* By setting this to 0, the network thread will send it for us, and
2551            queue retransmission if necessary */
2552         fr->sentyet = 0;
2553         AST_LIST_LOCK(&queue);
2554         AST_LIST_INSERT_TAIL(&queue, fr, list);
2555         AST_LIST_UNLOCK(&queue);
2556         /* Wake up the network and scheduler thread */
2557         if (netthreadid != AST_PTHREADT_NULL)
2558                 pthread_kill(netthreadid, SIGURG);
2559         signal_condition(&sched_lock, &sched_cond);
2560         return 0;
2561 }
2562
2563
2564
2565 static int iax2_digit_begin(struct ast_channel *c, char digit)
2566 {
2567         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2568 }
2569
2570 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2571 {
2572         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2573 }
2574
2575 static int iax2_sendtext(struct ast_channel *c, const char *text)
2576 {
2577         
2578         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2579                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2580 }
2581
2582 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2583 {
2584         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2585 }
2586
2587 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2588 {
2589         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2590 }
2591
2592 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2593 {
2594         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2595         ast_mutex_lock(&iaxsl[callno]);
2596         if (iaxs[callno])
2597                 iaxs[callno]->owner = newchan;
2598         else
2599                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2600         ast_mutex_unlock(&iaxsl[callno]);
2601         return 0;
2602 }
2603
2604 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2605 {
2606         struct ast_variable *var;
2607         struct ast_variable *tmp;
2608         struct iax2_peer *peer=NULL;
2609         time_t regseconds = 0, nowtime;
2610         int dynamic=0;
2611
2612         if (peername)
2613                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2614         else {
2615                 char porta[25];
2616                 sprintf(porta, "%d", ntohs(sin->sin_port));
2617                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2618                 if (var) {
2619                         /* We'll need the peer name in order to build the structure! */
2620                         for (tmp = var; tmp; tmp = tmp->next) {
2621                                 if (!strcasecmp(tmp->name, "name"))
2622                                         peername = tmp->value;
2623                         }
2624                 }
2625         }
2626         if (!var)
2627                 return NULL;
2628
2629         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2630         
2631         if (!peer) {
2632                 ast_variables_destroy(var);
2633                 return NULL;
2634         }
2635
2636         for (tmp = var; tmp; tmp = tmp->next) {
2637                 /* Make sure it's not a user only... */
2638                 if (!strcasecmp(tmp->name, "type")) {
2639                         if (strcasecmp(tmp->value, "friend") &&
2640                             strcasecmp(tmp->value, "peer")) {
2641                                 /* Whoops, we weren't supposed to exist! */
2642                                 destroy_peer(peer);
2643                                 peer = NULL;
2644                                 break;
2645                         } 
2646                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2647                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2648                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2649                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2650                 } else if (!strcasecmp(tmp->name, "port")) {
2651                         peer->addr.sin_port = htons(atoi(tmp->value));
2652                 } else if (!strcasecmp(tmp->name, "host")) {
2653                         if (!strcasecmp(tmp->value, "dynamic"))
2654                                 dynamic = 1;
2655                 }
2656         }
2657
2658         ast_variables_destroy(var);
2659
2660         if (!peer)
2661                 return NULL;
2662
2663         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2664                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2665                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2666                         if (peer->expire > -1)
2667                                 ast_sched_del(sched, peer->expire);
2668                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2669                 }
2670                 AST_LIST_LOCK(&peers);
2671                 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2672                 AST_LIST_UNLOCK(&peers);
2673                 if (ast_test_flag(peer, IAX_DYNAMIC))
2674                         reg_source_db(peer);
2675         } else {
2676                 ast_set_flag(peer, IAX_TEMPONLY);       
2677         }
2678
2679         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2680                 time(&nowtime);
2681                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2682                         memset(&peer->addr, 0, sizeof(peer->addr));
2683                         realtime_update_peer(peer->name, &peer->addr, 0);
2684                         if (option_debug)
2685                                 ast_log(LOG_DEBUG, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2686                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2687                 }
2688                 else {
2689                         if (option_debug)
2690                                 ast_log(LOG_DEBUG, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2691                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2692                 }
2693         }
2694
2695         return peer;
2696 }
2697
2698 static struct iax2_user *realtime_user(const char *username)
2699 {
2700         struct ast_variable *var;
2701         struct ast_variable *tmp;
2702         struct iax2_user *user=NULL;
2703
2704         var = ast_load_realtime("iaxusers", "name", username, NULL);
2705         if (!var)
2706                 return NULL;
2707
2708         tmp = var;
2709         while(tmp) {
2710                 /* Make sure it's not a peer only... */
2711                 if (!strcasecmp(tmp->name, "type")) {
2712                         if (strcasecmp(tmp->value, "friend") &&
2713                             strcasecmp(tmp->value, "user")) {
2714                                 return NULL;
2715                         } 
2716                 }
2717                 tmp = tmp->next;
2718         }
2719
2720         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2721
2722         ast_variables_destroy(var);
2723
2724         if (!user)
2725                 return NULL;
2726
2727         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2728                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2729                 AST_LIST_LOCK(&users);
2730                 AST_LIST_INSERT_HEAD(&users, user, entry);
2731                 AST_LIST_UNLOCK(&users);
2732         } else {
2733                 ast_set_flag(user, IAX_TEMPONLY);       
2734         }
2735
2736         return user;
2737 }
2738
2739 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2740 {
2741         char port[10];
2742         char regseconds[20];
2743         
2744         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2745         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2746         ast_update_realtime("iaxpeers", "name", peername, 
2747                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
2748                 "regseconds", regseconds, NULL);
2749 }
2750
2751 struct create_addr_info {
2752         int capability;
2753         unsigned int flags;
2754         int maxtime;
2755         int encmethods;
2756         int found;
2757         int sockfd;
2758         int adsi;
2759         char username[80];
2760         char secret[80];
2761         char outkey[80];
2762         char timezone[80];
2763         char prefs[32];
2764         char context[AST_MAX_CONTEXT];
2765         char peercontext[AST_MAX_CONTEXT];
2766         char mohinterpret[MAX_MUSICCLASS];
2767         char mohsuggest[MAX_MUSICCLASS];
2768 };
2769
2770 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2771 {
2772         struct iax2_peer *peer;
2773
2774         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2775         cai->sockfd = defaultsockfd;
2776         cai->maxtime = 0;
2777         sin->sin_family = AF_INET;
2778
2779         if (!(peer = find_peer(peername, 1))) {
2780                 cai->found = 0;
2781                 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
2782                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
2783                         return -1;
2784                 }
2785                 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2786                 /* use global iax prefs for unknown peer/user */
2787                 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2788                 return 0;
2789         }
2790
2791         cai->found = 1;
2792         
2793         /* if the peer has no address (current or default), return failure */
2794         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2795                 if (ast_test_flag(peer, IAX_TEMPONLY))
2796                         destroy_peer(peer);
2797                 return -1;
2798         }
2799
2800         /* if the peer is being monitored and is currently unreachable, return failure */
2801         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2802                 if (ast_test_flag(peer, IAX_TEMPONLY))
2803                         destroy_peer(peer);
2804                 return -1;
2805         }
2806
2807         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2808         cai->maxtime = peer->maxms;
2809         cai->capability = peer->capability;
2810         cai->encmethods = peer->encmethods;
2811         cai->sockfd = peer->sockfd;
2812         cai->adsi = peer->adsi;
2813         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2814         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2815         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2816         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2817         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2818         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2819         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2820         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2821         if (ast_strlen_zero(peer->dbsecret)) {
2822                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2823         } else {
2824                 char *family;
2825                 char *key = NULL;
2826
2827                 family = ast_strdupa(peer->dbsecret);
2828                 key = strchr(family, '/');
2829                 if (key)
2830                         *key++ = '\0';
2831                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2832                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2833                         if (ast_test_flag(peer, IAX_TEMPONLY))
2834                                 destroy_peer(peer);
2835                         return -1;
2836                 }
2837         }
2838
2839         if (peer->addr.sin_addr.s_addr) {
2840                 sin->sin_addr = peer->addr.sin_addr;
2841                 sin->sin_port = peer->addr.sin_port;
2842         } else {
2843                 sin->sin_addr = peer->defaddr.sin_addr;
2844                 sin->sin_port = peer->defaddr.sin_port;
2845         }
2846
2847         if (ast_test_flag(peer, IAX_TEMPONLY))
2848                 destroy_peer(peer);
2849
2850         return 0;
2851 }
2852
2853 static void __auto_congest(void *nothing)
2854 {
2855         int callno = PTR_TO_CALLNO(nothing);
2856         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2857         ast_mutex_lock(&iaxsl[callno]);
2858         if (iaxs[callno]) {
2859                 iaxs[callno]->initid = -1;
2860                 iax2_queue_frame(callno, &f);
2861                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2862         }
2863         ast_mutex_unlock(&iaxsl[callno]);
2864 }
2865
2866 static int auto_congest(void *data)
2867 {
2868 #ifdef SCHED_MULTITHREADED
2869         if (schedule_action(__auto_congest, data))
2870 #endif          
2871                 __auto_congest(data);
2872         return 0;
2873 }
2874
2875 static unsigned int iax2_datetime(const char *tz)
2876 {
2877         time_t t;
2878         struct tm tm;
2879         unsigned int tmp;
2880         time(&t);
2881         localtime_r(&t, &tm);
2882         if (!ast_strlen_zero(tz))
2883                 ast_localtime(&t, &tm, tz);
2884         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
2885         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
2886         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
2887         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
2888         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
2889         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
2890         return tmp;
2891 }
2892
2893 struct parsed_dial_string {
2894         char *username;
2895         char *password;
2896         char *key;
2897         char *peer;
2898         char *port;
2899         char *exten;
2900         char *context;
2901         char *options;
2902 };
2903
2904 /*!
2905  * \brief Parses an IAX dial string into its component parts.
2906  * \param data the string to be parsed
2907  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2908  * \return nothing
2909  *
2910  * This function parses the string and fills the structure
2911  * with pointers to its component parts. The input string
2912  * will be modified.
2913  *
2914  * \note This function supports both plaintext passwords and RSA
2915  * key names; if the password string is formatted as '[keyname]',
2916  * then the keyname will be placed into the key field, and the
2917  * password field will be set to NULL.
2918  *
2919  * \note The dial string format is:
2920  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
2921  */
2922 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2923 {
2924         if (ast_strlen_zero(data))
2925                 return;
2926
2927         pds->peer = strsep(&data, "/");
2928         pds->exten = strsep(&data, "/");
2929         pds->options = data;
2930
2931         if (pds->exten) {
2932                 data = pds->exten;
2933                 pds->exten = strsep(&data, "@");
2934                 pds->context = data;
2935         }
2936
2937         if (strchr(pds->peer, '@')) {
2938                 data = pds->peer;
2939                 pds->username = strsep(&data, "@");
2940                 pds->peer = data;
2941         }
2942
2943         if (pds->username) {
2944                 data = pds->username;
2945                 pds->username = strsep(&data, ":");
2946                 pds->password = data;
2947         }
2948
2949         data = pds->peer;
2950         pds->peer = strsep(&data, ":");
2951         pds->port = data;
2952
2953         /* check for a key name wrapped in [] in the secret position, if found,
2954            move it to the key field instead
2955         */
2956         if (pds->password && (pds->password[0] == '[')) {
2957                 pds->key = ast_strip_quoted(pds->password, "[", "]");
2958                 pds->password = NULL;
2959         }
2960 }
2961
2962 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2963 {
2964         struct sockaddr_in sin;
2965         char *l=NULL, *n=NULL, *tmpstr;
2966         struct iax_ie_data ied;
2967         char *defaultrdest = "s";
2968         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2969         struct parsed_dial_string pds;
2970         struct create_addr_info cai;
2971         struct ast_var_t *var;
2972         const char* osp_token_ptr;
2973         unsigned int osp_token_length;
2974         unsigned char osp_block_index;
2975         unsigned int osp_block_length;
2976         unsigned char osp_buffer[256];
2977
2978         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2979                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
2980                 return -1;
2981         }
2982
2983         memset(&cai, 0, sizeof(cai));
2984         cai.encmethods = iax2_encryption;
2985
2986         memset(&pds, 0, sizeof(pds));
2987         tmpstr = ast_strdupa(dest);
2988         parse_dial_string(tmpstr, &pds);
2989
2990         if (!pds.exten)
2991                 pds.exten = defaultrdest;
2992
2993         if (create_addr(pds.peer, &sin, &cai)) {
2994                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
2995                 return -1;
2996         }
2997
2998         if (!pds.username && !ast_strlen_zero(cai.username))
2999                 pds.username = cai.username;
3000         if (!pds.password && !ast_strlen_zero(cai.secret))
3001                 pds.password = cai.secret;
3002         if (!pds.key && !ast_strlen_zero(cai.outkey))
3003                 pds.key = cai.outkey;
3004         if (!pds.context && !ast_strlen_zero(cai.peercontext))
3005                 pds.context = cai.peercontext;
3006
3007         /* Keep track of the context for outgoing calls too */
3008         ast_copy_string(c->context, cai.context, sizeof(c->context));
3009
3010         if (pds.port)
3011                 sin.sin_port = htons(atoi(pds.port));
3012
3013         l = c->cid.cid_num;
3014         n = c->cid.cid_name;
3015
3016         /* Now build request */ 
3017         memset(&ied, 0, sizeof(ied));
3018
3019         /* On new call, first IE MUST be IAX version of caller */
3020         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
3021         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
3022         if (pds.options && strchr(pds.options, 'a')) {
3023                 /* Request auto answer */
3024                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
3025         }
3026
3027         iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
3028
3029         if (l) {
3030                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
3031                 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3032         } else {
3033                 if (n)
3034                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3035                 else
3036                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
3037         }
3038
3039         iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
3040         iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
3041
3042         if (n)
3043                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
3044         if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
3045                 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
3046
3047         if (!ast_strlen_zero(c->language))
3048                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
3049         if (!ast_strlen_zero(c->cid.cid_dnid))
3050                 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
3051         if (!ast_strlen_zero(c->cid.cid_rdnis))
3052                 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
3053
3054         if (pds.context)
3055                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
3056
3057         if (pds.username)
3058                 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
3059
3060         if (cai.encmethods)
3061                 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
3062
3063         ast_mutex_lock(&iaxsl[callno]);
3064
3065         if (!ast_strlen_zero(c->context))
3066                 ast_string_field_set(iaxs[callno], context, c->context);
3067
3068         if (pds.username)
3069                 ast_string_field_set(iaxs[callno], username, pds.username);
3070
3071         iaxs[callno]->encmethods = cai.encmethods;
3072
3073         iaxs[callno]->adsi = cai.adsi;
3074         
3075         ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
3076         ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
3077
3078         if (pds.key)
3079                 ast_string_field_set(iaxs[callno], outkey, pds.key);
3080         if (pds.password)
3081                 ast_string_field_set(iaxs[callno], secret, pds.password);
3082
3083         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
3084         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
3085         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
3086         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
3087
3088         if (iaxs[callno]->maxtime) {
3089                 /* Initialize pingtime and auto-congest time */
3090                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
3091                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
3092         } else if (autokill) {
3093                 iaxs[callno]->pingtime = autokill / 2;
3094                 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
3095         }
3096
3097         /* Check if there is an OSP token set by IAXCHANINFO function */
3098         osp_token_ptr = iaxs[callno]->osptoken;
3099         if (!ast_strlen_zero(osp_token_ptr)) {
3100                 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
3101                         osp_block_index = 0;
3102                         while (osp_token_length > 0) {
3103                                 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
3104                                 osp_buffer[0] = osp_block_index;
3105                                 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
3106                                 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
3107                                 osp_block_index++;
3108                                 osp_token_ptr += osp_block_length;
3109                                 osp_token_length -= osp_block_length;
3110                         } 
3111                 } else
3112                         ast_log(LOG_WARNING, "OSP token is too long\n");
3113         } else if (option_debug && iaxdebug)
3114                 ast_log(LOG_DEBUG, "OSP token is undefined\n");
3115
3116         /* send the command using the appropriate socket for this peer */
3117         iaxs[callno]->sockfd = cai.sockfd;
3118
3119         /* Add remote vars */
3120         AST_LIST_TRAVERSE(&c->varshead, var, entries) {
3121                 if (!strncmp(ast_var_name(var), "~IAX2~", strlen("~IAX2~"))) {
3122                         char tmp[256];
3123                         int i;
3124                         /* Automatically divide the value up into sized chunks */
3125                         for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) - strlen("~IAX2~") + 1)) {
3126                                 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var) + strlen("~IAX2~"), ast_var_value(var) + i);
3127                                 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
3128                         }
3129                 }
3130         }
3131
3132         /* Transmit the string in a "NEW" request */
3133         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
3134
3135         ast_mutex_unlock(&iaxsl[callno]);
3136         ast_setstate(c, AST_STATE_RINGING);
3137         
3138         return 0;
3139 }
3140
3141 static int iax2_hangup(struct ast_channel *c) 
3142 {
3143         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3144         int alreadygone;
3145         struct iax_ie_data ied;
3146         memset(&ied, 0, sizeof(ied));
3147         ast_mutex_lock(&iaxsl[callno]);
3148         if (callno && iaxs[callno]) {
3149                 if (option_debug)
3150                         ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
3151                 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
3152                 /* Send the hangup unless we have had a transmission error or are already gone */
3153                 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
3154                 if (!iaxs[callno]->error && !alreadygone) 
3155                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
3156                 /* Explicitly predestroy it */
3157                 iax2_predestroy(callno);
3158                 /* If we were already gone to begin with, destroy us now */
3159                 if (alreadygone) {
3160                         if (option_debug)
3161                                 ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
3162                         iax2_destroy(callno);
3163                 }
3164         }
3165         ast_mutex_unlock(&iaxsl[callno]);
3166         if (option_verbose > 2) 
3167                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
3168         return 0;
3169 }
3170
3171 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
3172 {
3173         struct ast_option_header *h;
3174         int res;
3175
3176         switch (option) {
3177         case AST_OPTION_TXGAIN:
3178         case AST_OPTION_RXGAIN:
3179                 /* these two cannot be sent, because they require a result */
3180                 errno = ENOSYS;
3181                 return -1;
3182         default:
3183                 if (!(h = ast_malloc(datalen + sizeof(*h))))
3184                         return -1;
3185
3186                 h->flag = AST_OPTION_FLAG_REQUEST;
3187                 h->option = htons(option);
3188                 memcpy(h->data, data, datalen);
3189                 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
3190                                           AST_CONTROL_OPTION, 0, (unsigned char *) h,
3191                                           datalen + sizeof(*h), -1);
3192                 ast_free(h);
3193                 return res;
3194         }
3195 }
3196
3197 static struct ast_frame *iax2_read(struct ast_channel *c) 
3198 {
3199         ast_log(LOG_NOTICE, "I should never be called!\n");
3200         return &ast_null_frame;
3201 }
3202
3203 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
3204 {
3205         int res;
3206         struct iax_ie_data ied0;
3207         struct iax_ie_data ied1;
3208         unsigned int transferid = (unsigned int)ast_random();
3209         memset(&ied0, 0, sizeof(ied0));
3210         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
3211         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
3212         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
3213
3214         memset(&ied1, 0, sizeof(ied1));
3215         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
3216         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
3217         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
3218         
3219         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
3220         if (res)
3221                 return -1;
3222         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
3223         if (res)
3224                 return -1;
3225         iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3226         iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3227         return 0;
3228 }
3229
3230 static void lock_both(unsigned short callno0, unsigned short callno1)
3231 {
3232         ast_mutex_lock(&iaxsl[callno0]);
3233         while (ast_mutex_trylock(&iaxsl[callno1])) {
3234                 ast_mutex_unlock(&iaxsl[callno0]);
3235                 usleep(10);
3236                 ast_mutex_lock(&iaxsl[callno0]);
3237         }
3238 }
3239
3240 static void unlock_both(unsigned short callno0, unsigned short callno1)
3241 {
3242         ast_mutex_unlock(&iaxsl[callno1]);
3243         ast_mutex_unlock(&iaxsl[callno0]);
3244 }
3245
3246 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)
3247 {
3248         struct ast_channel *cs[3];
3249         struct ast_channel *who, *other;
3250         int to = -1;
3251         int res = -1;
3252         int transferstarted=0;
3253         struct ast_frame *f;
3254         unsigned short callno0 = PTR_TO_CALLNO(c0->tech_pvt);
3255         unsigned short callno1 = PTR_TO_CALLNO(c1->tech_pvt);
3256         struct timeval waittimer = {0, 0}, tv;
3257
3258         lock_both(callno0, callno1);
3259         if (!iaxs[callno0] || !iaxs[callno1]) {
3260                 unlock_both(callno0, callno1);
3261                 return AST_BRIDGE_FAILED;
3262         }
3263         /* Put them in native bridge mode */
3264         if (!flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) {
3265                 iaxs[callno0]->bridgecallno = callno1;
3266                 iaxs[callno1]->bridgecallno = callno0;
3267         }
3268         unlock_both(callno0, callno1);
3269
3270         /* If not, try to bridge until we can execute a transfer, if we can */
3271         cs[0] = c0;
3272         cs[1] = c1;
3273         for (/* ever */;;) {
3274                 /* Check in case we got masqueraded into */
3275                 if ((c0->tech != &iax2_tech) || (c1->tech != &iax2_tech)) {
3276                         if (option_verbose > 2)
3277                                 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
3278                         /* Remove from native mode */
3279                         if (c0->tech == &iax2_tech) {
3280                                 ast_mutex_lock(&iaxsl[callno0]);
3281                                 iaxs[callno0]->bridgecallno = 0;
3282                                 ast_mutex_unlock(&iaxsl[callno0]);
3283                         }
3284                         if (c1->tech == &iax2_tech) {
3285                                 ast_mutex_lock(&iaxsl[callno1]);
3286                                 iaxs[callno1]->bridgecallno = 0;
3287                                 ast_mutex_unlock(&iaxsl[callno1]);
3288                         }
3289                         return AST_BRIDGE_FAILED_NOWARN;
3290                 }
3291                 if (c0->nativeformats != c1->nativeformats) {
3292                         if (option_verbose > 2) {
3293                                 char buf0[255];
3294                                 char buf1[255];
3295                                 ast_getformatname_multiple(buf0, sizeof(buf0) -1, c0->nativeformats);
3296                                 ast_getformatname_multiple(buf1, sizeof(buf1) -1, c1->nativeformats);
3297                                 ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs %d[%s] %d[%s] , can't native bridge...\n", c0->nativeformats, buf0, c1->nativeformats, buf1);
3298                         }
3299                         /* Remove from native mode */
3300                         lock_both(callno0, callno1);
3301                         if (iaxs[callno0])
3302                                 iaxs[callno0]->bridgecallno = 0;
3303                         if (iaxs[callno1])
3304                                 iaxs[callno1]->bridgecallno = 0;
3305                         unlock_both(callno0, callno1);
3306                         return AST_BRIDGE_FAILED_NOWARN;
3307                 }
3308                 /* check if transfered and if we really want native bridging */
3309                 if (!transferstarted && !ast_test_flag(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag(iaxs[callno1], IAX_NOTRANSFER)) {
3310                         /* Try the transfer */
3311                         if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
3312                                                         ast_test_flag(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag(iaxs[callno1], IAX_TRANSFERMEDIA)))
3313                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
3314                         transferstarted = 1;
3315                 }
3316                 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
3317                         /* Call has been transferred.  We're no longer involved */
3318                         gettimeofday(&tv, NULL);
3319                         if (ast_tvzero(waittimer)) {
3320                                 waittimer = tv;
3321                         } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
3322                                 c0->_softhangup |= AST_SOFTHANGUP_DEV;
3323                                 c1->_softhangup |= AST_SOFTHANGUP_DEV;
3324                                 *fo = NULL;
3325                                 *rc = c0;
3326                                 res = AST_BRIDGE_COMPLETE;
3327                                 break;
3328                         }
3329                 }
3330                 to = 1000;
3331                 who = ast_waitfor_n(cs, 2, &to);
3332                 if (timeoutms > -1) {
3333                         timeoutms -= (1000 - to);
3334                         if (timeoutms < 0)
3335                                 timeoutms = 0;
3336                 }
3337                 if (!who) {
3338                         if (!timeoutms) {
3339                                 res = AST_BRIDGE_RETRY;
3340                                 break;
3341                         }
3342                         if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
3343                                 res = AST_BRIDGE_FAILED;
3344                                 break;
3345                         }
3346                         continue;
3347                 }
3348                 f = ast_read(who);
3349                 if (!f) {
3350                         *fo = NULL;
3351                         *rc = who;
3352                         res = AST_BRIDGE_COMPLETE;
3353                         break;
3354                 }
3355                 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3356                         *fo = f;
3357                         *rc = who;
3358                         res =  AST_BRIDGE_COMPLETE;
3359                         break;
3360                 }
3361                 other = (who == c0) ? c1 : c0;  /* the 'other' channel */
3362                 if ((f->frametype == AST_FRAME_VOICE) ||
3363                     (f->frametype == AST_FRAME_TEXT) ||
3364                     (f->frametype == AST_FRAME_VIDEO) || 
3365                     (f->frametype == AST_FRAME_IMAGE) ||
3366                     (f->frametype == AST_FRAME_DTMF)) {
3367                         /* monitored dtmf take out of the bridge.
3368                          * check if we monitor the specific source.
3369                          */
3370                         int monitored_source = (who == c0) ? AST_BRIDGE_DTMF_CHANNEL_0 : AST_BRIDGE_DTMF_CHANNEL_1;
3371                         if (f->frametype == AST_FRAME_DTMF && (flags & monitored_source)) {
3372                                 *rc = who;
3373                                 *fo = f;
3374                                 res = AST_BRIDGE_COMPLETE;
3375                                 /* Remove from native mode */
3376                                 break;
3377                         }
3378                         /* everything else goes to the other side */
3379                         ast_write(other, f);
3380                 }
3381                 ast_frfree(f);
3382                 /* Swap who gets priority */
3383                 cs[2] = cs[0];
3384                 cs[0] = cs[1];
3385                 cs[1] = cs[2];
3386         }
3387         lock_both(callno0, callno1);
3388         if(iaxs[callno0])
3389                 iaxs[callno0]->bridgecallno = 0;
3390         if(iaxs[callno1])
3391                 iaxs[callno1]->bridgecallno = 0;
3392         unlock_both(callno0, callno1);
3393         return res;
3394 }
3395
3396 static int iax2_answer(struct ast_channel *c)
3397 {
3398         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3399         if (option_debug)
3400                 ast_log(LOG_DEBUG, "Answering IAX2 call\n");
3401         ast_mutex_lock(&iaxsl[callno]);
3402         if (iaxs[callno])
3403                 iax2_ami_channelupdate(iaxs[callno]);
3404         ast_mutex_unlock(&iaxsl[callno]);
3405         return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
3406 }
3407
3408 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
3409 {
3410         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3411         struct chan_iax2_pvt *pvt;
3412         int res = 0;
3413
3414         if (option_debug && iaxdebug)
3415                 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
3416
3417         ast_mutex_lock(&iaxsl[callno]);
3418         pvt = iaxs[callno];
3419         if (!strcasecmp(pvt->mohinterpret, "passthrough")) {
3420                 res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
3421                 ast_mutex_unlock(&iaxsl[callno]);
3422                 return res;
3423         }
3424
3425         switch (condition) {
3426         case AST_CONTROL_HOLD:
3427                 ast_moh_start(c, data, pvt->mohinterpret);
3428                 break;
3429         case AST_CONTROL_UNHOLD:
3430                 ast_moh_stop(c);
3431                 break;
3432         default:
3433                 res = send_command(pvt, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
3434         }
3435
3436         ast_mutex_unlock(&iaxsl[callno]);
3437
3438         return res;
3439 }
3440         
3441 static int iax2_transfer(struct ast_channel *c, const char *dest)
3442 {
3443         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3444         struct iax_ie_data ied = { "", };
3445         char tmp[256], *context;
3446         ast_copy_string(tmp, dest, sizeof(tmp));
3447         context = strchr(tmp, '@');
3448         if (context) {
3449                 *context = '\0';
3450                 context++;
3451         }
3452         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
3453         if (context)
3454                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
3455         if (option_debug)
3456                 ast_log(LOG_DEBUG, "Transferring '%s' to '%s'\n", c->name, dest);
3457         return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
3458 }
3459         
3460 static int iax2_getpeertrunk(struct sockaddr_in sin)
3461 {
3462         struct iax2_peer *peer = NULL;
3463         int res = 0;
3464
3465         AST_LIST_LOCK(&peers);
3466         AST_LIST_TRAVERSE(&peers, peer, entry) {
3467                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
3468                     (peer->addr.sin_port == sin.sin_port)) {
3469                         res = ast_test_flag(peer, IAX_TRUNK);
3470                         break;
3471                 }
3472         }
3473         AST_LIST_UNLOCK(&peers);
3474
3475         return res;
3476 }
3477
3478 /*! \brief  Create new call, interface with the PBX core */
3479 static struct ast_channel *ast_iax2_new(int callno, int state, int capability, unsigned int delaypbx)
3480 {
3481         struct ast_channel *tmp;
3482         struct chan_iax2_pvt *i;
3483         struct ast_variable *v = NULL;
3484
3485         if (!(i = iaxs[callno])) {
3486                 ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
3487                 return NULL;
3488         }
3489
3490         /* Don't hold call lock */
3491         ast_mutex_unlock(&iaxsl[callno]);
3492         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);
3493         ast_mutex_lock(&iaxsl[callno]);
3494         iax2_ami_channelupdate(i);
3495         if (!tmp)
3496                 return NULL;
3497         tmp->tech = &iax2_tech;
3498         /* We can support any format by default, until we get restricted */
3499         tmp->nativeformats = capability;
3500         tmp->readformat = ast_best_codec(capability);
3501         tmp->writeformat = ast_best_codec(capability);
3502         tmp->tech_pvt = CALLNO_TO_PTR(i->callno);
3503
3504         /* Don't use ast_set_callerid() here because it will
3505          * generate a NewCallerID event before the NewChannel event */
3506         tmp->cid.cid_num = ast_strdup(i->cid_num);
3507         tmp->cid.cid_name = ast_strdup(i->cid_name);
3508         if (!ast_strlen_zero(i->ani))
3509                 tmp->cid.cid_ani = ast_strdup(i->ani);
3510         else
3511                 tmp->cid.cid_ani = ast_strdup(i->cid_num);
3512         tmp->cid.cid_dnid = ast_strdup(i->dnid);
3513         tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
3514         tmp->cid.cid_pres = i->calling_pres;
3515         tmp->cid.cid_ton = i->calling_ton;
3516         tmp->cid.cid_tns = i->calling_tns;
3517         if (!ast_strlen_zero(i->language))
3518                 ast_string_field_set(tmp, language, i->language);
3519         if (!ast_strlen_zero(i->accountcode))
3520                 ast_string_field_set(tmp, accountcode, i->accountcode);
3521         if (i->amaflags)
3522                 tmp->amaflags = i->amaflags;
3523         ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
3524         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
3525         if (i->adsi)
3526                 tmp->adsicpe = i->peeradsicpe;
3527         else
3528                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
3529         i->owner = tmp;
3530         i->capability = capability;
3531
3532         for (v = i->vars ; v ; v = v->next)
3533                 pbx_builtin_setvar_helper(tmp, v->name, v->value);
3534
3535         if (delaypbx) {
3536                 ast_set_flag(i, IAX_DELAYPBXSTART);
3537         } else if (state != AST_STATE_DOWN) {
3538                 if (ast_pbx_start(tmp)) {
3539                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
3540                         ast_hangup(tmp);
3541                         i->owner = NULL;
3542                         return NULL;
3543                 }
3544         }
3545
3546         ast_module_ref(ast_module_info->self);
3547         return tmp;
3548 }
3549
3550 static unsigned int calc_txpeerstamp(struct iax2_trunk_peer *tpeer, int sampms, struct timeval *tv)
3551 {
3552         unsigned long int mssincetx; /* unsigned to handle overflows */
3553         long int ms, pred;
3554
3555         tpeer->trunkact = *tv;
3556         mssincetx = ast_tvdiff_ms(*tv, tpeer->lasttxtime);
3557         if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
3558                 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
3559                 tpeer->txtrunktime = *tv;
3560                 tpeer->lastsent = 999999;
3561         }
3562         /* Update last transmit time now */
3563         tpeer->lasttxtime = *tv;
3564         
3565         /* Calculate ms offset */
3566         ms = ast_tvdiff_ms(*tv, tpeer->txtrunktime);
3567         /* Predict from last value */
3568         pred = tpeer->lastsent + sampms;
3569         if (abs(ms - pred) < MAX_TIMESTAMP_SKEW)
3570                 ms = pred;
3571         
3572         /* We never send the same timestamp twice, so fudge a little if we must */
3573         if (ms == tpeer->lastsent)
3574                 ms = tpeer->lastsent + 1;
3575         tpeer->lastsent = ms;
3576         return ms;
3577 }
3578
3579 static unsigned int fix_peerts(struct timeval *tv, int callno, unsigned int ts)
3580 {
3581         long ms;        /* NOT unsigned */
3582         if (ast_tvzero(iaxs[callno]->rxcore)) {
3583                 /* Initialize rxcore time if appropriate */
3584                 gettimeofday(&iaxs[callno]->rxcore, NULL);
3585                 /* Round to nearest 20ms so traces look pretty */
3586                 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
3587         }
3588         /* Calculate difference between trunk and channel */
3589         ms = ast_tvdiff_ms(*tv, iaxs[callno]->rxcore);
3590         /* Return as the sum of trunk time and the difference between trunk and real time */
3591         return ms + ts;
3592 }
3593
3594 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
3595 {
3596         int ms;
3597         int voice = 0;
3598         int genuine = 0;
3599         int adjust;
3600         struct timeval *delivery = NULL;
3601
3602
3603         /* What sort of frame do we have?: voice is self-explanatory
3604            "genuine" means an IAX frame - things like LAGRQ/RP, PING/PONG, ACK
3605            non-genuine frames are CONTROL frames [ringing etc], DTMF
3606            The "genuine" distinction is needed because genuine frames must get a clock-based timestamp,
3607            the others need a timestamp slaved to the voice frames so that they go in sequence
3608         */
3609         if (f) {
3610                 if (f->frametype == AST_FRAME_VOICE) {
3611                         voice = 1;
3612                         delivery = &f->delivery;
3613                 } else if (f->frametype == AST_FRAME_IAX) {
3614                         genuine = 1;
3615                 } else if (f->frametype == AST_FRAME_CNG) {
3616                         p->notsilenttx = 0;     
3617                 }
3618         }
3619         if (ast_tvzero(p->offset)) {
3620                 gettimeofday(&p->offset, NULL);
3621                 /* Round to nearest 20ms for nice looking traces */
3622                 p->offset.tv_usec -= p->offset.tv_usec % 20000;
3623         }
3624         /* If the timestamp is specified, just send it as is */
3625         if (ts)
3626                 return ts;
3627         /* If we have a time that the frame arrived, always use it to make our timestamp */
3628         if (delivery && !ast_tvzero(*delivery)) {
3629                 ms = ast_tvdiff_ms(*delivery, p->offset);
3630                 if (option_debug > 2 && iaxdebug)
3631                         ast_log(LOG_DEBUG, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
3632         } else {
3633                 ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
3634                 if (ms < 0)
3635                         ms = 0;
3636                 if (voice) {
3637                         /* On a voice frame, use predicted values if appropriate */
3638                         if (p->notsilenttx && abs(ms - p->nextpred) <= MAX_TIMESTAMP_SKEW) {
3639                                 /* Adjust our txcore, keeping voice and non-voice synchronized */
3640                                 /* AN EXPLANATION:
3641                                    When we send voice, we usually send "calculated" timestamps worked out
3642                                    on the basis of the number of samples sent. When we send other frames,
3643                                    we usually send timestamps worked out from the real clock.
3644                                    The problem is that they can tend to drift out of step because the 
3645                                    source channel's clock and our clock may not be exactly at the same rate.
3646                                    We fix this by continuously "tweaking" p->offset.  p->offset is "time zero"
3647                                    for this call.  Moving it adjusts timestamps for non-voice frames.
3648                                    We make the adjustment in the style of a moving average.  Each time we
3649