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