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