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