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